add docs and co

packages/reservation-platform/README.md

@@ -1,15 +1,32 @@
-Raspberry Pi Settings
+# MYP - Manage Your Printer
 
-user: myp
-password: -
-Raspbian Lite
-MACvLAN (currently 3 ips, 2 corp, 1 local)
+MYP (Manage Your Printer) ist eine Webanwendung zur Reservierung von 3D-Druckern.
+Sie wurde im Rahmen des Abschlussprojektes der Fachinformatiker Ausbildung für Daten- und Prozessanalyse für die Technische Berufsausbildung des Mercedes-Benz Werkes Berlin-Marienfelde entwickelt.
 
----
+## Deployment
 
-Deployment steps:
-1. docker/build.sh
-2. docker/save.sh caddy:2.8 myp-rp:latest
-3. (on pi) docker/deploy.sh
+### Voraussetzungen
+
+- Netzwerk auf Raspberry Pi ist eingerichtet
+- Docker ist installiert
+
+### Schritte
+
+1. Docker-Container bauen (docker/build.sh)
+2. Docker-Container speichern (docker/save.sh caddy:2.8 myp-rp:latest)
+3. Docker-Container auf Raspberry Pi bereitstellen (docker/deploy.sh)
+
+## Entwicklerinformationen
+
+### Raspberry Pi Einstellungen
+
+Auf dem Raspberry Pi wurde Raspbian Lite installiert.
+Unter /srv/* sind die Projektdateien zu finden.
+
+### Anmeldedaten
+
+```
+Benutzer: myp
+Passwort: (persönlich bekannt)
+```
 
----

packages/reservation-platform/docs/Admin-Dashboard.md

@@ -0,0 +1,116 @@
+# **Detaillierte Dokumentation des Admin-Dashboards**
+
+In diesem Abschnitt werde ich die Funktionen und Nutzung des Admin-Dashboards genauer beschreiben, einschließlich der verschiedenen Module, Diagramme und deren Zweck.
+
+---
+
+## **1. Überblick über das Admin-Dashboard**
+
+Das Admin-Dashboard ist der zentrale Verwaltungsbereich für Administratoren. Es bietet Funktionen wie die Verwaltung von Druckern, Benutzern und Druckaufträgen sowie detaillierte Statistiken und Analysen.
+
+### **1.1. Navigation**
+Das Dashboard enthält ein Sidebar-Menü mit den folgenden Hauptbereichen:
+1. **Dashboard:** Übersicht der wichtigsten Statistiken.
+2. **Benutzer:** Verwaltung von Benutzerkonten.
+3. **Drucker:** Hinzufügen, Bearbeiten und Verwalten von Druckern.
+4. **Druckaufträge:** Einsicht in alle Druckaufträge und deren Status.
+5. **Einstellungen:** Konfiguration der Anwendung.
+6. **Über MYP:** Informationen über das Projekt und den Entwickler.
+
+Die Sidebar wird in der Datei `src/app/admin/admin-sidebar.tsx` definiert und dynamisch basierend auf der aktuellen Seite hervorgehoben.
+
+---
+
+## **2. Funktionen des Admin-Dashboards**
+
+### **2.1. Benutzerverwaltung**
+- **Datei:** `src/app/admin/users/page.tsx`
+- **Beschreibung:** Ermöglicht das Anzeigen, Bearbeiten und Löschen von Benutzerkonten.
+- **Funktionen:**
+  - Anzeige einer Liste aller registrierten Benutzer.
+  - Bearbeiten von Benutzerrollen (z. B. „admin“ oder „user“).
+  - Deaktivieren oder Löschen von Benutzerkonten.
+
+---
+
+### **2.2. Druckerverwaltung**
+- **Datei:** `src/app/admin/printers/page.tsx`
+- **Beschreibung:** Verwaltung der Drucker, einschließlich Hinzufügen, Bearbeiten und Deaktivieren.
+- **Funktionen:**
+  - Statusanzeige der Drucker (aktiv/inaktiv).
+  - Hinzufügen neuer Drucker mit Namen und Beschreibung.
+  - Löschen oder Bearbeiten bestehender Drucker.
+
+---
+
+### **2.3. Druckaufträge**
+- **Datei:** `src/app/admin/jobs/page.tsx`
+- **Beschreibung:** Übersicht aller Druckaufträge, einschließlich Details wie Startzeit, Dauer und Status.
+- **Funktionen:**
+  - Filtern nach Benutzern, Druckern oder Status (abgeschlossen, abgebrochen).
+  - Anzeigen von Abbruchgründen und Fehlermeldungen.
+  - Sortieren nach Zeit oder Benutzer.
+
+---
+
+### **2.4. Einstellungen**
+- **Datei:** `src/app/admin/settings/page.tsx`
+- **Beschreibung:** Konfigurationsseite für die Anwendung.
+- **Funktionen:**
+  - Ändern von globalen Einstellungen wie Standardzeiten oder Fehlerrichtlinien.
+  - Download von Daten (z. B. Export der Druckhistorie).
+
+---
+
+## **3. Statistiken und Diagramme**
+
+Das Admin-Dashboard enthält interaktive Diagramme, die wichtige Statistiken visualisieren. Hier einige der zentralen Diagramme:
+
+### **3.1. Abbruchgründe**
+- **Datei:** `src/app/admin/charts/printer-error-chart.tsx`
+- **Beschreibung:** Zeigt die Häufigkeit der Abbruchgründe für Druckaufträge in einem Balkendiagramm.
+- **Nutzen:** Identifiziert häufige Probleme wie Materialmangel oder Düsenverstopfungen.
+
+---
+
+### **3.2. Fehlerraten**
+- **Datei:** `src/app/admin/charts/printer-error-rate.tsx`
+- **Beschreibung:** Zeigt die prozentuale Fehlerrate für jeden Drucker in einem Balkendiagramm.
+- **Nutzen:** Ermöglicht die Überwachung und Identifizierung von problematischen Druckern.
+
+---
+
+### **3.3. Druckvolumen**
+- **Datei:** `src/app/admin/charts/printer-volume.tsx`
+- **Beschreibung:** Zeigt das Druckvolumen für heute, diese Woche und diesen Monat.
+- **Nutzen:** Vergleich des Druckeroutputs über verschiedene Zeiträume.
+
+---
+
+### **3.4. Prognostizierte Nutzung**
+- **Datei:** `src/app/admin/charts/printer-forecast.tsx`
+- **Beschreibung:** Ein Bereichsdiagramm zeigt die erwartete Druckernutzung pro Wochentag.
+- **Nutzen:** Hilft bei der Planung von Wartungsarbeiten oder Ressourcenzuweisungen.
+
+---
+
+### **3.5. Druckerauslastung**
+- **Datei:** `src/app/admin/charts/printer-utilization.tsx`
+- **Beschreibung:** Zeigt die aktuelle Nutzung eines Druckers in Prozent in einem Kreisdiagramm.
+- **Nutzen:** Überwacht die Auslastung und identifiziert ungenutzte Ressourcen.
+
+---
+
+## **4. Rollenbasierte Zugriffssteuerung**
+
+Das Admin-Dashboard ist nur für Benutzer mit der Rolle „admin“ zugänglich. Nicht berechtigte Benutzer werden auf die Startseite umgeleitet. Die Zugriffssteuerung erfolgt durch folgende Logik:
+- **Datei:** `src/app/admin/layout.tsx`
+- **Funktion:** `validateRequest` prüft die Rolle des aktuellen Benutzers.
+- **Umleitung:** Falls die Rolle unzureichend ist, wird der Benutzer automatisch umgeleitet:
+  ```typescript
+  if (guard(user, IS_NOT, UserRole.ADMIN)) {
+    redirect("/");
+  }
+  ```
+
+Nächster Schritt: [=> API-Endpunkte und deren Nutzung](./API.md)

packages/reservation-platform/docs/Architektur.md

@@ -0,0 +1,79 @@
+# **Technische Architektur und Codeaufbau**
+
+In diesem Abschnitt erläutere ich die Architektur und Struktur des MYP-Projekts sowie die Funktionalitäten der zentralen Komponenten.
+
+---
+
+## **1. Technische Architektur**
+
+### **1.1. Architekturübersicht**
+MYP basiert auf einer modernen Webanwendungsarchitektur:
+- **Frontend:** Entwickelt mit React und Next.js. Stellt die Benutzeroberfläche bereit.
+- **Backend:** Nutzt Node.js und Drizzle ORM für die Datenbankinteraktion und Geschäftslogik.
+- **Datenbank:** SQLite zur Speicherung von Nutzerdaten, Druckaufträgen und Druckerkonfigurationen.
+- **Containerisierung:** Docker wird verwendet, um die Anwendung in isolierten Containern bereitzustellen.
+- **Webserver:** Caddy dient als Reverse Proxy mit HTTPS-Unterstützung.
+
+### **1.2. Modulübersicht**
+- **Datenfluss:** Die Anwendung ist stark datengetrieben. API-Routen werden genutzt, um Daten zwischen Frontend und Backend auszutauschen.
+- **Rollenbasierter Zugriff:** Über ein Berechtigungssystem können Administratoren und Benutzer unterschiedliche Funktionen nutzen.
+
+---
+
+## **2. Codeaufbau**
+
+### **2.1. Ordnerstruktur**
+Die Datei `repomix-output.txt` zeigt eine strukturierte Übersicht des Projekts. Nachfolgend einige wichtige Verzeichnisse:
+
+| **Verzeichnis**         | **Inhalt**                                                                 |
+|--------------------------|---------------------------------------------------------------------------|
+| `src/app`                | Next.js-Seiten und Komponenten für Benutzer und Admins.                  |
+| `src/components`         | Wiederverwendbare UI-Komponenten wie Karten, Diagramme, Buttons etc.     |
+| `src/server`             | Backend-Logik, Authentifizierung und Datenbankinteraktionen.             |
+| `src/utils`              | Hilfsfunktionen für Analysen, Validierungen und Datenbankzugriffe.       |
+| `drizzle`                | Datenbank-Migrationsdateien und Metadaten.                               |
+| `docker`                 | Docker-Konfigurations- und Bereitstellungsskripte.                      |
+
+---
+
+### **2.2. Hauptdateien**
+#### **Frontend**
+- **`src/app/page.tsx`:** Startseite der Anwendung.
+- **`src/app/admin/`:** Admin-spezifische Seiten, z. B. Druckerverwaltung oder Fehlerstatistiken.
+- **`src/components/ui/`:** UI-Komponenten wie Dialoge, Formulare und Tabellen.
+
+#### **Backend**
+- **`src/server/auth/`:** Authentifizierung und Benutzerrollenmanagement.
+- **`src/server/actions/`:** Funktionen zur Interaktion mit Druckaufträgen und Druckern.
+- **`src/utils/`:** Analyse und Verarbeitung von Druckdaten (z. B. Fehlerquoten und Auslastung).
+
+#### **Datenbank**
+- **`drizzle/0000_overjoyed_strong_guy.sql`:** SQLite-Datenbankschema mit Tabellen für Drucker, Benutzer und Druckaufträge.
+- **`drizzle.meta/`:** Metadaten zur Datenbankmigration.
+
+---
+
+### **2.3. Datenbankschema**
+Das Schema enthält vier Haupttabellen:
+1. **`user`:** Speichert Benutzerinformationen, einschließlich Rollen und E-Mail-Adressen.
+2. **`printer`:** Beschreibt die Drucker, ihren Status und ihre Eigenschaften.
+3. **`printJob`:** Zeichnet Druckaufträge auf, einschließlich Startzeit, Dauer und Abbruchgrund.
+4. **`session`:** Verwaltert Benutzer-Sitzungen und Ablaufzeiten.
+
+---
+
+## **3. Wichtige Funktionen**
+
+### **3.1. Authentifizierung**
+Das System nutzt OAuth zur Anmeldung. Benutzerrollen werden in der Tabelle `user` gespeichert und im Backend überprüft.
+
+### **3.2. Statistiken**
+- **Fehlerrate:** Berechnet die Häufigkeit von Abbrüchen für jeden Drucker.
+- **Auslastung:** Prozentuale Nutzung der Drucker, basierend auf geplanten und abgeschlossenen Druckaufträgen.
+- **Prognosen:** Verwenden historische Daten, um zukünftige Drucknutzungen vorherzusagen.
+
+### **3.3. API-Endpunkte**
+- **`src/app/api/printers/`:** Zugriff auf Druckerkonfigurationsdaten.
+- **`src/app/api/job/[jobId]/`:** Verwaltung einzelner Druckaufträge.
+
+Nächster Schritt: [=> Datenbank und Analytik-Funktionen](./Datenbank.md)

packages/reservation-platform/docs/Bereitstellungsdetails .md

@@ -0,0 +1,150 @@
+# **Bereitstellungsdetails und Best Practices**
+
+In diesem Abschnitt erläutere ich, wie das MYP-Projekt auf einem Server bereitgestellt wird, sowie empfohlene Praktiken zur Verwaltung und Optimierung des Systems.
+
+---
+
+## **1. Bereitstellungsschritte**
+
+### **1.1. Voraussetzungen**
+- **Server:** Raspberry Pi mit installiertem Raspbian Lite.
+- **Docker:** Docker und Docker Compose müssen vorab installiert sein.
+- **Netzwerk:** Der Server muss über eine statische IP-Adresse oder einen DNS-Namen erreichbar sein.
+
+### **1.2. Vorbereitung**
+#### **1.2.1. Docker-Images erstellen und speichern**
+Führen Sie die folgenden Schritte auf dem Entwicklungssystem aus:
+1. **Images erstellen:**
+   ```bash
+   bash docker/build.sh
+   ```
+2. **Images exportieren und komprimieren:**
+   ```bash
+   bash docker/save.sh <image-name>
+   ```
+   Dies speichert die Docker-Images im Verzeichnis `docker/images/`.
+
+#### **1.2.2. Übertragung auf den Server**
+Kopieren Sie die erzeugten `.tar.xz`-Dateien auf den Raspberry Pi:
+```bash
+scp docker/images/*.tar.xz <username>@<server-ip>:/path/to/destination/
+```
+
+---
+
+### **1.3. Images auf dem Server laden**
+Loggen Sie sich auf dem Server ein und laden Sie die Docker-Images:
+```bash
+docker load -i /path/to/destination/<image-name>.tar.xz
+```
+
+---
+
+### **1.4. Starten der Anwendung**
+Führen Sie das Bereitstellungsskript aus:
+```bash
+bash docker/deploy.sh
+```
+Dieses Skript:
+- Startet die Docker-Container mithilfe von `docker compose`.
+- Verbindet den Reverse Proxy (Caddy) mit der Anwendung.
+
+Die Anwendung sollte unter `http://<server-ip>` oder der konfigurierten Domain erreichbar sein.
+
+---
+
+## **2. Best Practices**
+
+### **2.1. Sicherheit**
+1. **Umgebungsvariablen schützen:**
+   - Stellen Sie sicher, dass die Datei `.env` nicht versehentlich in ein öffentliches Repository hochgeladen wird.
+   - Verwenden Sie geeignete Zugriffsrechte:
+     ```bash
+     chmod 600 .env
+     ```
+2. **HTTPS aktivieren:**
+   - Der Caddy-Webserver unterstützt automatisch HTTPS. Stellen Sie sicher, dass eine gültige Domain konfiguriert ist.
+
+3. **Zugriffsrechte beschränken:**
+   - Verwenden Sie Benutzerrollen („admin“, „guest“), um den Zugriff auf kritische Funktionen zu steuern.
+
+---
+
+### **2.2. Performance**
+1. **Docker-Container optimieren:**
+   - Reduzieren Sie die Größe der Docker-Images, indem Sie unnötige Dateien in `.dockerignore` ausschließen.
+
+2. **Datenbankwartung:**
+   - Führen Sie regelmäßige Backups der SQLite-Datenbank durch:
+     ```bash
+     cp db/sqlite.db /path/to/backup/location/
+     ```
+   - Optimieren Sie die Datenbank regelmäßig:
+     ```sql
+     VACUUM;
+     ```
+
+3. **Skalierung:**
+   - Bei hoher Last kann die Anwendung mit Kubernetes oder einer Cloud-Lösung (z. B. AWS oder Azure) skaliert werden.
+
+---
+
+### **2.3. Fehlerbehebung**
+1. **Logs überprüfen:**
+   - Docker-Logs können wichtige Debug-Informationen liefern:
+     ```bash
+     docker logs <container-name>
+     ```
+
+2. **Health Checks:**
+   - Integrieren Sie Health Checks in die Docker Compose-Datei, um sicherzustellen, dass die Dienste korrekt laufen.
+
+3. **Fehlerhafte Drucker deaktivieren:**
+   - Deaktivieren Sie Drucker mit einer hohen Fehlerrate über das Admin-Dashboard, um die Benutzererfahrung zu verbessern.
+
+---
+
+### **2.4. Updates**
+1. **Neue Funktionen hinzufügen:**
+   - Aktualisieren Sie die Anwendung und erstellen Sie neue Docker-Images:
+     ```bash
+     git pull origin main
+     bash docker/build.sh
+     ```
+   - Stellen Sie die aktualisierten Images bereit:
+     ```bash
+     bash docker/deploy.sh
+     ```
+
+2. **Datenbankmigrationen:**
+   - Führen Sie neue Migrationsskripte mit folgendem Befehl aus:
+     ```bash
+     pnpm run db:migrate
+     ```
+
+---
+
+## **3. Backup und Wiederherstellung**
+
+### **3.1. Backups erstellen**
+Sichern Sie wichtige Dateien und Datenbanken regelmäßig:
+- **SQLite-Datenbank:**
+  ```bash
+  cp db/sqlite.db /backup/location/sqlite-$(date +%F).db
+  ```
+- **Docker-Images:**
+  ```bash
+  docker save myp-rp:latest | gzip > /backup/location/myp-rp-$(date +%F).tar.gz
+  ```
+
+### **3.2. Wiederherstellung**
+- **Datenbank wiederherstellen:**
+  ```bash
+  cp /backup/location/sqlite-<date>.db db/sqlite.db
+  ```
+- **Docker-Images importieren:**
+  ```bash
+  docker load < /backup/location/myp-rp-<date>.tar.gz
+  ```
+
+Nächster Schritt: [=> Admin-Dashboard](./Admin-Dashboard.md)

packages/reservation-platform/docs/Datenbank.md

@@ -0,0 +1,153 @@
+# **Datenbank und Analytik-Funktionen**
+
+Dieser Abschnitt konzentriert sich auf die Struktur der Datenbank sowie die Analyse- und Prognosefunktionen, die im Projekt verwendet werden.
+
+---
+
+## **1. Datenbankstruktur**
+
+Das Datenbankschema wurde mit **Drizzle ORM** definiert und basiert auf SQLite. Die wichtigsten Tabellen und ihre Zwecke sind:
+
+### **1.1. Tabellenübersicht**
+
+#### **`user`**
+- Speichert Benutzerinformationen.
+- Enthält Rollen wie „admin“ oder „guest“ zur Verwaltung von Berechtigungen.
+
+| **Feld**         | **Typ**    | **Beschreibung**                           |
+|-------------------|------------|-------------------------------------------|
+| `id`             | `text`     | Eindeutige ID des Benutzers.              |
+| `github_id`      | `integer`  | ID des Benutzers aus dem OAuth-Dienst.    |
+| `name`           | `text`     | Benutzername.                             |
+| `displayName`    | `text`     | Angezeigter Name.                         |
+| `email`          | `text`     | E-Mail-Adresse.                           |
+| `role`           | `text`     | Benutzerrolle, Standardwert: „guest“.     |
+
+---
+
+#### **`printer`**
+- Beschreibt verfügbare Drucker und deren Status.
+
+| **Feld**         | **Typ**    | **Beschreibung**                           |
+|-------------------|------------|-------------------------------------------|
+| `id`             | `text`     | Eindeutige Drucker-ID.                    |
+| `name`           | `text`     | Name des Druckers.                        |
+| `description`    | `text`     | Beschreibung oder Spezifikationen.        |
+| `status`         | `integer`  | Betriebsstatus (0 = inaktiv, 1 = aktiv).  |
+
+---
+
+#### **`printJob`**
+- Speichert Informationen zu Druckaufträgen.
+
+| **Feld**             | **Typ**       | **Beschreibung**                                       |
+|-----------------------|---------------|-------------------------------------------------------|
+| `id`                 | `text`        | Eindeutige Auftrags-ID.                               |
+| `printerId`          | `text`        | Verweis auf die ID des Druckers.                     |
+| `userId`             | `text`        | Verweis auf die ID des Benutzers.                    |
+| `startAt`            | `integer`     | Startzeit des Druckauftrags (Unix-Timestamp).        |
+| `durationInMinutes`  | `integer`     | Dauer des Druckauftrags in Minuten.                  |
+| `comments`           | `text`        | Zusätzliche Kommentare.                              |
+| `aborted`            | `integer`     | 1 = Abgebrochen, 0 = Erfolgreich abgeschlossen.      |
+| `abortReason`        | `text`        | Grund für den Abbruch (falls zutreffend).            |
+
+---
+
+#### **`session`**
+- Verwaltert Benutzer-Sitzungen und Ablaufzeiten.
+
+| **Feld**         | **Typ**    | **Beschreibung**                           |
+|-------------------|------------|-------------------------------------------|
+| `id`             | `text`     | Eindeutige Sitzungs-ID.                   |
+| `user_id`        | `text`     | Verweis auf die ID des Benutzers.         |
+| `expires_at`     | `integer`  | Zeitpunkt, wann die Sitzung abläuft.      |
+
+---
+
+### **1.2. Relationen**
+- `printer` → `printJob`: Druckaufträge sind an spezifische Drucker gebunden.
+- `user` → `printJob`: Druckaufträge werden Benutzern zugewiesen.
+- `user` → `session`: Sitzungen verknüpfen Benutzer mit Login-Details.
+
+---
+
+## **2. Analytik-Funktionen**
+
+Das Projekt bietet verschiedene Analytik- und Prognosetools, um die Druckernutzung und Fehler zu überwachen.
+
+### **2.1. Fehlerratenanalyse**
+- Funktion: `calculatePrinterErrorRate` (in `src/utils/analytics/error-rate.ts`).
+- Berechnet die prozentuale Fehlerrate für jeden Drucker basierend auf abgebrochenen Aufträgen.
+
+Beispielausgabe:
+```json
+[
+  { "name": "Drucker 1", "errorRate": 5.2 },
+  { "name": "Drucker 2", "errorRate": 3.7 }
+]
+```
+
+---
+
+### **2.2. Abbruchgründe**
+- Funktion: `calculateAbortReasonsCount` (in `src/utils/analytics/errors.ts`).
+- Zählt die Häufigkeit der Abbruchgründe aus der Tabelle `printJob`.
+
+Beispielausgabe:
+```json
+[
+  { "abortReason": "Materialmangel", "count": 10 },
+  { "abortReason": "Düsenverstopfung", "count": 7 }
+]
+```
+
+---
+
+### **2.3. Nutzung und Prognosen**
+#### Nutzung:
+- Funktion: `calculatePrinterUtilization` (in `src/utils/analytics/utilization.ts`).
+- Berechnet die Nutzung der Drucker in Prozent.
+
+Beispielausgabe:
+```json
+{ "printerId": "1", "utilizationPercentage": 85 }
+```
+
+#### Prognosen:
+- Funktion: `forecastPrinterUsage` (in `src/utils/analytics/forecast.ts`).
+- Nutzt historische Daten, um die erwartete Druckernutzung für kommende Tage/Wochen zu schätzen.
+
+Beispielausgabe:
+```json
+[
+  { "day": 1, "usageMinutes": 300 },
+  { "day": 2, "usageMinutes": 200 }
+]
+```
+
+---
+
+### **2.4. Druckvolumen**
+- Funktion: `calculatePrintVolumes` (in `src/utils/analytics/volume.ts`).
+- Vergleicht die Anzahl der abgeschlossenen Druckaufträge für heute, diese Woche und diesen Monat.
+
+Beispielausgabe:
+```json
+{
+  "today": 15,
+  "thisWeek": 90,
+  "thisMonth": 300
+}
+```
+
+---
+
+## **3. Datenbankinitialisierung**
+Die Datenbank wird über Skripte in der `package.json` initialisiert:
+```bash
+pnpm run db:clean       # Datenbank und Migrationsordner löschen
+pnpm run db:generate    # Neues Schema generieren
+pnpm run db:migrate     # Migrationsskripte ausführen
+```
+
+Nächster Schritt: [=> Bereitstellungsdetails und Best Practices](./Bereitstellungsdetails.md)

packages/reservation-platform/docs/Installation.md

@@ -0,0 +1,93 @@
+# **Installation und Einrichtung**
+
+In diesem Abschnitt wird beschrieben, wie die MYP-Anwendung installiert und eingerichtet wird. Diese Schritte umfassen die Vorbereitung der Umgebung, das Konfigurieren der notwendigen Dienste und die Bereitstellung des Projekts.
+
+---
+
+## **Voraussetzungen**
+### **Hardware und Software**
+- **Raspberry Pi:** Die Anwendung ist für den Einsatz auf einem Raspberry Pi optimiert, auf dem Raspbian Lite installiert sein sollte.
+- **Docker:** Docker und Docker Compose müssen installiert sein.
+- **Netzwerkzugriff:** Der Raspberry Pi muss im Netzwerk erreichbar sein.
+
+### **Abhängigkeiten**
+- Node.js (mindestens Version 20)
+- PNPM (Paketmanager)
+- SQLite (für lokale Datenbankverwaltung)
+
+---
+
+## **Schritte zur Einrichtung**
+
+### **1. Repository klonen**
+Klonen Sie das Repository auf Ihr System:
+```bash
+git clone <repository-url>
+cd <repository-ordner>
+```
+
+### **2. Konfiguration der Umgebungsvariablen**
+Passen Sie die Datei `.env.example` an und benennen Sie sie in `.env` um:
+```bash
+cp .env.example .env
+```
+Erforderliche Variablen:
+- `OAUTH_CLIENT_ID`: Client-ID für die OAuth-Authentifizierung
+- `OAUTH_CLIENT_SECRET`: Geheimnis für die OAuth-Authentifizierung
+
+### **3. Docker-Container erstellen**
+Führen Sie das Skript `build.sh` aus, um Docker-Images zu erstellen:
+```bash
+bash docker/build.sh
+```
+Dies erstellt die notwendigen Docker-Images, einschließlich der Anwendung und eines Caddy-Webservers.
+
+### **4. Docker-Images speichern**
+Speichern Sie die Images in komprimierter Form, um sie auf anderen Geräten bereitzustellen:
+```bash
+bash docker/save.sh <image-name>
+```
+
+### **5. Bereitstellung**
+Kopieren Sie die Docker-Images auf den Zielserver (z. B. Raspberry Pi) und führen Sie `deploy.sh` aus:
+```bash
+scp docker/images/*.tar.xz <ziel-server>:/path/to/deployment/
+bash docker/deploy.sh
+```
+Das Skript führt die Docker Compose-Konfiguration aus und startet die Anwendung.
+
+### **(Optional: 6. Admin-User anlegen)**
+
+Um einen Admin-User anzulegen, muss zuerst das Container-Image gestartet werden. Anschließend meldet man sich mittels
+der GitHub-Authentifizierung bei der Anwendung an.
+
+Der nun in der Datenbank angelegte User hat die Rolle `guest`. Über das CLI muss man nun in die SQLite-Datenbank (die Datenbank sollte außerhalb des Container-Images liegen) wechseln und
+den User updaten.
+
+
+#### SQL-Befehl, um den User zu updaten:
+```bash
+sqlite3 db.sqlite3
+UPDATE users SET role = 'admin' WHERE id = <user-id>;
+```
+
+---
+
+## **Start der Anwendung**
+Sobald die Docker-Container laufen, ist die Anwendung unter der angegebenen Domain oder IP-Adresse erreichbar. Standardmäßig verwendet der Caddy-Webserver Port 80 (HTTP) und 443 (HTTPS).
+
+---
+
+## **Optional: Entwicklungsmodus**
+Für lokale Tests können Sie die Anwendung ohne Docker starten:
+1. Installieren Sie Abhängigkeiten:
+   ```bash
+   pnpm install
+   ```
+2. Starten Sie den Entwicklungsserver:
+   ```bash
+   pnpm dev
+   ```
+   Die Anwendung ist dann unter `http://localhost:3000` verfügbar.
+
+Nächster Schritt: [=> Nutzung](./Nutzung.md)

packages/reservation-platform/docs/Nutzung.md

@@ -0,0 +1,75 @@
+# **Features und Nutzung der Anwendung**
+
+In diesem Abschnitt beschreibe ich die Hauptfunktionen von MYP (Manage Your Printer) und gebe Anweisungen zur Nutzung der verschiedenen Module.
+
+---
+
+## **1. Hauptfunktionen**
+
+### **1.1. Druckerreservierung**
+- Nutzer können Drucker für einen definierten Zeitraum reservieren.
+- Konflikte bei Reservierungen werden durch ein Echtzeit-Überprüfungssystem verhindert.
+
+### **1.2. Fehler- und Auslastungsanalyse**
+- Darstellung von Druckfehlern nach Kategorien und Häufigkeiten.
+- Übersicht der aktuellen und historischen Druckernutzung.
+- Diagramme zur Fehlerrate, Nutzung und Druckvolumen.
+
+### **1.3. Admin-Dashboard**
+- Verwaltung von Druckern, Nutzern und Druckaufträgen.
+- Überblick über alle Abbruchgründe und Druckfehler.
+- Zugriff auf erweiterte Statistiken und Prognosen.
+
+---
+
+## **2. Nutzung der Anwendung**
+
+### **2.1. Login und Authentifizierung**
+- Die Anwendung unterstützt OAuth-basierte Authentifizierung.
+- Nutzer müssen sich mit einem gültigen Konto anmelden, um Zugriff auf die Funktionen zu erhalten.
+
+### **2.2. Dashboard**
+- Nach dem Login gelangen die Nutzer auf das Dashboard, das einen Überblick über die aktuelle Druckernutzung bietet.
+- Administratoren haben Zugriff auf zusätzliche Menüpunkte, wie z. B. Benutzerverwaltung.
+
+---
+
+## **3. Admin-Funktionen**
+
+### **3.1. Druckerverwaltung**
+- Administratoren können Drucker hinzufügen, bearbeiten oder löschen.
+- Status eines Druckers (z. B. „in Betrieb“, „außer Betrieb“) kann angepasst werden.
+
+### **3.2. Nutzerverwaltung**
+- Verwalten von Benutzerkonten, einschließlich Rollen (z. B. „Admin“ oder „User“).
+- Benutzer können aktiviert oder deaktiviert werden.
+
+### **3.3. Statistiken und Berichte**
+- Diagramme wie:
+  - **Abbruchgründe:** Zeigt häufige Fehlerursachen.
+  - **Fehlerrate:** Prozentuale Fehlerquote der Drucker.
+  - **Nutzung:** Prognosen für die Druckernutzung pro Wochentag.
+
+---
+
+## **4. Diagramme und Visualisierungen**
+
+### **4.1. Abbruchgründe**
+- Ein Säulendiagramm zeigt die Häufigkeiten der Fehlerursachen.
+- Nutzt Echtzeit-Daten aus der Druckhistorie.
+
+### **4.2. Prognostizierte Nutzung**
+- Ein Liniendiagramm zeigt die erwartete Druckernutzung pro Tag.
+- Hilft bei der Planung von Wartungszeiten.
+
+### **4.3. Druckvolumen**
+- Balkendiagramme vergleichen Druckaufträge heute, diese Woche und diesen Monat.
+
+---
+
+## **5. Interaktive Komponenten**
+- **Benachrichtigungen:** Informieren über Druckaufträge, Fehler oder Systemereignisse.
+- **Filter und Suchfunktionen:** Erleichtern das Auffinden von Druckern oder Druckaufträgen.
+- **Rollenbasierter Zugriff:** Funktionen sind je nach Benutzerrolle eingeschränkt.
+
+Nächster Schritt: [=> Technische Architektur und Codeaufbau](./Architektur.md)

packages/reservation-platform/docs/README.md

@@ -0,0 +1,37 @@
+# **Einleitung**
+
+> Information: Die Dokumenation wurde mit generativer AI erstellt und kann fehlerhaft sein. Im Zweifel bitte die Quellcode-Dateien anschauen oder die Entwickler kontaktieren.
+
+## **Projektbeschreibung**
+MYP (Manage Your Printer) ist eine Webanwendung zur Verwaltung und Reservierung von 3D-Druckern. Das Projekt wurde als Abschlussarbeit im Rahmen der Fachinformatiker-Ausbildung mit Schwerpunkt Daten- und Prozessanalyse entwickelt und dient als Plattform zur einfachen Koordination und Überwachung von Druckressourcen. Es wurde speziell für die Technische Berufsausbildung des Mercedes-Benz Werkes in Berlin-Marienfelde erstellt.
+
+---
+
+## **Hauptmerkmale**
+- **Druckerreservierungen:** Nutzer können 3D-Drucker in definierten Zeitfenstern reservieren.
+- **Fehleranalyse:** Statistiken über Druckfehler und Abbruchgründe werden visuell dargestellt.
+- **Druckauslastung:** Echtzeit-Daten über die Nutzung der Drucker.
+- **Admin-Dashboard:** Übersichtliche Verwaltung und Konfiguration von Druckern, Benutzern und Druckaufträgen.
+- **Datenbankintegration:** Alle Daten werden in einer SQLite-Datenbank gespeichert und verwaltet.
+
+---
+
+## **Technologien**
+- **Frontend:** React, Next.js, TailwindCSS
+- **Backend:** Node.js, Drizzle ORM
+- **Datenbank:** SQLite
+- **Deployment:** Docker und Raspberry Pi
+- **Zusätzliche Bibliotheken:** recharts für Diagramme, Faker.js für Testdaten, sowie diverse Radix-UI-Komponenten.
+
+---
+
+## **Dateistruktur**
+Die Repository-Dateien sind in logische Abschnitte unterteilt:
+1. **Docker-Konfigurationen** (`docker/`) - Skripte und Konfigurationsdateien für die Bereitstellung.
+2. **Frontend-Komponenten** (`src/app/`) - Weboberfläche und deren Funktionalitäten.
+3. **Backend-Funktionen** (`src/server/`) - Datenbankinteraktionen und Authentifizierungslogik.
+4. **Utils und Helferfunktionen** (`src/utils/`) - Wiederverwendbare Dienste und Hilfsmethoden.
+5. **Datenbank-Skripte** (`drizzle/`) - Datenbankschemas und Migrationsdateien.
+
+
+Nächster Schritt: [=> Installation](./Installation.md)