# MYP-Plattform Projektübersicht

## 1. Projektüberblick

Die MYP-Plattform (My Young Printer) ist ein Verwaltungssystem für 3D-Drucker mit folgenden Kernfunktionen:

- Zentrale Verwaltung mehrerer 3D-Drucker über ein Netzwerk
- Steuerung der Stromversorgung über SmartPlugs (Tapo P110) 
- Benutzer- und Auftragsmanagement mit Reservierungsfunktionalität
- Offline-Fähigkeit durch Service Worker Integration
- REST-API für Frontend und externe Dienste
- Automatisierte Auftrags-Planung und -Ausführung via Scheduler
- Verschlüsselte Kommunikation über HTTPS mit selbstsignierten Zertifikaten
- Kiosk-Modus für Informationsdisplays und öffentliche Terminals

Das Backend basiert auf Flask (Python) und nutzt eine SQLite-Datenbank für die Datenspeicherung.

## 2. Netzwerk-Architektur & Digitale Vernetzung

Die MYP-Plattform setzt auf eine verteilte Netzwerk-Architektur:

### Hauptkomponenten

- **Flask-Backend-Server**: Stellt die zentrale API bereit (Port 5000)
- **Smart-Plugs (Tapo P110)**: Steuerung der Drucker-Stromversorgung via IP-Netzwerk
- **3D-Drucker**: Werden als Netzwerkgeräte mit festen IP-Adressen konfiguriert
- **Frontend**: Als Web-App mit Offline-Funktionalität konzipiert
- **PWA-Funktionalität**: Service Worker für Offline-Betrieb und Cache-Management
- **Kiosk-Displays**: Raspberry Pi mit Chrome im Kiosk-Modus

### Netzwerk-Topologie

```
                          ┌──────────────────┐
                          │  Command Center  │
                          │  (192.168.0.1)   │
                          └──────────┬───────┘
                                     │
                                     ▼
┌───────────────┐      ┌─────────────────────┐     ┌──────────────┐
│ Frontend/PWA  │◄────►│   Flask-Backend     │◄────►│ Smart-Plugs  │
│(192.168.0.105)│      │   (192.168.0.105)   │     │(192.168.0.1xx)│
└───────┬───────┘      └─────────┬───────────┘     └──────┬────────┘
        │                        │                        │
        │                        │                        ▼
┌───────▼───────┐                │               ┌────────────────┐
│  Kiosk-Mode   │                │               │   3D-Drucker   │
│ (10.0.0.1-10) │                │               │(192.168.0.1xx) │
└───────────────┘                ▼               └────────────────┘
                    ┌─────────────────────┐
                    │ Ad-hoc Pi-Netzwerk  │
                    │    (10.0.0.x/24)    │
                    └─────────────────────┘
```

### Kommunikationsprotokolle

- **HTTPS/REST**: Zwischen Frontend und Backend (Port 5000)
- **JSON**: Standardformat für Datenaustausch
- **Tapo-Protokoll**: Für Smart-Plug-Steuerung via PyP110-Bibliothek
- **SQLite**: Lokale Datenbankanbindung
- **TLS 1.2/1.3**: Verschlüsselte Kommunikation mit selbstsignierten Zertifikaten

### Vernetzungs-Features

- IP-basierte Identifikation der Drucker im lokalen Netzwerk
- SmartPlug-Integration für Fernsteuerung der Stromversorgung
- Offline-Betriebsmodus mit synchronisierenden Service Workern
- Automatische Erkennung der Drucker-Status via Netzwerk-Polling
- Kiosk-Modus mit automatischem Start nach Systemneustart
- Command Center für zentrale Verwaltung aller Komponenten

## 3. Hauptkomponenten des Backends

### Core-Komponenten

- **app.py**: Hauptanwendung mit API-Endpunkten und Route-Definitionen
- **models.py**: Datenbankmodelle für User, Printer, Job und Stats
- **job_scheduler.py**: Background-Task-Scheduler für automatisierte Prozesse
- **Blueprints**: Modulare Komponenten für Auth, User, etc.

### API-Layer

Das Backend stellt eine umfassende REST-API bereit:
- **User Management**: Authentifizierung, Profilmanagement
- **Printer Management**: Druckerstatus, Steuerung
- **Job Management**: Auftragsplanung, -verwaltung und -überwachung
- **Stats API**: Statistiken und Auswertungen
- **Kiosk API**: Steuerung der Kiosk-Displays

### SmartPlug-Integration

- Nutzung der PyP110-Bibliothek für die Kommunikation mit Tapo-SmartPlugs
- Automatisierte Steuerung der Stromversorgung basierend auf Jobplanung
- Status-Monitoring und Fehlerbehandlung

### SSL/HTTPS-Implementierung

- Selbstsignierte Zertifikate für verschlüsselte Kommunikation
- Automatische Zertifikatsgenerierung während der Installation
- Konfigurierbare Zertifikatslaufzeit (Standard: 10 Jahre)
- Prüfwerkzeuge für Zertifikatsstatus und -gültigkeit

## 4. Datenbankmodell & Scheduler-Logik

### Datenbankmodelle

- **User**: Benutzer-Accounts mit Rollenmanagement
- **Printer**: 3D-Drucker mit Netzwerkkonfiguration und Status
- **Job**: Druckaufträge mit Zeitplanung und Statusinformationen
- **Stats**: Globale Statistikdaten

### Scheduler-Architektur

Der BackgroundTaskScheduler bietet:
- Registrierung von Task-Funktionen mit individuellen Intervallen
- Zeitgesteuerte Ausführung im Hintergrund
- Kommunikation mit Smart-Plugs zur zeitgesteuerten Stromversorgung
- Automatisches Job-Management

### Datenbanksicherung

- SQLite-Datenbank mit Backup-Funktionalität
- Einfache Administrierbarkeit durch übersichtliche Tabellenstruktur

## 5. API-Endpunkte

| Endpunkt | Methode | Funktion | Authentifizierung |
|----------|---------|----------|-------------------|
| /api/jobs | GET | Auftragsliste abrufen | Ja |
| /api/jobs | POST | Neuen Auftrag erstellen | Ja |
| /api/jobs/{id} | GET | Auftragsdetails abrufen | Ja, Besitzer |
| /api/jobs/{id}/extend | POST | Auftrag verlängern | Ja, Besitzer |
| /api/jobs/{id}/finish | POST | Auftrag abschließen | Ja |
| /api/printers | GET | Druckerliste abrufen | Ja |
| /api/printers | POST | Neuen Drucker anlegen | Ja, Admin |
| /api/printers/status | GET | Status aller Drucker | Ja |
| /api/stats | GET | Statistiken abrufen | Ja |
| /api/users | GET | Benutzerliste | Ja, Admin |
| /api/users | POST | Neuen Benutzer anlegen | Ja, Admin |
| /api/scheduler/status | GET | Scheduler-Status | Ja |
| /api/scheduler/start | POST | Scheduler starten | Ja, Admin |
| /api/scheduler/stop | POST | Scheduler stoppen | Ja, Admin |
| /api/kiosk/status | GET | Kiosk-Status | Ja |
| /api/kiosk/activate | POST | Kiosk aktivieren | Ja, Admin |
| /api/kiosk/deactivate | POST | Kiosk deaktivieren | Ja, Admin |
| /auth/login | POST | Anmelden | Nein |
| /auth/logout | GET/POST | Abmelden | Ja |

## 6. Sicherheits- & Zugriffskonzept

### Authentifizierung

- Flask-Login für Session-Management
- BCrypt für sichere Passwort-Hashes
- Role-Based Access Control (RBAC) mit Admin- und Benutzerrollen
- Eigene Decorator für erweiterte Zugriffskontrollen (z.B. job_owner_required)

### Netzwerksicherheit

- HTTPS mit selbstsignierten TLS-Zertifikaten
- CORS-Konfiguration für sichere Cross-Origin-Requests
- Sicherheitsheader im Response (X-Content-Type-Options, X-Frame-Options)
- Keine sensiblen Daten in URLs oder Query-Parametern

### Offline-Sicherheit

- Selektive Cache-Strategie für sensible Daten
- Ausschluss von API-Endpunkten mit vertraulichen Informationen vom Caching
- Eingeschränkte Funktionalität im Offline-Modus

## 7. Build- & Deployment-Ablauf

### Installationsprozess

Die Installation der MYP-Plattform erfolgt über verschiedene Shell-Skripte:

- **setup_myp.sh**: Hauptinstallationsskript (Command Center)
  - Standardinstallation mit HTTPS-Unterstützung
  - Kiosk-Modus-Installation (gehärtete Variante)
  - Netzwerk- und DNS-Konfiguration
  - Systemüberwachung und Logging

- **create_ssl_cert.sh**: Generiert selbstsignierte Zertifikate
  - Unterstützt Multiple-SAN-Entries (Hostname, IP-Adressen)
  - Konfigurierbare Zertifikatslaufzeit
  - Automatische Fehlerbehandlung

- **ssl_check.sh**: Prüft SSL-Zertifikatsstatus
  - Validiert Gültigkeitsdauer
  - Zeigt Fingerprint und Subject-Details
  - Warnt vor bald ablaufenden Zertifikaten

### Backend-Deployment

- Python 3.11 venv-Umgebung
- Konfigurierbare Entwicklungs- und Produktionsumgebungen
- Log-Rotation und strukturierte Logging-Hierarchie
- SSL/TLS-Unterstützung mit automatischer Zertifikatsgenerierung

### Kiosk-Modus

- Basiert auf Raspberry Pi mit Chromium Browser
- Automatischer Start im Vollbildmodus nach Boot
- Deaktivierung von Fehlerdialogen und Warnungen
- Integrierte Überwachung und Watchdog-Funktionalität
- Spezielle Konfiguration für öffentliche Informationsdisplays
- Ignoriert SSL-Zertifikatswarnungen für selbstsignierte Zertifikate

### Command Center

- Zentrales Verwaltungstool mit CLI-Interface
- Integrierte Systemdiagnose und -überwachung
- Einfache Verwaltung von SSL-Zertifikaten
- Fernsteuerung von Kiosk-Displays
- Netzwerk- und IP-Konfiguration
- Dienst-Management (Start/Stop/Neustart)

### Frontend-Integration

- Tailwind CSS für responsive UI
- CLI-Befehle für Tailwind-Kompilierung
- Service Worker für PWA-Funktionalität
- HTTPS-Unterstützung mit Proxy-Konfiguration

### Systemd-Integration

- Automatischer Start des Backend-Servers
- Überwachung und Neustart bei Fehlern
- Logging-Integration in systemd-journal

## 8. Offene Punkte / Verbesserungspotenzial

### Digitale Vernetzung

- OPC UA oder MQTT-Integration für direktere Druckerkommunikation
- Echtzeit-Statusüberwachung statt Polling
- Push-Benachrichtigungen für Fertigstellungs- und Fehlerereignisse
- VPN-Unterstützung für Remote-Zugriff außerhalb des lokalen Netzwerks

### Sicherheit

- OAuth2-Integration für externe Authentifizierungsquellen
- Zwei-Faktor-Authentifizierung
- Zertifikatsbasierte Geräteauthentifizierung für SmartPlugs
- Letsencrypt-Integration für vertrauenswürdige Zertifikate

### Skalierbarkeit

- Migration von SQLite zu einer skalierbaren Datenbank
- Containerisierung mit Docker für einfacheres Deployment
- Horizontale Skalierung der Backend-Komponenten 