FIN INIT

.npmrc

@@ -0,0 +1,11 @@
+fund=false
+audit-level=moderate
+package-lock=true
+save-exact=true
+save-prefix=
+ca[]=
+cafile=/etc/ssl/certs/ca-certificates.crt
+strict-ssl=true
+registry=https://registry.npmjs.org/
+progress=false
+loglevel=warn

README.md

@@ -0,0 +1,595 @@
+# MYP Druckerverwaltung
+
+Ein umfassendes Druckerverwaltungssystem für Mercedes-Benz, optimiert für Debian/Linux-Systeme mit HTTPS-Kiosk-Modus.
+
+## 🚀 Schnellstart
+
+### Debian/Linux Kiosk-Installation (Empfohlen)
+
+```bash
+# Repository klonen
+git clone <repository-url>
+cd backend
+
+# Konsolidiertes Setup-Skript ausführen
+sudo ./setup.sh
+```
+
+**Installationsoptionen**:
+
+1. **Abhängigkeiten installieren** - System für manuelles Testen vorbereiten
+2. **Vollständige Kiosk-Installation** - Automatischer Kiosk-Modus mit Remote-Zugang
+
+**Nach der Installation**: System mit `sudo reboot` neustarten für automatischen Kiosk-Modus.
+
+### Entwicklungsumgebung (Windows)
+
+```bash
+# Abhängigkeiten installieren
+pip install -r requirements.txt
+npm install
+
+# Entwicklungsserver starten
+python app.py --debug
+```
+
+## 📋 Systemanforderungen
+
+### Produktionsumgebung (Kiosk)
+
+- **Debian/Raspbian** (Raspberry Pi OS empfohlen)
+- Raspberry Pi 4 mit 2GB+ RAM
+- 16GB+ SD-Karte
+- HDMI-Monitor
+- Netzwerkverbindung
+
+### Entwicklungsumgebung
+
+- **Windows 10/11** (nur für Entwicklung)
+- Python 3.8+
+- Node.js 18+
+- Git
+
+## 🔧 Features
+
+### Kern-Funktionalitäten
+
+- **Druckerverwaltung** mit Smart-Plug-Integration (TP-Link Tapo)
+- **Job-Management** mit Warteschlangen-System
+- **Benutzerverwaltung** mit Rollen und Berechtigungen
+- **Gast-Anfragen** für temporären Zugriff
+- **Echtzeit-Dashboard** mit Live-Statistiken
+- **Automatische Backups** und Wartung
+
+### Kiosk-Modus Features
+
+- **HTTPS auf Port 443** mit automatischen SSL-Zertifikaten
+- **Chromium-Vollbildmodus** ohne Desktop-Environment
+- **Automatischer Login** und Browser-Start
+- **Watchdog-Überwachung** für Systemstabilität
+- **Remote-Zugang** via SSH und RDP mit Firewall-Schutz
+- **Responsive Design** für Desktop-Nutzung
+
+### Sicherheit
+
+- **SSL/TLS-Verschlüsselung** (selbstsignierte Zertifikate)
+- **CSRF-Schutz** und Session-Management
+- **Rate-Limiting** und Eingabevalidierung
+- **Systemd-Service-Isolation**
+- **IPv6 vollständig deaktiviert** für erhöhte Sicherheit
+- **IP-Spoofing-Schutz** und DDoS-Abwehr
+- **TCP-Optimierungen** und RFC-Compliance
+
+## 🏗️ Architektur
+
+### Backend
+
+- **Flask 3.1.1** - Web-Framework
+- **SQLAlchemy 2.0.36** - ORM und Datenbankzugriff
+- **SQLite** - Eingebettete Datenbank
+- **Gunicorn** - WSGI-Server für Produktion
+
+### Frontend
+
+- **TailwindCSS** - Utility-First CSS Framework
+- **Chart.js** - Datenvisualisierung
+- **FontAwesome** - Icons
+- **Vanilla JavaScript** - Interaktivität
+
+### System-Integration
+
+- **systemd** - Service-Management
+- **OpenSSL** - SSL-Zertifikat-Generierung
+- **Chromium** - Kiosk-Browser
+- **X11** - Minimale Grafikumgebung
+
+## 📁 Projektstruktur
+
+```
+backend/
+├── app.py                 # Hauptanwendung mit HTTPS-Support
+├── models.py              # Datenbankmodelle
+├── setup.sh               # Konsolidiertes Setup-Skript
+├── requirements.txt       # Python-Abhängigkeiten
+├── package.json           # Node.js-Abhängigkeiten
+├── 
+├── systemd/               # Systemd-Service-Dateien
+│   ├── myp-https.service  # HTTPS-Backend-Service
+│   ├── myp-kiosk.service  # Kiosk-Browser-Service
+│   ├── kiosk-watchdog.service # Überwachungsservice
+│   └── kiosk-watchdog-python.service # Python-Watchdog
+├── 
+├── blueprints/            # Flask-Blueprints
+│   ├── auth.py           # Authentifizierung
+│   ├── users.py          # Benutzerverwaltung
+│   ├── printers.py       # Druckerverwaltung
+│   ├── jobs.py           # Job-Management
+│   └── guest.py          # Gast-Anfragen
+├── 
+├── config/               # Konfigurationsdateien
+│   └── settings.py       # Hauptkonfiguration
+├── 
+├── utils/                # Hilfsfunktionen
+│   ├── ssl_config.py     # SSL-Zertifikat-Management
+│   ├── logging_config.py # Logging-Konfiguration
+│   ├── queue_manager.py  # Job-Warteschlange
+│   └── printer_monitor.py # Drucker-Überwachung
+├── 
+├── static/               # Statische Dateien
+│   ├── css/             # Stylesheets
+│   ├── js/              # JavaScript
+│   └── icons/           # Icons und Bilder
+├── 
+├── templates/            # Jinja2-Templates
+├── docs/                 # Dokumentation
+├── logs/                 # Log-Dateien
+└── uploads/              # Hochgeladene Dateien
+```
+
+## 🔧 Installation
+
+### Option 1: Automatische Installation mit setup.sh (Empfohlen)
+
+```bash
+# Als Root ausführen
+sudo ./setup.sh
+
+# Menüoptionen:
+# 1. Abhängigkeiten installieren für manuelles Testen
+# 2. Vollständige Kiosk-Installation mit Remote-Zugang
+# 3. Beenden
+```
+
+**Installationsmodi**:
+
+- **Option 1**: Ideal für Entwicklung, manuelle Tests und Debugging
+- **Option 2**: Vollständige Produktionsinstallation mit automatischem Kiosk-Start
+
+### Option 2: Manuelle Installation
+
+#### Schritt 1: System vorbereiten
+
+```bash
+sudo apt-get update && sudo apt-get upgrade -y
+sudo apt-get install -y python3 python3-pip nodejs npm git
+```
+
+#### Schritt 2: Abhängigkeiten installieren
+
+```bash
+# Python-Pakete (ohne virtuelles Environment)
+pip3 install -r requirements.txt --break-system-packages
+
+# Node.js-Pakete
+npm install
+
+# TailwindCSS kompilieren
+npm run build:css
+```
+
+#### Schritt 3: SSL-Zertifikate generieren
+
+```bash
+python3 -c "
+import sys; sys.path.insert(0, '.')
+from utils.ssl_config import ensure_ssl_certificates
+ensure_ssl_certificates('.', True)
+"
+```
+
+#### Schritt 4: Services einrichten
+
+```bash
+# Services aus systemd/ Verzeichnis kopieren
+sudo cp systemd/*.service /etc/systemd/system/
+sudo systemctl daemon-reload
+
+# HTTPS-Service aktivieren
+sudo systemctl enable myp-https.service
+sudo systemctl start myp-https.service
+
+# Kiosk-Service aktivieren (optional)
+sudo systemctl enable myp-kiosk.service
+```
+
+## 🌐 Zugriff
+
+### Lokaler Zugriff
+
+- **HTTPS**: `https://localhost:443`
+- **HTTP (Entwicklung)**: `http://localhost:5000`
+
+### Netzwerk-Zugriff
+
+- **HTTPS**: `https://<raspberry-pi-ip>:443`
+
+### Remote-Zugang (falls konfiguriert)
+
+- **SSH**: `ssh user@<raspberry-pi-ip>` (Passwort: `raspberry`)
+- **RDP**: `<raspberry-pi-ip>:3389` (Benutzer: `root`, Passwort: `744563017196A`)
+
+### Standard-Anmeldedaten
+
+- **Benutzername**: `admin`
+- **Passwort**: `admin123`
+
+⚠️ **Wichtig**: Ändern Sie das Standard-Passwort nach der ersten Anmeldung!
+
+## 🔧 Konfiguration
+
+### Umgebungsvariablen
+
+```bash
+# Produktionsumgebung
+export FLASK_ENV=production
+export FLASK_HOST=0.0.0.0
+export FLASK_PORT=443
+
+# Entwicklungsumgebung
+export FLASK_ENV=development
+export FLASK_HOST=127.0.0.1
+export FLASK_PORT=5000
+```
+
+### SSL-Konfiguration
+
+```bash
+# Automatische Zertifikat-Generierung
+python3 utils/ssl_config.py /opt/myp
+
+# Manuelle Zertifikat-Erneuerung
+python3 utils/ssl_config.py /opt/myp --force
+```
+
+### Drucker-Konfiguration
+
+1. **Admin-Panel** → **Drucker** → **Neuer Drucker**
+2. IP-Adresse und TP-Link Tapo-Zugangsdaten eingeben
+3. Drucker-Test durchführen
+4. Smart-Plug-Integration aktivieren
+
+## 📊 Überwachung
+
+### Service-Status
+
+```bash
+# HTTPS-Service
+sudo systemctl status myp-https.service
+sudo journalctl -u myp-https -f
+
+# Kiosk-Service
+sudo systemctl status myp-kiosk.service
+sudo journalctl -u myp-kiosk -f
+
+# Watchdog-Service
+sudo systemctl status kiosk-watchdog.service
+sudo tail -f /var/log/kiosk-watchdog.log
+```
+
+### System-Tests
+
+```bash
+# HTTPS-Erreichbarkeit
+curl -k https://localhost:443
+
+# SSL-Zertifikat prüfen
+openssl s_client -connect localhost:443 -servername localhost
+
+# Automatische Tests mit setup.sh
+sudo ./setup.sh # Option 5: System-Test
+```
+
+### Log-Dateien
+
+```bash
+# Anwendungslogs
+tail -f logs/app/app.log
+tail -f logs/auth/auth.log
+tail -f logs/printers/printers.log
+
+# Systemlogs
+sudo journalctl -u myp-https -f
+sudo tail -f /var/log/kiosk-watchdog.log
+
+# Installationslog
+sudo tail -f /var/log/myp-install.log
+```
+
+## 🛠️ Entwicklung
+
+### Entwicklungsserver starten
+
+```bash
+# HTTP-Entwicklungsserver (Port 5000)
+python app.py --debug
+
+# HTTPS-Produktionsserver (Port 443)
+python app.py
+```
+
+### Frontend-Entwicklung
+
+```bash
+# TailwindCSS im Watch-Modus
+npm run watch:css
+
+# CSS kompilieren
+npm run build:css
+
+# Alle Assets bauen
+npm run build
+```
+
+### Datenbank-Management
+
+```bash
+# Datenbank initialisieren
+python -c "from models import init_database; init_database()"
+
+# Backup erstellen
+python -c "from utils.backup_manager import BackupManager; BackupManager().create_backup()"
+```
+
+## 🔒 Sicherheit
+
+### SSL/TLS
+
+- **TLS 1.2+** erforderlich
+- **Starke Cipher-Suites** konfiguriert
+- **Selbstsignierte Zertifikate** für localhost
+- **Automatische Erneuerung** bei Ablauf
+
+### Anwendungssicherheit
+
+- **CSRF-Schutz** aktiviert
+- **Session-Management** mit Timeout
+- **Rate-Limiting** für API-Endpunkte
+- **Eingabevalidierung** und Sanitization
+
+### System-Sicherheit
+
+- **Minimale X11-Umgebung** ohne Desktop
+- **Kiosk-User** ohne Sudo-Rechte
+- **Systemd-Service-Isolation**
+- **Read-only Systempartitionen** (optional)
+
+## 📚 Dokumentation
+
+### Detaillierte Anleitungen
+
+- [`docs/SETUP_ANLEITUNG.md`](docs/SETUP_ANLEITUNG.md) - Konsolidiertes Setup-System
+- [`docs/INSTALLATION_DEBIAN_KIOSK.md`](docs/INSTALLATION_DEBIAN_KIOSK.md) - Vollständige Kiosk-Installation
+- [`docs/API_DOCUMENTATION.md`](docs/API_DOCUMENTATION.md) - API-Referenz
+- [`docs/CONFIGURATION.md`](docs/CONFIGURATION.md) - Konfigurationsoptionen
+- [`docs/TROUBLESHOOTING.md`](docs/TROUBLESHOOTING.md) - Fehlerbehebung
+
+### API-Endpunkte
+
+- **Authentifizierung**: `/auth/login`, `/auth/logout`
+- **Drucker**: `/api/printers`, `/api/printers/{id}`
+- **Jobs**: `/api/jobs`, `/api/jobs/{id}`
+- **Benutzer**: `/api/users`, `/api/users/{id}`
+- **Dashboard**: `/api/dashboard/refresh`, `/api/stats`
+
+## 🐛 Fehlerbehebung
+
+### Häufige Probleme
+
+#### HTTPS nicht erreichbar
+
+```bash
+# Service-Status prüfen
+sudo systemctl status myp-https.service
+
+# SSL-Zertifikate neu generieren
+sudo python3 utils/ssl_config.py /opt/myp --force
+sudo systemctl restart myp-https.service
+
+# Oder mit setup.sh
+sudo ./setup.sh # Option 1 für Zertifikat-Neugenerierung
+```
+
+#### Kiosk-Browser startet nicht
+
+```bash
+# X-Server prüfen
+ps aux | grep X
+
+# Browser manuell starten
+sudo su - kiosk
+DISPLAY=:0 chromium --kiosk https://localhost:443
+
+# Service-Status prüfen
+sudo systemctl status myp-kiosk.service
+```
+
+#### Hohe Speichernutzung
+
+```bash
+# Browser-Cache leeren
+sudo rm -rf /home/kiosk/.chromium-kiosk/Default/Cache/*
+
+# System-Cache leeren
+sudo sync && sudo echo 3 > /proc/sys/vm/drop_caches
+
+# Watchdog überwacht automatisch Speichernutzung
+sudo journalctl -u kiosk-watchdog -f
+```
+
+### Support
+
+Bei Problemen:
+
+1. **System-Test durchführen**: `sudo ./setup.sh` → Option 5
+2. **Log-Bundle erstellen**:
+
+```bash
+sudo tar -czf myp-logs-$(date +%Y%m%d).tar.gz \
+  logs/ \
+  /var/log/kiosk-watchdog.log \
+  /var/log/myp-install.log
+```
+
+## 🔄 Updates
+
+### Anwendungs-Updates
+
+```bash
+cd /opt/myp
+git pull origin main
+sudo pip3 install -r requirements.txt --break-system-packages --upgrade
+sudo npm install
+
+# Services mit setup.sh aktualisieren
+sudo ./setup.sh # Option 3: Nur Services installieren
+
+sudo systemctl restart myp-https.service
+```
+
+### System-Updates
+
+```bash
+sudo apt-get update && sudo apt-get upgrade -y
+sudo reboot
+```
+
+## 📄 Lizenz
+
+Dieses Projekt ist für den internen Gebrauch bei Mercedes-Benz entwickelt.
+
+## 🤝 Beitragen
+
+1. Fork des Repositories erstellen
+2. Feature-Branch erstellen (`git checkout -b feature/AmazingFeature`)
+3. Änderungen committen (`git commit -m 'Add some AmazingFeature'`)
+4. Branch pushen (`git push origin feature/AmazingFeature`)
+5. Pull Request erstellen
+
+## 📞 Support
+
+- **Dokumentation**: [`docs/`](docs/) Verzeichnis
+- **Setup-Anleitung**: [`docs/SETUP_ANLEITUNG.md`](docs/SETUP_ANLEITUNG.md)
+- **Issues**: GitHub Issues für Bug-Reports
+- **Logs**: Automatische Log-Sammlung mit `setup.sh`
+
+---
+
+## 🆕 Version 4.1.0 - Erweiterte Konfliktbehandlung (2025-01-06)
+
+### ✨ Neue Features
+
+- **🔧 Intelligente Druckerkonflikt-Management-Engine**: Automatische Erkennung und Lösung von Zeitüberschneidungen
+- **🎯 Smart-Empfehlungssystem**: KI-basierte Druckerzuweisung mit Scoring-Algorithmus basierend auf:
+  - Verfügbarkeit und Auslastung
+  - Prioritätsstufen (urgent, high, normal, low)
+  - Zeitfenster-Optimierung (Tag-/Nachtschicht)
+  - Job-Dauer-Eignung (Express vs. Langzeit-Jobs)
+- **📊 Echtzeit-Verfügbarkeitsanzeige**: Live-Dashboard mit Druckerstatus und Auslastung
+- **⚠️ Proaktive Konfliktprävention**: Echzeit-Validierung während Formulareingabe
+- **🚀 Automatische Konfliktlösung**: Ein-Klick-Lösung für erkannte Konflikte
+
+### 🔧 Technische Verbesserungen
+
+- **Neue API-Endpunkte**:
+  - `/api/calendar/check-conflicts` - Detaillierte Konfliktanalyse
+  - `/api/calendar/resolve-conflicts` - Automatische Konfliktlösung
+  - `/api/calendar/printer-availability` - Echtzeit-Verfügbarkeit
+- **ConflictManager-Klasse** mit umfassender Konfliktbehandlung
+- **Erweiterte Frontend-Integration** mit modalen Dialogen und Toast-Benachrichtigungen
+- **Smart-Assignment-Algorithmus** mit gewichteter Bewertung
+
+### 📋 Konfliktarten und Behandlung
+
+1. **Zeitüberschneidungen** - Automatische Alternative oder Zeitverschiebung
+2. **Druckerausfälle** - Sofortige Neuzuweisung auf verfügbare Drucker
+3. **Prioritätskonflikte** - Intelligente Umplanung bei höherprioren Jobs
+4. **Ressourcenkonflikte** - Warteschlange mit automatischer Reaktivierung
+
+### 🎨 Benutzeroberfläche
+
+- **Konflikt-Benachrichtigungsmodal** mit detaillierten Lösungsvorschlägen
+- **Verfügbarkeits-Dashboard** mit visuellen Status-Indikatoren
+- **Smart-Empfehlungs-Widget** mit Confidence-Scores
+- **"Konflikte prüfen" Button** für manuelle Validierung
+- **Echtzeit-Verfügbarkeitsanzeige** mit Aktualisierungsbutton
+
+### 📚 Dokumentation
+
+- **[`docs/DRUCKERKONFLIKT_MANAGEMENT.md`](docs/DRUCKERKONFLIKT_MANAGEMENT.md)** - Umfassende Dokumentation des Konfliktsystems
+- Detaillierte API-Referenz für alle neuen Endpunkte
+- Scoring-Algorithmus-Dokumentation mit Beispielen
+- Troubleshooting-Guide für Konfliktbehandlung
+
+### 🔄 Migration
+
+```bash
+# Keine Datenbankmigrationen erforderlich
+# Frontend-Assets aktualisieren
+npm run build:css
+
+# Neue JavaScript-Module laden
+# (Automatisch über Template-Integration)
+```
+
+---
+
+## 🔄 Version 4.0.4 - Setup-Korrekturen (2025-01-12)
+
+### ✅ Behobene Probleme
+
+- **Python-Import-Fehler behoben**: Flask-App kann jetzt korrekt importiert werden
+- **Requirements.txt korrigiert**: Alle Versionskonflikte beseitigt (Werkzeug + Flask)
+- **Internetverbindung-Erkennung**: Multi-Methoden-Prüfung (HTTP/DNS/ICMP/Gateway)
+- **PYTHONPATH-Konflikte behoben**: Robuste Umgebungsvariablen-Behandlung
+- **Robuste Installation**: Mehrstufige Validierung und Fallback-Mechanismen
+- **Python-Umgebung**: Automatische PYTHONPATH-Konfiguration implementiert
+
+### 🔧 Verbesserungen
+
+- Erweiterte Fehlerbehandlung im Setup-Skript
+- Sichere Test-Umgebung für Flask-App-Validierung
+- Performance-Optimierungen für pip-Installation
+- Robuste Netzwerk-Erkennung für Firewalls/Proxys/VirtualBox
+- Umfassende Dokumentation der Korrekturen
+
+### 📋 Nach Update empfohlen
+
+```bash
+# Setup-Skript erneut ausführen für korrigierte Installation
+sudo ./setup.sh  # Option 1 zum Testen der Korrekturen
+
+# Das Setup sollte jetzt reibungslos durchlaufen ohne:
+# - Python-Import-Fehler
+# - PYTHONPATH-Konflikte  
+# - Internetverbindung-Fehlmeldungen
+```
+
+**Details**: Siehe [`docs/SETUP_KORREKTUREN.md`](docs/SETUP_KORREKTUREN.md)
+
+---
+
+**Version**: 4.0.4 (Korrigiert)
+**Plattform**: Debian/Linux (Raspberry Pi OS)
+**Modus**: HTTPS Kiosk (Port 443)
+**Setup**: Konsolidiertes `setup.sh` System
+**Entwickelt für**: Mercedes-Benz MYP

blueprints/admin.py

@@ -0,0 +1,335 @@
+"""
+Admin-Blueprint für das 3D-Druck-Management-System
+
+Dieses Modul enthält alle Admin-spezifischen Routen und Funktionen,
+einschließlich Benutzerverwaltung, Systemüberwachung und Drucker-Administration.
+"""
+
+from flask import Blueprint, render_template, request, jsonify, redirect, url_for, flash
+from flask_login import login_required, current_user
+from functools import wraps
+from models import User, Printer, Job, get_db_session, Stats, SystemLog
+from utils.logging_config import get_logger
+from datetime import datetime
+
+# Blueprint erstellen
+admin_blueprint = Blueprint('admin', __name__, url_prefix='/admin')
+
+# Logger initialisieren
+admin_logger = get_logger("admin")
+
+def admin_required(f):
+    """Decorator für Admin-Berechtigung"""
+    @wraps(f)
+    @login_required
+    def decorated_function(*args, **kwargs):
+        admin_logger.info(f"Admin-Check für Funktion {f.__name__}: User authenticated: {current_user.is_authenticated}, User ID: {current_user.id if current_user.is_authenticated else 'None'}, Is Admin: {current_user.is_admin if current_user.is_authenticated else 'None'}")
+        if not current_user.is_admin:
+            admin_logger.warning(f"Admin-Zugriff verweigert für User {current_user.id if current_user.is_authenticated else 'Anonymous'} auf Funktion {f.__name__}")
+            return jsonify({"error": "Nur Administratoren haben Zugriff"}), 403
+        return f(*args, **kwargs)
+    return decorated_function
+
+@admin_blueprint.route("/")
+@login_required
+@admin_required
+def admin_dashboard():
+    """Admin-Dashboard-Hauptseite"""
+    try:
+        db_session = get_db_session()
+        
+        # Grundlegende Statistiken sammeln
+        total_users = db_session.query(User).count()
+        total_printers = db_session.query(Printer).count()
+        total_jobs = db_session.query(Job).count()
+        
+        # Aktive Jobs zählen
+        active_jobs = db_session.query(Job).filter(
+            Job.status.in_(['pending', 'printing', 'paused'])
+        ).count()
+        
+        db_session.close()
+        
+        stats = {
+            'total_users': total_users,
+            'total_printers': total_printers,
+            'total_jobs': total_jobs,
+            'active_jobs': active_jobs
+        }
+        
+        return render_template('admin/dashboard.html', stats=stats)
+        
+    except Exception as e:
+        admin_logger.error(f"Fehler beim Laden des Admin-Dashboards: {str(e)}")
+        flash("Fehler beim Laden der Dashboard-Daten", "error")
+        return render_template('admin/dashboard.html', stats={})
+
+@admin_blueprint.route("/users")
+@login_required
+@admin_required
+def users_overview():
+    """Benutzerübersicht für Administratoren"""
+    return render_template('admin/users.html')
+
+@admin_blueprint.route("/users/add", methods=["GET"])
+@login_required
+@admin_required
+def add_user_page():
+    """Seite zum Hinzufügen eines neuen Benutzers"""
+    return render_template('admin/add_user.html')
+
+@admin_blueprint.route("/users/<int:user_id>/edit", methods=["GET"])
+@login_required
+@admin_required
+def edit_user_page(user_id):
+    """Seite zum Bearbeiten eines Benutzers"""
+    try:
+        db_session = get_db_session()
+        user = db_session.query(User).filter(User.id == user_id).first()
+        
+        if not user:
+            db_session.close()
+            flash("Benutzer nicht gefunden", "error")
+            return redirect(url_for('admin.users_overview'))
+        
+        db_session.close()
+        return render_template('admin/edit_user.html', user=user)
+        
+    except Exception as e:
+        admin_logger.error(f"Fehler beim Laden der Benutzer-Bearbeitung: {str(e)}")
+        flash("Fehler beim Laden der Benutzerdaten", "error")
+        return redirect(url_for('admin.users_overview'))
+
+@admin_blueprint.route("/printers")
+@login_required
+@admin_required
+def printers_overview():
+    """Druckerübersicht für Administratoren"""
+    return render_template('admin/printers.html')
+
+@admin_blueprint.route("/printers/add", methods=["GET"])
+@login_required
+@admin_required
+def add_printer_page():
+    """Seite zum Hinzufügen eines neuen Druckers"""
+    return render_template('admin/add_printer.html')
+
+@admin_blueprint.route("/printers/<int:printer_id>/edit", methods=["GET"])
+@login_required
+@admin_required
+def edit_printer_page(printer_id):
+    """Seite zum Bearbeiten eines Druckers"""
+    try:
+        db_session = get_db_session()
+        printer = db_session.query(Printer).filter(Printer.id == printer_id).first()
+        
+        if not printer:
+            db_session.close()
+            flash("Drucker nicht gefunden", "error")
+            return redirect(url_for('admin.printers_overview'))
+        
+        db_session.close()
+        return render_template('admin/edit_printer.html', printer=printer)
+        
+    except Exception as e:
+        admin_logger.error(f"Fehler beim Laden der Drucker-Bearbeitung: {str(e)}")
+        flash("Fehler beim Laden der Druckerdaten", "error")
+        return redirect(url_for('admin.printers_overview'))
+
+@admin_blueprint.route("/guest-requests")
+@login_required
+@admin_required
+def guest_requests():
+    """Gäste-Anfragen-Übersicht"""
+    return render_template('admin/guest_requests.html')
+
+@admin_blueprint.route("/advanced-settings")
+@login_required
+@admin_required
+def advanced_settings():
+    """Erweiterte Systemeinstellungen"""
+    return render_template('admin/advanced_settings.html')
+
+@admin_blueprint.route("/system-health")
+@login_required
+@admin_required
+def system_health():
+    """System-Gesundheitsstatus"""
+    return render_template('admin/system_health.html')
+
+@admin_blueprint.route("/logs")
+@login_required
+@admin_required
+def logs_overview():
+    """System-Logs-Übersicht"""
+    return render_template('admin/logs.html')
+
+@admin_blueprint.route("/maintenance")
+@login_required
+@admin_required
+def maintenance():
+    """Wartungsseite"""
+    return render_template('admin/maintenance.html')
+
+# API-Endpunkte für Admin-Funktionen
+@admin_blueprint.route("/api/users", methods=["POST"])
+@login_required
+@admin_required
+def create_user_api():
+    """API-Endpunkt zum Erstellen eines neuen Benutzers"""
+    try:
+        data = request.get_json()
+        
+        # Validierung der erforderlichen Felder
+        required_fields = ['username', 'email', 'password', 'name']
+        for field in required_fields:
+            if field not in data or not data[field]:
+                return jsonify({"error": f"Feld '{field}' ist erforderlich"}), 400
+        
+        db_session = get_db_session()
+        
+        # Überprüfung auf bereits existierende Benutzer
+        existing_user = db_session.query(User).filter(
+            (User.username == data['username']) | (User.email == data['email'])
+        ).first()
+        
+        if existing_user:
+            db_session.close()
+            return jsonify({"error": "Benutzername oder E-Mail bereits vergeben"}), 400
+        
+        # Neuen Benutzer erstellen
+        new_user = User(
+            username=data['username'],
+            email=data['email'],
+            name=data['name'],
+            role=data.get('role', 'user'),
+            department=data.get('department'),
+            position=data.get('position'),
+            phone=data.get('phone'),
+            bio=data.get('bio')
+        )
+        new_user.set_password(data['password'])
+        
+        db_session.add(new_user)
+        db_session.commit()
+        
+        admin_logger.info(f"Neuer Benutzer erstellt: {new_user.username} von Admin {current_user.username}")
+        
+        db_session.close()
+        return jsonify({
+            "success": True,
+            "message": "Benutzer erfolgreich erstellt",
+            "user_id": new_user.id
+        })
+        
+    except Exception as e:
+        admin_logger.error(f"Fehler beim Erstellen des Benutzers: {str(e)}")
+        return jsonify({"error": "Fehler beim Erstellen des Benutzers"}), 500
+
+@admin_blueprint.route("/api/users/<int:user_id>", methods=["GET"])
+@login_required
+@admin_required
+def get_user_api(user_id):
+    """API-Endpunkt zum Abrufen von Benutzerdaten"""
+    try:
+        db_session = get_db_session()
+        user = db_session.query(User).filter(User.id == user_id).first()
+        
+        if not user:
+            db_session.close()
+            return jsonify({"error": "Benutzer nicht gefunden"}), 404
+        
+        user_data = {
+            "id": user.id,
+            "username": user.username,
+            "email": user.email,
+            "name": user.name,
+            "role": user.role,
+            "active": user.active,
+            "created_at": user.created_at.isoformat() if user.created_at else None,
+            "last_login": user.last_login.isoformat() if user.last_login else None,
+            "department": user.department,
+            "position": user.position,
+            "phone": user.phone,
+            "bio": user.bio
+        }
+        
+        db_session.close()
+        return jsonify(user_data)
+        
+    except Exception as e:
+        admin_logger.error(f"Fehler beim Abrufen der Benutzerdaten: {str(e)}")
+        return jsonify({"error": "Fehler beim Abrufen der Benutzerdaten"}), 500
+
+@admin_blueprint.route("/api/users/<int:user_id>", methods=["PUT"])
+@login_required
+@admin_required
+def update_user_api(user_id):
+    """API-Endpunkt zum Aktualisieren von Benutzerdaten"""
+    try:
+        data = request.get_json()
+        
+        db_session = get_db_session()
+        user = db_session.query(User).filter(User.id == user_id).first()
+        
+        if not user:
+            db_session.close()
+            return jsonify({"error": "Benutzer nicht gefunden"}), 404
+        
+        # Aktualisierbare Felder
+        updatable_fields = ['username', 'email', 'name', 'role', 'active', 'department', 'position', 'phone', 'bio']
+        
+        for field in updatable_fields:
+            if field in data:
+                setattr(user, field, data[field])
+        
+        # Passwort separat behandeln
+        if 'password' in data and data['password']:
+            user.set_password(data['password'])
+        
+        user.updated_at = datetime.now()
+        db_session.commit()
+        
+        admin_logger.info(f"Benutzer {user.username} aktualisiert von Admin {current_user.username}")
+        
+        db_session.close()
+        return jsonify({
+            "success": True,
+            "message": "Benutzer erfolgreich aktualisiert"
+        })
+        
+    except Exception as e:
+        admin_logger.error(f"Fehler beim Aktualisieren des Benutzers: {str(e)}")
+        return jsonify({"error": "Fehler beim Aktualisieren des Benutzers"}), 500
+
+@admin_blueprint.route("/api/users/<int:user_id>", methods=["DELETE"])
+@login_required
+@admin_required
+def delete_user_api(user_id):
+    """API-Endpunkt zum Löschen eines Benutzers"""
+    try:
+        if user_id == current_user.id:
+            return jsonify({"error": "Sie können sich nicht selbst löschen"}), 400
+        
+        db_session = get_db_session()
+        user = db_session.query(User).filter(User.id == user_id).first()
+        
+        if not user:
+            db_session.close()
+            return jsonify({"error": "Benutzer nicht gefunden"}), 404
+        
+        username = user.username
+        db_session.delete(user)
+        db_session.commit()
+        
+        admin_logger.info(f"Benutzer {username} gelöscht von Admin {current_user.username}")
+        
+        db_session.close()
+        return jsonify({
+            "success": True,
+            "message": "Benutzer erfolgreich gelöscht"
+        })
+        
+    except Exception as e:
+        admin_logger.error(f"Fehler beim Löschen des Benutzers: {str(e)}")
+        return jsonify({"error": "Fehler beim Löschen des Benutzers"}), 500 

blueprints/admin_api.py

@@ -0,0 +1,489 @@
+"""
+Admin-API Blueprint für erweiterte Verwaltungsfunktionen
+
+Dieses Blueprint stellt zusätzliche Admin-API-Endpunkte bereit für:
+- System-Backups
+- Datenbank-Optimierung  
+- Cache-Verwaltung
+
+Autor: MYP Team
+Datum: 2025-06-01
+"""
+
+import os
+import shutil
+import zipfile
+import sqlite3
+import glob
+from datetime import datetime, timedelta
+from flask import Blueprint, request, jsonify, current_app
+from flask_login import login_required, current_user
+from functools import wraps
+from utils.logging_config import get_logger
+
+# Blueprint erstellen
+admin_api_blueprint = Blueprint('admin_api', __name__, url_prefix='/api/admin')
+
+# Logger initialisieren
+admin_logger = get_logger("admin_api")
+
+def admin_required(f):
+    """Decorator um sicherzustellen, dass nur Admins auf Endpunkte zugreifen können."""
+    @wraps(f)
+    @login_required
+    def decorated_function(*args, **kwargs):
+        if not current_user.is_authenticated or current_user.role != 'admin':
+            admin_logger.warning(f"Unauthorized admin access attempt by user {getattr(current_user, 'id', 'anonymous')}")
+            return jsonify({'error': 'Admin-Berechtigung erforderlich'}), 403
+        return f(*args, **kwargs)
+    return decorated_function
+
+@admin_api_blueprint.route('/backup/create', methods=['POST'])
+@admin_required
+def create_backup():
+    """
+    Erstellt ein manuelles System-Backup.
+    
+    Erstellt eine Sicherung aller wichtigen Systemdaten einschließlich
+    Datenbank, Konfigurationsdateien und Benutzer-Uploads.
+    
+    Returns:
+        JSON: Erfolgs-Status und Backup-Informationen
+    """
+    try:
+        admin_logger.info(f"Backup-Erstellung angefordert von Admin {current_user.username}")
+        
+        # Backup-Verzeichnis sicherstellen
+        backup_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'database', 'backups')
+        os.makedirs(backup_dir, exist_ok=True)
+        
+        # Eindeutigen Backup-Namen erstellen
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        backup_name = f"system_backup_{timestamp}.zip"
+        backup_path = os.path.join(backup_dir, backup_name)
+        
+        created_files = []
+        backup_size = 0
+        
+        with zipfile.ZipFile(backup_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            # 1. Datenbank-Datei hinzufügen
+            try:
+                from config.settings import DATABASE_PATH
+                if os.path.exists(DATABASE_PATH):
+                    zipf.write(DATABASE_PATH, 'database/main.db')
+                    created_files.append('database/main.db')
+                    admin_logger.debug("✅ Hauptdatenbank zur Sicherung hinzugefügt")
+                
+                # WAL- und SHM-Dateien falls vorhanden
+                wal_path = DATABASE_PATH + '-wal'
+                shm_path = DATABASE_PATH + '-shm'
+                
+                if os.path.exists(wal_path):
+                    zipf.write(wal_path, 'database/main.db-wal')
+                    created_files.append('database/main.db-wal')
+                
+                if os.path.exists(shm_path):
+                    zipf.write(shm_path, 'database/main.db-shm')
+                    created_files.append('database/main.db-shm')
+                    
+            except Exception as db_error:
+                admin_logger.warning(f"Fehler beim Hinzufügen der Datenbank: {str(db_error)}")
+            
+            # 2. Konfigurationsdateien
+            try:
+                config_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'config')
+                if os.path.exists(config_dir):
+                    for root, dirs, files in os.walk(config_dir):
+                        for file in files:
+                            if file.endswith(('.py', '.json', '.yaml', '.yml', '.toml')):
+                                file_path = os.path.join(root, file)
+                                arc_path = os.path.relpath(file_path, os.path.dirname(os.path.dirname(__file__)))
+                                zipf.write(file_path, arc_path)
+                                created_files.append(arc_path)
+                    admin_logger.debug("✅ Konfigurationsdateien zur Sicherung hinzugefügt")
+            except Exception as config_error:
+                admin_logger.warning(f"Fehler beim Hinzufügen der Konfiguration: {str(config_error)}")
+            
+            # 3. Wichtige User-Uploads (limitiert auf die letzten 1000 Dateien)
+            try:
+                uploads_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'uploads')
+                if os.path.exists(uploads_dir):
+                    file_count = 0
+                    max_files = 1000  # Limit für Performance
+                    
+                    for root, dirs, files in os.walk(uploads_dir):
+                        for file in files[:max_files - file_count]:
+                            if file_count >= max_files:
+                                break
+                                
+                            file_path = os.path.join(root, file)
+                            file_size = os.path.getsize(file_path)
+                            
+                            # Nur Dateien unter 50MB hinzufügen
+                            if file_size < 50 * 1024 * 1024:
+                                arc_path = os.path.relpath(file_path, os.path.dirname(os.path.dirname(__file__)))
+                                zipf.write(file_path, arc_path)
+                                created_files.append(arc_path)
+                                file_count += 1
+                                
+                        if file_count >= max_files:
+                            break
+                    
+                    admin_logger.debug(f"✅ {file_count} Upload-Dateien zur Sicherung hinzugefügt")
+            except Exception as uploads_error:
+                admin_logger.warning(f"Fehler beim Hinzufügen der Uploads: {str(uploads_error)}")
+            
+            # 4. System-Logs (nur die letzten 100 Log-Dateien)
+            try:
+                logs_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'logs')
+                if os.path.exists(logs_dir):
+                    log_files = []
+                    for root, dirs, files in os.walk(logs_dir):
+                        for file in files:
+                            if file.endswith(('.log', '.txt')):
+                                file_path = os.path.join(root, file)
+                                log_files.append((file_path, os.path.getmtime(file_path)))
+                    
+                    # Sortiere nach Datum (neueste zuerst) und nimm nur die letzten 100
+                    log_files.sort(key=lambda x: x[1], reverse=True)
+                    for file_path, _ in log_files[:100]:
+                        arc_path = os.path.relpath(file_path, os.path.dirname(os.path.dirname(__file__)))
+                        zipf.write(file_path, arc_path)
+                        created_files.append(arc_path)
+                    
+                    admin_logger.debug(f"✅ {len(log_files[:100])} Log-Dateien zur Sicherung hinzugefügt")
+            except Exception as logs_error:
+                admin_logger.warning(f"Fehler beim Hinzufügen der Logs: {str(logs_error)}")
+        
+        # Backup-Größe bestimmen
+        if os.path.exists(backup_path):
+            backup_size = os.path.getsize(backup_path)
+        
+        admin_logger.info(f"✅ System-Backup erfolgreich erstellt: {backup_name} ({backup_size / 1024 / 1024:.2f} MB)")
+        
+        return jsonify({
+            'success': True,
+            'message': f'Backup erfolgreich erstellt: {backup_name}',
+            'backup_info': {
+                'filename': backup_name,
+                'size_bytes': backup_size,
+                'size_mb': round(backup_size / 1024 / 1024, 2),
+                'files_count': len(created_files),
+                'created_at': datetime.now().isoformat(),
+                'path': backup_path
+            }
+        })
+        
+    except Exception as e:
+        admin_logger.error(f"❌ Fehler beim Erstellen des Backups: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': f'Fehler beim Erstellen des Backups: {str(e)}'
+        }), 500
+
+@admin_api_blueprint.route('/database/optimize', methods=['POST'])
+@admin_required
+def optimize_database():
+    """
+    Führt Datenbank-Optimierung durch.
+    
+    Optimiert die SQLite-Datenbank durch VACUUM, ANALYZE und weitere
+    Wartungsoperationen für bessere Performance.
+    
+    Returns:
+        JSON: Erfolgs-Status und Optimierungs-Statistiken
+    """
+    try:
+        admin_logger.info(f"Datenbank-Optimierung angefordert von Admin {current_user.username}")
+        
+        from config.settings import DATABASE_PATH
+        
+        optimization_results = {
+            'vacuum_completed': False,
+            'analyze_completed': False,
+            'integrity_check': False,
+            'wal_checkpoint': False,
+            'size_before': 0,
+            'size_after': 0,
+            'space_saved': 0
+        }
+        
+        # Datenbankgröße vor Optimierung
+        if os.path.exists(DATABASE_PATH):
+            optimization_results['size_before'] = os.path.getsize(DATABASE_PATH)
+        
+        # Verbindung zur Datenbank herstellen
+        conn = sqlite3.connect(DATABASE_PATH, timeout=30.0)
+        cursor = conn.cursor()
+        
+        try:
+            # 1. Integritätsprüfung
+            admin_logger.debug("🔍 Führe Integritätsprüfung durch...")
+            cursor.execute("PRAGMA integrity_check")
+            integrity_result = cursor.fetchone()
+            optimization_results['integrity_check'] = integrity_result[0] == 'ok'
+            
+            if not optimization_results['integrity_check']:
+                admin_logger.warning(f"⚠️ Integritätsprüfung ergab: {integrity_result[0]}")
+            else:
+                admin_logger.debug("✅ Integritätsprüfung erfolgreich")
+            
+            # 2. WAL-Checkpoint (falls WAL-Modus aktiv)
+            try:
+                admin_logger.debug("🔄 Führe WAL-Checkpoint durch...")
+                cursor.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+                optimization_results['wal_checkpoint'] = True
+                admin_logger.debug("✅ WAL-Checkpoint erfolgreich")
+            except Exception as wal_error:
+                admin_logger.debug(f"ℹ️ WAL-Checkpoint nicht möglich: {str(wal_error)}")
+            
+            # 3. ANALYZE - Statistiken aktualisieren
+            admin_logger.debug("📊 Aktualisiere Datenbank-Statistiken...")
+            cursor.execute("ANALYZE")
+            optimization_results['analyze_completed'] = True
+            admin_logger.debug("✅ ANALYZE erfolgreich")
+            
+            # 4. VACUUM - Datenbank komprimieren und reorganisieren
+            admin_logger.debug("🗜️ Komprimiere und reorganisiere Datenbank...")
+            cursor.execute("VACUUM")
+            optimization_results['vacuum_completed'] = True
+            admin_logger.debug("✅ VACUUM erfolgreich")
+            
+            # 5. Performance-Optimierungen
+            try:
+                # Cache-Größe optimieren
+                cursor.execute("PRAGMA cache_size = 10000")  # 10MB Cache
+                
+                # Journal-Modus auf WAL setzen für bessere Concurrent-Performance
+                cursor.execute("PRAGMA journal_mode = WAL")
+                
+                # Synchronous auf NORMAL für Balance zwischen Performance und Sicherheit
+                cursor.execute("PRAGMA synchronous = NORMAL")
+                
+                # Page-Größe optimieren (falls noch nicht gesetzt)
+                cursor.execute("PRAGMA page_size = 4096")
+                
+                admin_logger.debug("✅ Performance-Optimierungen angewendet")
+            except Exception as perf_error:
+                admin_logger.warning(f"⚠️ Performance-Optimierungen teilweise fehlgeschlagen: {str(perf_error)}")
+            
+        finally:
+            cursor.close()
+            conn.close()
+        
+        # Datenbankgröße nach Optimierung
+        if os.path.exists(DATABASE_PATH):
+            optimization_results['size_after'] = os.path.getsize(DATABASE_PATH)
+            optimization_results['space_saved'] = optimization_results['size_before'] - optimization_results['size_after']
+        
+        # Ergebnisse loggen
+        space_saved_mb = optimization_results['space_saved'] / 1024 / 1024
+        admin_logger.info(f"✅ Datenbank-Optimierung abgeschlossen - {space_saved_mb:.2f} MB Speicher gespart")
+        
+        return jsonify({
+            'success': True,
+            'message': 'Datenbank erfolgreich optimiert',
+            'results': {
+                'vacuum_completed': optimization_results['vacuum_completed'],
+                'analyze_completed': optimization_results['analyze_completed'],
+                'integrity_check_passed': optimization_results['integrity_check'],
+                'wal_checkpoint_completed': optimization_results['wal_checkpoint'],
+                'size_before_mb': round(optimization_results['size_before'] / 1024 / 1024, 2),
+                'size_after_mb': round(optimization_results['size_after'] / 1024 / 1024, 2),
+                'space_saved_mb': round(space_saved_mb, 2),
+                'optimization_timestamp': datetime.now().isoformat()
+            }
+        })
+        
+    except Exception as e:
+        admin_logger.error(f"❌ Fehler bei Datenbank-Optimierung: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': f'Fehler bei Datenbank-Optimierung: {str(e)}'
+        }), 500
+
+@admin_api_blueprint.route('/cache/clear', methods=['POST'])
+@admin_required
+def clear_cache():
+    """
+    Leert den System-Cache.
+    
+    Entfernt alle temporären Dateien, Cache-Verzeichnisse und
+    Python-Bytecode um Speicher freizugeben und Performance zu verbessern.
+    
+    Returns:
+        JSON: Erfolgs-Status und Lösch-Statistiken
+    """
+    try:
+        admin_logger.info(f"Cache-Leerung angefordert von Admin {current_user.username}")
+        
+        cleared_stats = {
+            'files_deleted': 0,
+            'dirs_deleted': 0,
+            'space_freed': 0,
+            'categories': {}
+        }
+        
+        app_root = os.path.dirname(os.path.dirname(__file__))
+        
+        # 1. Python-Bytecode-Cache leeren (__pycache__)
+        try:
+            pycache_count = 0
+            pycache_size = 0
+            
+            for root, dirs, files in os.walk(app_root):
+                if '__pycache__' in root:
+                    for file in files:
+                        file_path = os.path.join(root, file)
+                        try:
+                            pycache_size += os.path.getsize(file_path)
+                            os.remove(file_path)
+                            pycache_count += 1
+                        except Exception:
+                            pass
+                    
+                    # Versuche das __pycache__-Verzeichnis zu löschen
+                    try:
+                        os.rmdir(root)
+                        cleared_stats['dirs_deleted'] += 1
+                    except Exception:
+                        pass
+            
+            cleared_stats['categories']['python_bytecode'] = {
+                'files': pycache_count,
+                'size_mb': round(pycache_size / 1024 / 1024, 2)
+            }
+            cleared_stats['files_deleted'] += pycache_count
+            cleared_stats['space_freed'] += pycache_size
+            
+            admin_logger.debug(f"✅ Python-Bytecode-Cache: {pycache_count} Dateien, {pycache_size / 1024 / 1024:.2f} MB")
+            
+        except Exception as pycache_error:
+            admin_logger.warning(f"⚠️ Fehler beim Leeren des Python-Cache: {str(pycache_error)}")
+        
+        # 2. Temporäre Dateien im uploads/temp Verzeichnis
+        try:
+            temp_count = 0
+            temp_size = 0
+            temp_dir = os.path.join(app_root, 'uploads', 'temp')
+            
+            if os.path.exists(temp_dir):
+                for root, dirs, files in os.walk(temp_dir):
+                    for file in files:
+                        file_path = os.path.join(root, file)
+                        try:
+                            temp_size += os.path.getsize(file_path)
+                            os.remove(file_path)
+                            temp_count += 1
+                        except Exception:
+                            pass
+            
+            cleared_stats['categories']['temp_uploads'] = {
+                'files': temp_count,
+                'size_mb': round(temp_size / 1024 / 1024, 2)
+            }
+            cleared_stats['files_deleted'] += temp_count
+            cleared_stats['space_freed'] += temp_size
+            
+            admin_logger.debug(f"✅ Temporäre Upload-Dateien: {temp_count} Dateien, {temp_size / 1024 / 1024:.2f} MB")
+            
+        except Exception as temp_error:
+            admin_logger.warning(f"⚠️ Fehler beim Leeren des Temp-Verzeichnisses: {str(temp_error)}")
+        
+        # 3. System-Cache-Verzeichnisse (falls vorhanden)
+        try:
+            cache_count = 0
+            cache_size = 0
+            
+            cache_dirs = [
+                os.path.join(app_root, 'static', 'cache'),
+                os.path.join(app_root, 'cache'),
+                os.path.join(app_root, '.cache')
+            ]
+            
+            for cache_dir in cache_dirs:
+                if os.path.exists(cache_dir):
+                    for root, dirs, files in os.walk(cache_dir):
+                        for file in files:
+                            file_path = os.path.join(root, file)
+                            try:
+                                cache_size += os.path.getsize(file_path)
+                                os.remove(file_path)
+                                cache_count += 1
+                            except Exception:
+                                pass
+            
+            cleared_stats['categories']['system_cache'] = {
+                'files': cache_count,
+                'size_mb': round(cache_size / 1024 / 1024, 2)
+            }
+            cleared_stats['files_deleted'] += cache_count
+            cleared_stats['space_freed'] += cache_size
+            
+            admin_logger.debug(f"✅ System-Cache: {cache_count} Dateien, {cache_size / 1024 / 1024:.2f} MB")
+            
+        except Exception as cache_error:
+            admin_logger.warning(f"⚠️ Fehler beim Leeren des System-Cache: {str(cache_error)}")
+        
+        # 4. Alte Log-Dateien (älter als 30 Tage)
+        try:
+            logs_count = 0
+            logs_size = 0
+            logs_dir = os.path.join(app_root, 'logs')
+            cutoff_date = datetime.now().timestamp() - (30 * 24 * 60 * 60)  # 30 Tage
+            
+            if os.path.exists(logs_dir):
+                for root, dirs, files in os.walk(logs_dir):
+                    for file in files:
+                        if file.endswith(('.log', '.log.1', '.log.2', '.log.3')):
+                            file_path = os.path.join(root, file)
+                            try:
+                                if os.path.getmtime(file_path) < cutoff_date:
+                                    logs_size += os.path.getsize(file_path)
+                                    os.remove(file_path)
+                                    logs_count += 1
+                            except Exception:
+                                pass
+            
+            cleared_stats['categories']['old_logs'] = {
+                'files': logs_count,
+                'size_mb': round(logs_size / 1024 / 1024, 2)
+            }
+            cleared_stats['files_deleted'] += logs_count
+            cleared_stats['space_freed'] += logs_size
+            
+            admin_logger.debug(f"✅ Alte Log-Dateien: {logs_count} Dateien, {logs_size / 1024 / 1024:.2f} MB")
+            
+        except Exception as logs_error:
+            admin_logger.warning(f"⚠️ Fehler beim Leeren alter Log-Dateien: {str(logs_error)}")
+        
+        # 5. Application-Level Cache leeren (falls Models-Cache existiert)
+        try:
+            from models import clear_model_cache
+            clear_model_cache()
+            admin_logger.debug("✅ Application-Level Cache geleert")
+        except (ImportError, AttributeError):
+            admin_logger.debug("ℹ️ Kein Application-Level Cache verfügbar")
+        
+        # Ergebnisse zusammenfassen
+        total_space_mb = cleared_stats['space_freed'] / 1024 / 1024
+        admin_logger.info(f"✅ Cache-Leerung abgeschlossen: {cleared_stats['files_deleted']} Dateien, {total_space_mb:.2f} MB freigegeben")
+        
+        return jsonify({
+            'success': True,
+            'message': f'Cache erfolgreich geleert - {total_space_mb:.2f} MB freigegeben',
+            'statistics': {
+                'total_files_deleted': cleared_stats['files_deleted'],
+                'total_dirs_deleted': cleared_stats['dirs_deleted'],
+                'total_space_freed_mb': round(total_space_mb, 2),
+                'categories': cleared_stats['categories'],
+                'cleanup_timestamp': datetime.now().isoformat()
+            }
+        })
+        
+    except Exception as e:
+        admin_logger.error(f"❌ Fehler beim Leeren des Cache: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': f'Fehler beim Leeren des Cache: {str(e)}'
+        }), 500 

blueprints/auth.py

@@ -0,0 +1,336 @@
+"""
+Authentifizierungs-Blueprint für das 3D-Druck-Management-System
+
+Dieses Modul enthält alle Routen und Funktionen für die Benutzerauthentifizierung,
+einschließlich Login, Logout, OAuth-Callbacks und Passwort-Reset.
+"""
+
+import logging
+from datetime import datetime
+from flask import Blueprint, render_template, request, jsonify, redirect, url_for, flash, session
+from flask_login import login_user, logout_user, login_required, current_user
+from werkzeug.security import check_password_hash
+from models import User, get_db_session
+from utils.logging_config import get_logger
+
+# Blueprint erstellen
+auth_blueprint = Blueprint('auth', __name__, url_prefix='/auth')
+
+# Logger initialisieren
+auth_logger = get_logger("auth")
+
+@auth_blueprint.route("/login", methods=["GET", "POST"])
+def login():
+    """Benutzeranmeldung mit E-Mail/Benutzername und Passwort"""
+    if current_user.is_authenticated:
+        return redirect(url_for("index"))
+        
+    error = None
+    if request.method == "POST":
+        # Debug-Logging für Request-Details
+        auth_logger.debug(f"Login-Request: Content-Type={request.content_type}, Headers={dict(request.headers)}")
+        
+        # Erweiterte Content-Type-Erkennung für AJAX-Anfragen
+        content_type = request.content_type or ""
+        is_json_request = (
+            request.is_json or 
+            "application/json" in content_type or
+            request.headers.get('X-Requested-With') == 'XMLHttpRequest' or
+            request.headers.get('Accept', '').startswith('application/json')
+        )
+        
+        # Robuste Datenextraktion
+        username = None
+        password = None
+        remember_me = False
+        
+        try:
+            if is_json_request:
+                # JSON-Request verarbeiten
+                try:
+                    data = request.get_json(force=True) or {}
+                    username = data.get("username") or data.get("email")
+                    password = data.get("password")
+                    remember_me = data.get("remember_me", False)
+                except Exception as json_error:
+                    auth_logger.warning(f"JSON-Parsing fehlgeschlagen: {str(json_error)}")
+                    # Fallback zu Form-Daten
+                    username = request.form.get("email")
+                    password = request.form.get("password")
+                    remember_me = request.form.get("remember_me") == "on"
+            else:
+                # Form-Request verarbeiten
+                username = request.form.get("email")
+                password = request.form.get("password")
+                remember_me = request.form.get("remember_me") == "on"
+                
+                # Zusätzlicher Fallback für verschiedene Feldnamen
+                if not username:
+                    username = request.form.get("username") or request.values.get("email") or request.values.get("username")
+                if not password:
+                    password = request.form.get("password") or request.values.get("password")
+                
+        except Exception as extract_error:
+            auth_logger.error(f"Fehler beim Extrahieren der Login-Daten: {str(extract_error)}")
+            error = "Fehler beim Verarbeiten der Anmeldedaten."
+            if is_json_request:
+                return jsonify({"error": error, "success": False}), 400
+        
+        if not username or not password:
+            error = "E-Mail-Adresse und Passwort müssen angegeben werden."
+            auth_logger.warning(f"Unvollständige Login-Daten: username={bool(username)}, password={bool(password)}")
+            if is_json_request:
+                return jsonify({"error": error, "success": False}), 400
+        else:
+            db_session = None
+            try:
+                db_session = get_db_session()
+                # Suche nach Benutzer mit übereinstimmendem Benutzernamen oder E-Mail
+                user = db_session.query(User).filter(
+                    (User.username == username) | (User.email == username)
+                ).first()
+                
+                if user and user.check_password(password):
+                    # Update last login timestamp
+                    user.update_last_login()
+                    db_session.commit()
+                    
+                    login_user(user, remember=remember_me)
+                    auth_logger.info(f"Benutzer {username} hat sich erfolgreich angemeldet")
+                    
+                    next_page = request.args.get("next")
+                    
+                    if is_json_request:
+                        return jsonify({
+                            "success": True,
+                            "message": "Anmeldung erfolgreich",
+                            "redirect_url": next_page or url_for("index")
+                        })
+                    else:
+                        if next_page:
+                            return redirect(next_page)
+                        return redirect(url_for("index"))
+                else:
+                    error = "Ungültige E-Mail-Adresse oder Passwort."
+                    auth_logger.warning(f"Fehlgeschlagener Login-Versuch für Benutzer {username}")
+                    
+                    if is_json_request:
+                        return jsonify({"error": error, "success": False}), 401
+            except Exception as e:
+                # Fehlerbehandlung für Datenbankprobleme
+                error = "Anmeldefehler. Bitte versuchen Sie es später erneut."
+                auth_logger.error(f"Fehler bei der Anmeldung: {str(e)}")
+                if is_json_request:
+                    return jsonify({"error": error, "success": False}), 500
+            finally:
+                # Sicherstellen, dass die Datenbankverbindung geschlossen wird
+                if db_session:
+                    try:
+                        db_session.close()
+                    except Exception as close_error:
+                        auth_logger.error(f"Fehler beim Schließen der DB-Session: {str(close_error)}")
+    
+    return render_template("login.html", error=error)
+
+@auth_blueprint.route("/logout", methods=["GET", "POST"])
+@login_required
+def logout():
+    """Meldet den Benutzer ab"""
+    auth_logger.info(f"Benutzer {current_user.email} hat sich abgemeldet")
+    logout_user()
+    flash("Sie wurden erfolgreich abgemeldet.", "info")
+    return redirect(url_for("auth.login"))
+
+@auth_blueprint.route("/reset-password-request", methods=["GET", "POST"])
+def reset_password_request():
+    """Passwort-Reset anfordern (Placeholder)"""
+    # TODO: Implement password reset functionality
+    flash("Passwort-Reset-Funktionalität ist noch nicht implementiert.", "info")
+    return redirect(url_for("auth.login"))
+
+@auth_blueprint.route("/api/login", methods=["POST"])
+def api_login():
+    """API-Login-Endpunkt für Frontend"""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "Keine Daten erhalten"}), 400
+        
+        username = data.get("username")
+        password = data.get("password")
+        remember_me = data.get("remember_me", False)
+        
+        if not username or not password:
+            return jsonify({"error": "Benutzername und Passwort müssen angegeben werden"}), 400
+        
+        db_session = get_db_session()
+        user = db_session.query(User).filter(
+            (User.username == username) | (User.email == username)
+        ).first()
+        
+        if user and user.check_password(password):
+            # Update last login timestamp
+            user.update_last_login()
+            db_session.commit()
+            
+            login_user(user, remember=remember_me)
+            auth_logger.info(f"API-Login erfolgreich für Benutzer {username}")
+            
+            user_data = {
+                "id": user.id,
+                "username": user.username,
+                "name": user.name,
+                "email": user.email,
+                "is_admin": user.is_admin
+            }
+            
+            db_session.close()
+            return jsonify({
+                "success": True,
+                "user": user_data,
+                "redirect_url": url_for("index")
+            })
+        else:
+            auth_logger.warning(f"Fehlgeschlagener API-Login für Benutzer {username}")
+            db_session.close()
+            return jsonify({"error": "Ungültiger Benutzername oder Passwort"}), 401
+            
+    except Exception as e:
+        auth_logger.error(f"Fehler beim API-Login: {str(e)}")
+        return jsonify({"error": "Anmeldefehler. Bitte versuchen Sie es später erneut"}), 500
+
+@auth_blueprint.route("/api/callback", methods=["GET", "POST"])
+def api_callback():
+    """OAuth-Callback-Endpunkt für externe Authentifizierung"""
+    try:
+        # OAuth-Provider bestimmen
+        provider = request.args.get('provider', 'github')
+        
+        if request.method == "GET":
+            # Authorization Code aus URL-Parameter extrahieren
+            code = request.args.get('code')
+            state = request.args.get('state')
+            error = request.args.get('error')
+            
+            if error:
+                auth_logger.warning(f"OAuth-Fehler von {provider}: {error}")
+                return jsonify({
+                    "error": f"OAuth-Authentifizierung fehlgeschlagen: {error}",
+                    "redirect_url": url_for("auth.login")
+                }), 400
+            
+            if not code:
+                auth_logger.warning(f"Kein Authorization Code von {provider} erhalten")
+                return jsonify({
+                    "error": "Kein Authorization Code erhalten",
+                    "redirect_url": url_for("auth.login")
+                }), 400
+            
+            # State-Parameter validieren (CSRF-Schutz)
+            session_state = session.get('oauth_state')
+            if not state or state != session_state:
+                auth_logger.warning(f"Ungültiger State-Parameter von {provider}")
+                return jsonify({
+                    "error": "Ungültiger State-Parameter",
+                    "redirect_url": url_for("auth.login")
+                }), 400
+            
+            # OAuth-Token austauschen
+            if provider == 'github':
+                user_data = handle_github_callback(code)
+            else:
+                auth_logger.error(f"Unbekannter OAuth-Provider: {provider}")
+                return jsonify({
+                    "error": "Unbekannter OAuth-Provider",
+                    "redirect_url": url_for("auth.login")
+                }), 400
+            
+            if not user_data:
+                return jsonify({
+                    "error": "Fehler beim Abrufen der Benutzerdaten",
+                    "redirect_url": url_for("auth.login")
+                }), 400
+            
+            # Benutzer in Datenbank suchen oder erstellen
+            db_session = get_db_session()
+            try:
+                user = db_session.query(User).filter(
+                    User.email == user_data['email']
+                ).first()
+                
+                if not user:
+                    # Neuen Benutzer erstellen
+                    user = User(
+                        username=user_data['username'],
+                        email=user_data['email'],
+                        name=user_data['name'],
+                        role="user",
+                        oauth_provider=provider,
+                        oauth_id=str(user_data['id'])
+                    )
+                    # Zufälliges Passwort setzen (wird nicht verwendet)
+                    import secrets
+                    user.set_password(secrets.token_urlsafe(32))
+                    db_session.add(user)
+                    db_session.commit()
+                    auth_logger.info(f"Neuer OAuth-Benutzer erstellt: {user.username} via {provider}")
+                else:
+                    # Bestehenden Benutzer aktualisieren
+                    user.oauth_provider = provider
+                    user.oauth_id = str(user_data['id'])
+                    user.name = user_data['name']
+                    user.updated_at = datetime.now()
+                    db_session.commit()
+                    auth_logger.info(f"OAuth-Benutzer aktualisiert: {user.username} via {provider}")
+                
+                # Update last login timestamp
+                user.update_last_login()
+                db_session.commit()
+                
+                login_user(user, remember=True)
+                
+                # Session-State löschen
+                session.pop('oauth_state', None)
+                
+                response_data = {
+                    "success": True,
+                    "user": {
+                        "id": user.id,
+                        "username": user.username,
+                        "name": user.name,
+                        "email": user.email,
+                        "is_admin": user.is_admin
+                    },
+                    "redirect_url": url_for("index")
+                }
+                
+                db_session.close()
+                return jsonify(response_data)
+                
+            except Exception as e:
+                db_session.rollback()
+                db_session.close()
+                auth_logger.error(f"Datenbankfehler bei OAuth-Callback: {str(e)}")
+                return jsonify({
+                    "error": "Datenbankfehler bei der Benutzeranmeldung",
+                    "redirect_url": url_for("auth.login")
+                }), 500
+        
+    except Exception as e:
+        auth_logger.error(f"Fehler im OAuth-Callback: {str(e)}")
+        return jsonify({
+            "error": "OAuth-Callback-Fehler",
+            "redirect_url": url_for("auth.login")
+        }), 500
+
+def handle_github_callback(code):
+    """Verarbeite GitHub OAuth Callback"""
+    # TODO: Implementiere GitHub OAuth Handling
+    auth_logger.warning("GitHub OAuth Callback noch nicht implementiert")
+    return None
+
+def get_github_user_data(access_token):
+    """Lade Benutzerdaten von GitHub API"""
+    # TODO: Implementiere GitHub API Abfrage
+    auth_logger.warning("GitHub User Data Abfrage noch nicht implementiert")
+    return None 

blueprints/jobs.py

@@ -0,0 +1,612 @@
+"""
+Jobs Blueprint - API-Endpunkte für Job-Verwaltung
+Alle Job-bezogenen API-Endpunkte sind hier zentralisiert.
+"""
+
+from flask import Blueprint, request, jsonify, current_app
+from flask_login import login_required, current_user
+from datetime import datetime, timedelta
+from functools import wraps
+from sqlalchemy.orm import joinedload
+
+from models import get_db_session, Job, Printer
+from utils.logging_config import get_logger
+from utils.conflict_manager import conflict_manager
+
+# Blueprint initialisieren - URL-Präfix geändert um Konflikte zu vermeiden
+jobs_blueprint = Blueprint('jobs', __name__, url_prefix='/api/jobs-bp')
+
+# Logger für Jobs
+jobs_logger = get_logger("jobs")
+
+def job_owner_required(f):
+    """Decorator um zu prüfen, ob der aktuelle Benutzer Besitzer eines Jobs ist oder Admin"""
+    @wraps(f)
+    def decorated_function(job_id, *args, **kwargs):
+        db_session = get_db_session()
+        job = db_session.query(Job).filter(Job.id == job_id).first()
+        
+        if not job:
+            db_session.close()
+            return jsonify({"error": "Job nicht gefunden"}), 404
+            
+        is_owner = job.user_id == int(current_user.id) or job.owner_id == int(current_user.id)
+        is_admin = current_user.is_admin
+        
+        if not (is_owner or is_admin):
+            db_session.close()
+            return jsonify({"error": "Keine Berechtigung"}), 403
+            
+        db_session.close()
+        return f(job_id, *args, **kwargs)
+    return decorated_function
+
+def check_printer_status(ip_address: str, timeout: int = 7):
+    """Mock-Implementierung für Drucker-Status-Check"""
+    # TODO: Implementiere echten Status-Check
+    if ip_address:
+        return "online", True
+    return "offline", False
+
+@jobs_blueprint.route('', methods=['GET'])
+@login_required
+def get_jobs():
+    """Gibt alle Jobs zurück. Admins sehen alle Jobs, normale Benutzer nur ihre eigenen."""
+    db_session = get_db_session()
+    
+    try:
+        jobs_logger.info(f"📋 Jobs-Abfrage gestartet von Benutzer {current_user.id} (Admin: {current_user.is_admin})")
+        
+        # Paginierung unterstützen
+        page = request.args.get('page', 1, type=int)
+        per_page = request.args.get('per_page', 50, type=int)
+        status_filter = request.args.get('status')
+        
+        jobs_logger.debug(f"📋 Parameter: page={page}, per_page={per_page}, status_filter={status_filter}")
+        
+        # Query aufbauen
+        query = db_session.query(Job).options(joinedload(Job.user), joinedload(Job.printer))
+        
+        # Admin sieht alle Jobs, User nur eigene
+        if not current_user.is_admin:
+            query = query.filter(Job.user_id == int(current_user.id))
+            jobs_logger.debug(f"🔒 Benutzerfilter angewendet für User {current_user.id}")
+        
+        # Status-Filter anwenden
+        if status_filter:
+            query = query.filter(Job.status == status_filter)
+            jobs_logger.debug(f"🏷️ Status-Filter angewendet: {status_filter}")
+        
+        # Sortierung: neueste zuerst
+        query = query.order_by(Job.created_at.desc())
+        
+        # Paginierung anwenden
+        offset = (page - 1) * per_page
+        jobs = query.offset(offset).limit(per_page).all()
+        
+        # Gesamtanzahl für Paginierung
+        total_count = query.count()
+        
+        # Convert jobs to dictionaries before closing the session
+        job_dicts = [job.to_dict() for job in jobs]
+        
+        db_session.close()
+        
+        jobs_logger.info(f"✅ Jobs erfolgreich abgerufen: {len(job_dicts)} von {total_count} (Seite {page})")
+        
+        return jsonify({
+            "jobs": job_dicts,
+            "pagination": {
+                "page": page,
+                "per_page": per_page,
+                "total": total_count,
+                "pages": (total_count + per_page - 1) // per_page
+            }
+        })
+    except Exception as e:
+        jobs_logger.error(f"❌ Fehler beim Abrufen von Jobs: {str(e)}", exc_info=True)
+        try:
+            db_session.close()
+        except:
+            pass
+        return jsonify({"error": "Interner Serverfehler", "details": str(e)}), 500
+
+@jobs_blueprint.route('/<int:job_id>', methods=['GET'])
+@login_required
+@job_owner_required
+def get_job(job_id):
+    """Gibt einen einzelnen Job zurück."""
+    db_session = get_db_session()
+    
+    try:
+        jobs_logger.info(f"🔍 Job-Detail-Abfrage für Job {job_id} von Benutzer {current_user.id}")
+        
+        # Eagerly load the user and printer relationships
+        job = db_session.query(Job).options(joinedload(Job.user), joinedload(Job.printer)).filter(Job.id == job_id).first()
+        
+        if not job:
+            jobs_logger.warning(f"⚠️ Job {job_id} nicht gefunden")
+            db_session.close()
+            return jsonify({"error": "Job nicht gefunden"}), 404
+            
+        # Convert to dict before closing session
+        job_dict = job.to_dict()
+        db_session.close()
+        
+        jobs_logger.info(f"✅ Job-Details erfolgreich abgerufen für Job {job_id}")
+        return jsonify(job_dict)
+    except Exception as e:
+        jobs_logger.error(f"❌ Fehler beim Abrufen des Jobs {job_id}: {str(e)}", exc_info=True)
+        try:
+            db_session.close()
+        except:
+            pass
+        return jsonify({"error": "Interner Serverfehler", "details": str(e)}), 500
+
+@jobs_blueprint.route('', methods=['POST'])
+@login_required
+def create_job():
+    """
+    Erstellt einen neuen Job.
+    
+    Body: {
+        "name": str (optional),
+        "description": str (optional),
+        "printer_id": int,
+        "start_iso": str,
+        "duration_minutes": int,
+        "file_path": str (optional)
+    }
+    """
+    try:
+        jobs_logger.info(f"🚀 Neue Job-Erstellung gestartet von Benutzer {current_user.id}")
+        
+        data = request.json
+        if not data:
+            jobs_logger.error("❌ Keine JSON-Daten empfangen")
+            return jsonify({"error": "Keine JSON-Daten empfangen"}), 400
+        
+        jobs_logger.debug(f"📋 Empfangene Daten: {data}")
+        
+        # Pflichtfelder prüfen
+        required_fields = ["printer_id", "start_iso", "duration_minutes"]
+        for field in required_fields:
+            if field not in data:
+                jobs_logger.error(f"❌ Pflichtfeld '{field}' fehlt in den Daten")
+                return jsonify({"error": f"Feld '{field}' fehlt"}), 400
+        
+        # Daten extrahieren und validieren
+        try:
+            printer_id = int(data["printer_id"])
+            start_iso = data["start_iso"]
+            duration_minutes = int(data["duration_minutes"])
+            jobs_logger.debug(f"✅ Grunddaten validiert: printer_id={printer_id}, duration={duration_minutes}")
+        except (ValueError, TypeError) as e:
+            jobs_logger.error(f"❌ Fehler bei Datenvalidierung: {str(e)}")
+            return jsonify({"error": f"Ungültige Datenformate: {str(e)}"}), 400
+        
+        # Optional: Jobtitel, Beschreibung und Dateipfad
+        name = data.get("name", f"Druckjob vom {datetime.now().strftime('%d.%m.%Y %H:%M')}")
+        description = data.get("description", "")
+        file_path = data.get("file_path")
+        
+        # Start-Zeit parsen
+        try:
+            start_at = datetime.fromisoformat(start_iso.replace('Z', '+00:00'))
+            jobs_logger.debug(f"✅ Startzeit geparst: {start_at}")
+        except ValueError as e:
+            jobs_logger.error(f"❌ Ungültiges Startdatum '{start_iso}': {str(e)}")
+            return jsonify({"error": f"Ungültiges Startdatum: {str(e)}"}), 400
+        
+        # Dauer validieren
+        if duration_minutes <= 0:
+            jobs_logger.error(f"❌ Ungültige Dauer: {duration_minutes} Minuten")
+            return jsonify({"error": "Dauer muss größer als 0 sein"}), 400
+        
+        # End-Zeit berechnen
+        end_at = start_at + timedelta(minutes=duration_minutes)
+        
+        db_session = get_db_session()
+        
+        try:
+            # Prüfen, ob der Drucker existiert
+            printer = db_session.query(Printer).get(printer_id)
+            if not printer:
+                jobs_logger.error(f"❌ Drucker mit ID {printer_id} nicht gefunden")
+                db_session.close()
+                return jsonify({"error": "Drucker nicht gefunden"}), 404
+            
+            jobs_logger.debug(f"✅ Drucker gefunden: {printer.name} (ID: {printer_id})")
+            
+            # ERWEITERTE KONFLIKTPRÜFUNG
+            job_data = {
+                'printer_id': printer_id,
+                'start_time': start_at,
+                'end_time': end_at,
+                'priority': data.get('priority', 'normal'),
+                'duration_minutes': duration_minutes
+            }
+            
+            # Konflikte erkennen
+            conflicts = conflict_manager.detect_conflicts(job_data, db_session)
+            
+            if conflicts:
+                critical_conflicts = [c for c in conflicts if c.severity.value in ['kritisch', 'hoch']]
+                if critical_conflicts:
+                    # Kritische Konflikte verhindern Job-Erstellung
+                    conflict_descriptions = [c.description for c in critical_conflicts]
+                    jobs_logger.warning(f"⚠️ Kritische Konflikte gefunden: {conflict_descriptions}")
+                    
+                    db_session.close()
+                    return jsonify({
+                        "error": "Kritische Konflikte gefunden",
+                        "conflicts": conflict_descriptions,
+                        "suggestions": [s for c in critical_conflicts for s in c.suggested_solutions]
+                    }), 409
+                
+                # Mittlere/niedrige Konflikte protokollieren aber zulassen
+                jobs_logger.info(f"📋 {len(conflicts)} Konflikte erkannt, aber übergehbar")
+            
+            # Prüfen, ob der Drucker online ist
+            printer_status, printer_active = check_printer_status(printer.plug_ip if printer.plug_ip else "")
+            jobs_logger.debug(f"🖨️ Drucker-Status: {printer_status}, aktiv: {printer_active}")
+            
+            # Status basierend auf Drucker-Verfügbarkeit setzen
+            if printer_status == "online" and printer_active:
+                job_status = "scheduled"
+            else:
+                job_status = "waiting_for_printer"
+            
+            jobs_logger.info(f"📋 Job-Status festgelegt: {job_status}")
+            
+            # Neuen Job erstellen
+            new_job = Job(
+                name=name,
+                description=description,
+                printer_id=printer_id,
+                user_id=current_user.id,
+                owner_id=current_user.id,
+                start_at=start_at,
+                end_at=end_at,
+                status=job_status,
+                file_path=file_path,
+                duration_minutes=duration_minutes
+            )
+            
+            db_session.add(new_job)
+            db_session.commit()
+            
+            # Job-Objekt für die Antwort serialisieren
+            job_dict = new_job.to_dict()
+            db_session.close()
+            
+            jobs_logger.info(f"✅ Neuer Job {new_job.id} erfolgreich erstellt für Drucker {printer_id}, Start: {start_at}, Dauer: {duration_minutes} Minuten")
+            return jsonify({"job": job_dict}), 201
+            
+        except Exception as db_error:
+            jobs_logger.error(f"❌ Datenbankfehler beim Job-Erstellen: {str(db_error)}")
+            try:
+                db_session.rollback()
+                db_session.close()
+            except:
+                pass
+            return jsonify({"error": "Datenbankfehler beim Erstellen des Jobs", "details": str(db_error)}), 500
+    
+    except Exception as e:
+        jobs_logger.error(f"❌ Kritischer Fehler beim Erstellen eines Jobs: {str(e)}", exc_info=True)
+        return jsonify({"error": "Interner Serverfehler", "details": str(e)}), 500
+
+@jobs_blueprint.route('/<int:job_id>', methods=['PUT'])
+@login_required
+@job_owner_required
+def update_job(job_id):
+    """Aktualisiert einen existierenden Job."""
+    try:
+        data = request.json
+        
+        db_session = get_db_session()
+        job = db_session.query(Job).get(job_id)
+        
+        if not job:
+            db_session.close()
+            return jsonify({"error": "Job nicht gefunden"}), 404
+        
+        # Prüfen, ob der Job bearbeitet werden kann
+        if job.status in ["finished", "aborted"]:
+            db_session.close()
+            return jsonify({"error": f"Job kann im Status '{job.status}' nicht bearbeitet werden"}), 400
+        
+        # Felder aktualisieren, falls vorhanden
+        if "name" in data:
+            job.name = data["name"]
+        
+        if "description" in data:
+            job.description = data["description"]
+        
+        if "notes" in data:
+            job.notes = data["notes"]
+        
+        if "start_iso" in data:
+            try:
+                new_start = datetime.fromisoformat(data["start_iso"].replace('Z', '+00:00'))
+                job.start_at = new_start
+                
+                # End-Zeit neu berechnen falls Duration verfügbar
+                if job.duration_minutes:
+                    job.end_at = new_start + timedelta(minutes=job.duration_minutes)
+            except ValueError:
+                db_session.close()
+                return jsonify({"error": "Ungültiges Startdatum"}), 400
+        
+        if "duration_minutes" in data:
+            duration = int(data["duration_minutes"])
+            if duration <= 0:
+                db_session.close()
+                return jsonify({"error": "Dauer muss größer als 0 sein"}), 400
+            
+            job.duration_minutes = duration
+            # End-Zeit neu berechnen
+            if job.start_at:
+                job.end_at = job.start_at + timedelta(minutes=duration)
+        
+        # Aktualisierungszeitpunkt setzen
+        job.updated_at = datetime.now()
+        
+        db_session.commit()
+        
+        # Job-Objekt für die Antwort serialisieren
+        job_dict = job.to_dict()
+        db_session.close()
+        
+        jobs_logger.info(f"Job {job_id} aktualisiert")
+        return jsonify({"job": job_dict})
+    
+    except Exception as e:
+        jobs_logger.error(f"Fehler beim Aktualisieren von Job {job_id}: {str(e)}")
+        return jsonify({"error": "Interner Serverfehler", "details": str(e)}), 500
+
+@jobs_blueprint.route('/<int:job_id>', methods=['DELETE'])
+@login_required
+@job_owner_required
+def delete_job(job_id):
+    """Löscht einen Job."""
+    try:
+        db_session = get_db_session()
+        job = db_session.query(Job).get(job_id)
+        
+        if not job:
+            db_session.close()
+            return jsonify({"error": "Job nicht gefunden"}), 404
+        
+        # Prüfen, ob der Job gelöscht werden kann
+        if job.status == "running":
+            db_session.close()
+            return jsonify({"error": "Laufende Jobs können nicht gelöscht werden"}), 400
+        
+        job_name = job.name
+        db_session.delete(job)
+        db_session.commit()
+        db_session.close()
+        
+        jobs_logger.info(f"Job '{job_name}' (ID: {job_id}) gelöscht von Benutzer {current_user.id}")
+        return jsonify({"success": True, "message": "Job erfolgreich gelöscht"})
+        
+    except Exception as e:
+        jobs_logger.error(f"Fehler beim Löschen des Jobs {job_id}: {str(e)}")
+        return jsonify({"error": "Interner Serverfehler"}), 500
+
+@jobs_blueprint.route('/active', methods=['GET'])
+@login_required
+def get_active_jobs():
+    """Gibt alle aktiven Jobs zurück."""
+    try:
+        db_session = get_db_session()
+        
+        query = db_session.query(Job).options(
+            joinedload(Job.user), 
+            joinedload(Job.printer)
+        ).filter(
+            Job.status.in_(["scheduled", "running"])
+        )
+        
+        # Normale Benutzer sehen nur ihre eigenen aktiven Jobs
+        if not current_user.is_admin:
+            query = query.filter(Job.user_id == current_user.id)
+        
+        active_jobs = query.all()
+        
+        result = []
+        for job in active_jobs:
+            job_dict = job.to_dict()
+            # Aktuelle Restzeit berechnen
+            if job.status == "running" and job.end_at:
+                remaining_time = job.end_at - datetime.now()
+                if remaining_time.total_seconds() > 0:
+                    job_dict["remaining_minutes"] = int(remaining_time.total_seconds() / 60)
+                else:
+                    job_dict["remaining_minutes"] = 0
+            
+            result.append(job_dict)
+        
+        db_session.close()
+        return jsonify({"jobs": result})
+    except Exception as e:
+        jobs_logger.error(f"Fehler beim Abrufen aktiver Jobs: {str(e)}")
+        return jsonify({"error": "Interner Serverfehler", "details": str(e)}), 500
+
+@jobs_blueprint.route('/current', methods=['GET'])
+@login_required
+def get_current_job():
+    """Gibt den aktuell laufenden Job für den eingeloggten Benutzer zurück."""
+    db_session = get_db_session()
+    
+    try:
+        current_job = db_session.query(Job).filter(
+            Job.user_id == current_user.id,
+            Job.status == "running"
+        ).first()
+        
+        if current_job:
+            job_dict = current_job.to_dict()
+            db_session.close()
+            return jsonify(job_dict)
+        else:
+            db_session.close()
+            return jsonify({"message": "Kein aktueller Job"}), 404
+    except Exception as e:
+        jobs_logger.error(f"Fehler beim Abrufen des aktuellen Jobs: {str(e)}")
+        db_session.close()
+        return jsonify({"error": "Interner Serverfehler"}), 500
+
+@jobs_blueprint.route('/<int:job_id>/start', methods=['POST'])
+@login_required
+@job_owner_required
+def start_job(job_id):
+    """Startet einen Job manuell."""
+    try:
+        db_session = get_db_session()
+        job = db_session.query(Job).options(joinedload(Job.printer)).get(job_id)
+        
+        if not job:
+            db_session.close()
+            return jsonify({"error": "Job nicht gefunden"}), 404
+        
+        # Prüfen, ob der Job gestartet werden kann
+        if job.status not in ["scheduled", "waiting_for_printer"]:
+            db_session.close()
+            return jsonify({"error": f"Job kann im Status '{job.status}' nicht gestartet werden"}), 400
+        
+        # Drucker-Status prüfen
+        if job.printer.plug_ip:
+            status, active = check_printer_status(job.printer.plug_ip)
+            if status != "online" or not active:
+                db_session.close()
+                return jsonify({"error": "Drucker ist nicht online"}), 400
+        
+        # Job als laufend markieren
+        job.status = "running"
+        job.start_at = datetime.now()
+        job.end_at = job.start_at + timedelta(minutes=job.duration_minutes)
+        
+        db_session.commit()
+        
+        # Job-Objekt für die Antwort serialisieren
+        job_dict = job.to_dict()
+        db_session.close()
+        
+        jobs_logger.info(f"Job {job_id} manuell gestartet")
+        return jsonify({"job": job_dict})
+    
+    except Exception as e:
+        jobs_logger.error(f"Fehler beim Starten von Job {job_id}: {str(e)}")
+        return jsonify({"error": "Interner Serverfehler", "details": str(e)}), 500
+
+@jobs_blueprint.route('/<int:job_id>/pause', methods=['POST'])
+@login_required
+@job_owner_required
+def pause_job(job_id):
+    """Pausiert einen laufenden Job."""
+    try:
+        db_session = get_db_session()
+        job = db_session.query(Job).get(job_id)
+        
+        if not job:
+            db_session.close()
+            return jsonify({"error": "Job nicht gefunden"}), 404
+        
+        # Prüfen, ob der Job pausiert werden kann
+        if job.status != "running":
+            db_session.close()
+            return jsonify({"error": f"Job kann im Status '{job.status}' nicht pausiert werden"}), 400
+        
+        # Job pausieren
+        job.status = "paused"
+        
+        db_session.commit()
+        
+        # Job-Objekt für die Antwort serialisieren
+        job_dict = job.to_dict()
+        db_session.close()
+        
+        jobs_logger.info(f"Job {job_id} pausiert")
+        return jsonify({"job": job_dict})
+    
+    except Exception as e:
+        jobs_logger.error(f"Fehler beim Pausieren von Job {job_id}: {str(e)}")
+        return jsonify({"error": "Interner Serverfehler", "details": str(e)}), 500
+
+@jobs_blueprint.route('/<int:job_id>/resume', methods=['POST'])
+@login_required
+@job_owner_required
+def resume_job(job_id):
+    """Setzt einen pausierten Job fort."""
+    try:
+        db_session = get_db_session()
+        job = db_session.query(Job).get(job_id)
+        
+        if not job:
+            db_session.close()
+            return jsonify({"error": "Job nicht gefunden"}), 404
+        
+        # Prüfen, ob der Job fortgesetzt werden kann
+        if job.status != "paused":
+            db_session.close()
+            return jsonify({"error": f"Job kann im Status '{job.status}' nicht fortgesetzt werden"}), 400
+        
+        # Job fortsetzen
+        job.status = "running"
+        
+        db_session.commit()
+        
+        # Job-Objekt für die Antwort serialisieren
+        job_dict = job.to_dict()
+        db_session.close()
+        
+        jobs_logger.info(f"Job {job_id} fortgesetzt")
+        return jsonify({"job": job_dict})
+    
+    except Exception as e:
+        jobs_logger.error(f"Fehler beim Fortsetzen von Job {job_id}: {str(e)}")
+        return jsonify({"error": "Interner Serverfehler", "details": str(e)}), 500
+
+@jobs_blueprint.route('/<int:job_id>/finish', methods=['POST'])
+@login_required
+def finish_job(job_id):
+    """Beendet einen Job manuell."""
+    try:
+        db_session = get_db_session()
+        job = db_session.query(Job).options(joinedload(Job.printer)).get(job_id)
+        
+        if not job:
+            db_session.close()
+            return jsonify({"error": "Job nicht gefunden"}), 404
+        
+        # Berechtigung prüfen
+        is_owner = job.user_id == int(current_user.id) or job.owner_id == int(current_user.id)
+        is_admin = current_user.is_admin
+        
+        if not (is_owner or is_admin):
+            db_session.close()
+            return jsonify({"error": "Keine Berechtigung"}), 403
+        
+        # Prüfen, ob der Job beendet werden kann
+        if job.status not in ["scheduled", "running", "paused"]:
+            db_session.close()
+            return jsonify({"error": f"Job kann im Status '{job.status}' nicht beendet werden"}), 400
+        
+        # Job als beendet markieren
+        job.status = "finished"
+        job.actual_end_time = datetime.now()
+        
+        db_session.commit()
+        
+        # Job-Objekt für die Antwort serialisieren
+        job_dict = job.to_dict()
+        db_session.close()
+        
+        jobs_logger.info(f"Job {job_id} manuell beendet durch Benutzer {current_user.id}")
+        return jsonify({"job": job_dict})
+    
+    except Exception as e:
+        jobs_logger.error(f"Fehler beim manuellen Beenden von Job {job_id}: {str(e)}")
+        return jsonify({"error": "Interner Serverfehler", "details": str(e)}), 500 

blueprints/printers.py

@@ -0,0 +1,966 @@
+"""
+Drucker-Blueprint für MYP Platform
+Enthält alle Routen und Funktionen zur Druckerverwaltung, Statusüberwachung und Steuerung.
+"""
+
+import os
+import json
+import time
+from datetime import datetime, timedelta
+from flask import Blueprint, request, jsonify, current_app, abort, Response
+from flask_login import login_required, current_user
+from werkzeug.utils import secure_filename
+from werkzeug.exceptions import NotFound, BadRequest
+from sqlalchemy import func, desc, asc
+from sqlalchemy.exc import SQLAlchemyError
+from typing import Dict, List, Tuple, Any, Optional
+
+from models import Printer, User, Job, get_db_session
+from utils.logging_config import get_logger, measure_execution_time
+from utils.permissions import require_permission, Permission, check_permission
+from utils.printer_monitor import printer_monitor
+from utils.drag_drop_system import drag_drop_manager
+
+# Logger initialisieren
+printers_logger = get_logger("printers")
+
+# Blueprint erstellen
+printers_blueprint = Blueprint("printers", __name__, url_prefix="/api/printers")
+
+@printers_blueprint.route("/monitor/live-status", methods=["GET"])
+@login_required
+@measure_execution_time(logger=printers_logger, task_name="API-Live-Drucker-Status-Abfrage")
+def get_live_printer_status():
+    """
+    Liefert den aktuellen Live-Status aller Drucker.
+    
+    Query-Parameter:
+    - use_cache: ob Cache verwendet werden soll (default: true)
+    
+    Returns:
+        JSON mit Live-Status aller Drucker
+    """
+    printers_logger.info(f"🔄 Live-Status-Abfrage von Benutzer {current_user.name} (ID: {current_user.id})")
+    
+    # Parameter auslesen
+    use_cache_param = request.args.get("use_cache", "true").lower()
+    use_cache = use_cache_param == "true"
+    
+    try:
+        # Live-Status über den PrinterMonitor abrufen
+        status_data = printer_monitor.get_live_printer_status(use_session_cache=use_cache)
+        
+        # Zusammenfassung der Druckerstatus erstellen
+        summary = printer_monitor.get_printer_summary()
+        
+        # Antwort mit Status und Zusammenfassung
+        response = {
+            "success": True,
+            "status": status_data,
+            "summary": summary,
+            "timestamp": datetime.now().isoformat(),
+            "cache_used": use_cache
+        }
+        
+        printers_logger.info(f"✅ Live-Status-Abfrage erfolgreich: {len(status_data)} Drucker")
+        return jsonify(response)
+        
+    except Exception as e:
+        printers_logger.error(f"❌ Fehler bei Live-Status-Abfrage: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": "Fehler bei Abfrage des Druckerstatus",
+            "message": str(e)
+        }), 500
+
+@printers_blueprint.route("/control/<int:printer_id>/power", methods=["POST"])
+@login_required
+@require_permission(Permission.CONTROL_PRINTER)  # Verwende die bereits vorhandene Berechtigung
+@measure_execution_time(logger=printers_logger, task_name="API-Drucker-Stromversorgung-Steuerung")
+def control_printer_power(printer_id):
+    """
+    Steuert die Stromversorgung eines Druckers (ein-/ausschalten).
+    
+    Args:
+        printer_id: ID des zu steuernden Druckers
+    
+    JSON-Parameter:
+    - action: "on" oder "off"
+    
+    Returns:
+        JSON mit Ergebnis der Steuerungsaktion
+    """
+    printers_logger.info(f"🔌 Stromsteuerung für Drucker {printer_id} von Benutzer {current_user.name}")
+    
+    # Parameter validieren
+    data = request.get_json()
+    if not data or "action" not in data:
+        return jsonify({
+            "success": False,
+            "error": "Parameter 'action' fehlt"
+        }), 400
+        
+    action = data["action"]
+    if action not in ["on", "off"]:
+        return jsonify({
+            "success": False,
+            "error": "Ungültige Aktion. Erlaubt sind 'on' oder 'off'."
+        }), 400
+    
+    try:
+        # Drucker aus Datenbank holen
+        db_session = get_db_session()
+        printer = db_session.query(Printer).filter(Printer.id == printer_id).first()
+        
+        if not printer:
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": f"Drucker mit ID {printer_id} nicht gefunden"
+            }), 404
+            
+        # Prüfen, ob Drucker eine Steckdose konfiguriert hat
+        if not printer.plug_ip or not printer.plug_username or not printer.plug_password:
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": f"Drucker {printer.name} hat keine Steckdose konfiguriert"
+            }), 400
+            
+        # Steckdose steuern
+        from PyP100 import PyP110
+        try:
+            # TP-Link Tapo P110 Verbindung herstellen
+            p110 = PyP110.P110(printer.plug_ip, printer.plug_username, printer.plug_password)
+            p110.handshake()  # Authentifizierung
+            p110.login()      # Login
+            
+            # Steckdose ein- oder ausschalten
+            if action == "on":
+                p110.turnOn()
+                success = True
+                message = "Steckdose erfolgreich eingeschaltet"
+                printer.status = "starting"  # Status aktualisieren
+            else:
+                p110.turnOff()
+                success = True
+                message = "Steckdose erfolgreich ausgeschaltet"
+                printer.status = "offline"  # Status aktualisieren
+                
+            # Zeitpunkt der letzten Prüfung aktualisieren
+            printer.last_checked = datetime.now()
+            db_session.commit()
+            
+            # Cache leeren, damit neue Status-Abfragen aktuell sind
+            printer_monitor.clear_all_caches()
+            
+            printers_logger.info(f"✅ {action.upper()}: Drucker {printer.name} erfolgreich {message}")
+            
+        except Exception as e:
+            printers_logger.error(f"❌ Fehler bei Steckdosensteuerung für {printer.name}: {str(e)}")
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": f"Fehler bei Steckdosensteuerung: {str(e)}"
+            }), 500
+            
+        db_session.close()
+        return jsonify({
+            "success": True,
+            "message": message,
+            "printer_id": printer_id,
+            "printer_name": printer.name,
+            "action": action,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+    except Exception as e:
+        printers_logger.error(f"❌ Allgemeiner Fehler bei Stromsteuerung: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Allgemeiner Fehler: {str(e)}"
+        }), 500
+
+@printers_blueprint.route("/test/socket/<int:printer_id>", methods=["GET"])
+@login_required
+@require_permission(Permission.ADMIN)
+@measure_execution_time(logger=printers_logger, task_name="API-Steckdosen-Test-Status")
+def test_socket_status(printer_id):
+    """
+    Prüft den aktuellen Status einer Steckdose für Testzwecke (nur für Ausbilder/Administratoren).
+    
+    Args:
+        printer_id: ID des Druckers dessen Steckdose getestet werden soll
+    
+    Returns:
+        JSON mit detailliertem Status der Steckdose und Warnungen
+    """
+    printers_logger.info(f"🔍 Steckdosen-Test-Status für Drucker {printer_id} von Admin {current_user.name}")
+    
+    try:
+        # Drucker aus Datenbank holen
+        db_session = get_db_session()
+        printer = db_session.query(Printer).filter(Printer.id == printer_id).first()
+        
+        if not printer:
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": f"Drucker mit ID {printer_id} nicht gefunden"
+            }), 404
+            
+        # Prüfen, ob Drucker eine Steckdose konfiguriert hat
+        if not printer.plug_ip or not printer.plug_username or not printer.plug_password:
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": f"Drucker {printer.name} hat keine Steckdose konfiguriert",
+                "warning": "Steckdose kann nicht getestet werden - Konfiguration fehlt"
+            }), 400
+            
+        # Prüfen, ob der Drucker gerade aktive Jobs hat
+        active_jobs = db_session.query(Job).filter(
+            Job.printer_id == printer_id,
+            Job.status.in_(["running", "printing", "active"])
+        ).all()
+        
+        db_session.close()
+        
+        # Steckdosen-Status prüfen
+        from PyP100 import PyP110
+        socket_status = None
+        socket_info = None
+        error_message = None
+        
+        try:
+            # TP-Link Tapo P110 Verbindung herstellen
+            p110 = PyP110.P110(printer.plug_ip, printer.plug_username, printer.plug_password)
+            p110.handshake()  # Authentifizierung
+            p110.login()      # Login
+            
+            # Geräteinformationen abrufen
+            device_info = p110.getDeviceInfo()
+            socket_status = "online" if device_info["result"]["device_on"] else "offline"
+            
+            # Energieverbrauch abrufen (falls verfügbar)
+            try:
+                energy_info = p110.getEnergyUsage()
+                current_power = energy_info.get("result", {}).get("current_power", 0)
+            except:
+                current_power = None
+                
+            socket_info = {
+                "device_on": device_info["result"]["device_on"],
+                "signal_level": device_info["result"].get("signal_level", 0),
+                "current_power": current_power,
+                "device_id": device_info["result"].get("device_id", "Unbekannt"),
+                "model": device_info["result"].get("model", "Unbekannt"),
+                "hw_ver": device_info["result"].get("hw_ver", "Unbekannt"),
+                "fw_ver": device_info["result"].get("fw_ver", "Unbekannt")
+            }
+            
+        except Exception as e:
+            printers_logger.warning(f"⚠️ Fehler bei Steckdosen-Status-Abfrage für {printer.name}: {str(e)}")
+            socket_status = "error"
+            error_message = str(e)
+            
+        # Warnungen und Empfehlungen zusammenstellen
+        warnings = []
+        recommendations = []
+        risk_level = "low"
+        
+        if active_jobs:
+            warnings.append(f"ACHTUNG: Drucker hat {len(active_jobs)} aktive(n) Job(s)!")
+            risk_level = "high"
+            recommendations.append("Warten Sie bis alle Jobs abgeschlossen sind bevor Sie die Steckdose ausschalten")
+            
+        if socket_status == "online" and socket_info and socket_info.get("device_on"):
+            if socket_info.get("current_power", 0) > 10:  # Mehr als 10W Verbrauch
+                warnings.append(f"Drucker verbraucht aktuell {socket_info['current_power']}W - vermutlich aktiv")
+                risk_level = "medium" if risk_level == "low" else risk_level
+                recommendations.append("Prüfen Sie den Druckerstatus bevor Sie die Steckdose ausschalten")
+            else:
+                recommendations.append("Drucker scheint im Standby-Modus zu sein - Test sollte sicher möglich sein")
+                
+        if socket_status == "error":
+            warnings.append("Steckdose nicht erreichbar - Netzwerk oder Konfigurationsproblem")
+            recommendations.append("Prüfen Sie die Netzwerkverbindung und Steckdosen-Konfiguration")
+            
+        if not warnings and socket_status == "offline":
+            recommendations.append("Steckdose ist ausgeschaltet - Test kann sicher durchgeführt werden")
+        
+        printers_logger.info(f"✅ Steckdosen-Test-Status erfolgreich abgerufen für {printer.name}")
+        
+        return jsonify({
+            "success": True,
+            "printer": {
+                "id": printer.id,
+                "name": printer.name,
+                "model": printer.model,
+                "location": printer.location,
+                "status": printer.status
+            },
+            "socket": {
+                "status": socket_status,
+                "info": socket_info,
+                "error": error_message,
+                "ip_address": printer.plug_ip
+            },
+            "safety": {
+                "risk_level": risk_level,
+                "warnings": warnings,
+                "recommendations": recommendations,
+                "active_jobs_count": len(active_jobs),
+                "safe_to_test": len(warnings) == 0
+            },
+            "timestamp": datetime.now().isoformat()
+        })
+        
+    except Exception as e:
+        printers_logger.error(f"❌ Allgemeiner Fehler bei Steckdosen-Test-Status: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Allgemeiner Fehler: {str(e)}"
+        }), 500
+
+@printers_blueprint.route("/test/socket/<int:printer_id>/control", methods=["POST"])
+@login_required
+@require_permission(Permission.ADMIN)
+@measure_execution_time(logger=printers_logger, task_name="API-Steckdosen-Test-Steuerung")
+def test_socket_control(printer_id):
+    """
+    Steuert eine Steckdose für Testzwecke (nur für Ausbilder/Administratoren).
+    Diese Funktion zeigt Warnungen an, erlaubt aber trotzdem die Steuerung für Tests.
+    
+    Args:
+        printer_id: ID des Druckers dessen Steckdose gesteuert werden soll
+    
+    JSON-Parameter:
+    - action: "on" oder "off"
+    - force: boolean - überschreibt Sicherheitswarnungen (default: false)
+    - test_reason: string - Grund für den Test (optional)
+    
+    Returns:
+        JSON mit Ergebnis der Steuerungsaktion und Warnungen
+    """
+    printers_logger.info(f"🧪 Steckdosen-Test-Steuerung für Drucker {printer_id} von Admin {current_user.name}")
+    
+    # Parameter validieren
+    data = request.get_json()
+    if not data or "action" not in data:
+        return jsonify({
+            "success": False,
+            "error": "Parameter 'action' fehlt"
+        }), 400
+        
+    action = data["action"]
+    if action not in ["on", "off"]:
+        return jsonify({
+            "success": False,
+            "error": "Ungültige Aktion. Erlaubt sind 'on' oder 'off'."
+        }), 400
+        
+    force = data.get("force", False)
+    test_reason = data.get("test_reason", "Routinetest")
+    
+    try:
+        # Drucker aus Datenbank holen
+        db_session = get_db_session()
+        printer = db_session.query(Printer).filter(Printer.id == printer_id).first()
+        
+        if not printer:
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": f"Drucker mit ID {printer_id} nicht gefunden"
+            }), 404
+            
+        # Prüfen, ob Drucker eine Steckdose konfiguriert hat
+        if not printer.plug_ip or not printer.plug_username or not printer.plug_password:
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": f"Drucker {printer.name} hat keine Steckdose konfiguriert"
+            }), 400
+            
+        # Aktive Jobs prüfen
+        active_jobs = db_session.query(Job).filter(
+            Job.printer_id == printer_id,
+            Job.status.in_(["running", "printing", "active"])
+        ).all()
+        
+        # Sicherheitsprüfungen
+        warnings = []
+        should_block = False
+        
+        if active_jobs and action == "off":
+            warnings.append(f"WARNUNG: {len(active_jobs)} aktive Job(s) würden abgebrochen!")
+            if not force:
+                should_block = True
+                
+        if should_block:
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": "Aktion blockiert aufgrund von Sicherheitsbedenken",
+                "warnings": warnings,
+                "hint": "Verwenden Sie 'force': true um die Aktion trotzdem auszuführen",
+                "requires_force": True
+            }), 409  # Conflict
+            
+        # Steckdose steuern
+        from PyP100 import PyP110
+        try:
+            # TP-Link Tapo P110 Verbindung herstellen
+            p110 = PyP110.P110(printer.plug_ip, printer.plug_username, printer.plug_password)
+            p110.handshake()  # Authentifizierung
+            p110.login()      # Login
+            
+            # Aktuellen Status vor der Änderung abrufen
+            device_info_before = p110.getDeviceInfo()
+            status_before = device_info_before["result"]["device_on"]
+            
+            # Steckdose ein- oder ausschalten
+            if action == "on":
+                p110.turnOn()
+                success = True
+                message = "Steckdose für Test erfolgreich eingeschaltet"
+                new_printer_status = "starting"
+            else:
+                p110.turnOff()
+                success = True
+                message = "Steckdose für Test erfolgreich ausgeschaltet"
+                new_printer_status = "offline"
+                
+            # Kurz warten und neuen Status prüfen
+            time.sleep(2)
+            device_info_after = p110.getDeviceInfo()
+            status_after = device_info_after["result"]["device_on"]
+            
+            # Drucker-Status aktualisieren
+            printer.status = new_printer_status
+            printer.last_checked = datetime.now()
+            db_session.commit()
+            
+            # Cache leeren, damit neue Status-Abfragen aktuell sind
+            printer_monitor.clear_all_caches()
+            
+            # Test-Eintrag für Audit-Log
+            printers_logger.info(f"🧪 TEST DURCHGEFÜHRT: {action.upper()} für {printer.name} | "
+                               f"Admin: {current_user.name} | Grund: {test_reason} | "
+                               f"Force: {force} | Status: {status_before} → {status_after}")
+            
+        except Exception as e:
+            printers_logger.error(f"❌ Fehler bei Test-Steckdosensteuerung für {printer.name}: {str(e)}")
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": f"Fehler bei Steckdosensteuerung: {str(e)}"
+            }), 500
+            
+        db_session.close()
+        return jsonify({
+            "success": True,
+            "message": message,
+            "test_info": {
+                "admin": current_user.name,
+                "reason": test_reason,
+                "forced": force,
+                "status_before": status_before,
+                "status_after": status_after
+            },
+            "printer": {
+                "id": printer_id,
+                "name": printer.name,
+                "status": new_printer_status
+            },
+            "action": action,
+            "warnings": warnings,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+    except Exception as e:
+        printers_logger.error(f"❌ Allgemeiner Fehler bei Test-Steckdosensteuerung: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Allgemeiner Fehler: {str(e)}"
+        }), 500
+
+@printers_blueprint.route("/test/all-sockets", methods=["GET"])
+@login_required
+@require_permission(Permission.ADMIN)
+@measure_execution_time(logger=printers_logger, task_name="API-Alle-Steckdosen-Test-Status")
+def test_all_sockets_status():
+    """
+    Liefert den Test-Status aller konfigurierten Steckdosen (nur für Ausbilder/Administratoren).
+    
+    Returns:
+        JSON mit Status aller Steckdosen und Gesamtübersicht
+    """
+    printers_logger.info(f"🔍 Alle-Steckdosen-Test-Status von Admin {current_user.name}")
+    
+    try:
+        # Alle Drucker mit Steckdosen-Konfiguration holen
+        db_session = get_db_session()
+        printers = db_session.query(Printer).filter(
+            Printer.plug_ip.isnot(None),
+            Printer.plug_username.isnot(None),
+            Printer.plug_password.isnot(None)
+        ).all()
+        
+        results = []
+        total_online = 0
+        total_offline = 0
+        total_error = 0
+        total_warnings = 0
+        
+        from PyP100 import PyP110
+        
+        for printer in printers:
+            # Aktive Jobs für diesen Drucker prüfen
+            active_jobs = db_session.query(Job).filter(
+                Job.printer_id == printer.id,
+                Job.status.in_(["running", "printing", "active"])
+            ).count()
+            
+            # Steckdosen-Status prüfen
+            socket_status = "unknown"
+            device_on = False
+            current_power = None
+            error_message = None
+            warnings = []
+            
+            try:
+                p110 = PyP110.P110(printer.plug_ip, printer.plug_username, printer.plug_password)
+                p110.handshake()
+                p110.login()
+                
+                device_info = p110.getDeviceInfo()
+                device_on = device_info["result"]["device_on"]
+                socket_status = "online" if device_on else "offline"
+                
+                # Energieverbrauch abrufen
+                try:
+                    energy_info = p110.getEnergyUsage()
+                    current_power = energy_info.get("result", {}).get("current_power", 0)
+                except:
+                    current_power = None
+                    
+                # Warnungen generieren
+                if active_jobs > 0:
+                    warnings.append(f"{active_jobs} aktive Job(s)")
+                    
+                if device_on and current_power and current_power > 10:
+                    warnings.append(f"Hoher Verbrauch: {current_power}W")
+                    
+            except Exception as e:
+                socket_status = "error"
+                error_message = str(e)
+                warnings.append(f"Verbindungsfehler: {str(e)[:50]}")
+                
+            # Statistiken aktualisieren
+            if socket_status == "online":
+                total_online += 1
+            elif socket_status == "offline":
+                total_offline += 1
+            else:
+                total_error += 1
+                
+            if warnings:
+                total_warnings += 1
+                
+            results.append({
+                "printer": {
+                    "id": printer.id,
+                    "name": printer.name,
+                    "model": printer.model,
+                    "location": printer.location
+                },
+                "socket": {
+                    "status": socket_status,
+                    "device_on": device_on,
+                    "current_power": current_power,
+                    "ip_address": printer.plug_ip,
+                    "error": error_message
+                },
+                "warnings": warnings,
+                "active_jobs": active_jobs,
+                "safe_to_test": len(warnings) == 0
+            })
+            
+        db_session.close()
+        
+        # Gesamtübersicht erstellen
+        summary = {
+            "total_sockets": len(results),
+            "online": total_online,
+            "offline": total_offline,
+            "error": total_error,
+            "with_warnings": total_warnings,
+            "safe_to_test": len(results) - total_warnings
+        }
+        
+        printers_logger.info(f"✅ Alle-Steckdosen-Status erfolgreich abgerufen: {len(results)} Steckdosen")
+        
+        return jsonify({
+            "success": True,
+            "sockets": results,
+            "summary": summary,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+    except Exception as e:
+        printers_logger.error(f"❌ Fehler bei Alle-Steckdosen-Test-Status: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Allgemeiner Fehler: {str(e)}"
+        }), 500
+
+
+# =============================================================================
+# DRAG & DROP API - JOB-REIHENFOLGE-MANAGEMENT
+# =============================================================================
+
+@printers_blueprint.route("/<int:printer_id>/jobs/order", methods=["GET"])
+@login_required
+@measure_execution_time(logger=printers_logger, task_name="API-Job-Reihenfolge-Abfrage")
+def get_job_order(printer_id):
+    """
+    Holt die aktuelle Job-Reihenfolge für einen Drucker.
+    
+    Args:
+        printer_id: ID des Druckers
+    
+    Returns:
+        JSON mit Jobs in der korrekten Reihenfolge
+    """
+    printers_logger.info(f"📋 Job-Reihenfolge-Abfrage für Drucker {printer_id} von Benutzer {current_user.name}")
+    
+    try:
+        # Drucker existiert prüfen
+        db_session = get_db_session()
+        printer = db_session.query(Printer).filter(Printer.id == printer_id).first()
+        
+        if not printer:
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": f"Drucker mit ID {printer_id} nicht gefunden"
+            }), 404
+        
+        db_session.close()
+        
+        # Job-Reihenfolge und Details holen
+        ordered_jobs = drag_drop_manager.get_ordered_jobs_for_printer(printer_id)
+        job_order_ids = drag_drop_manager.get_job_order(printer_id)
+        
+        # Job-Details für Response aufbereiten
+        jobs_data = []
+        for job in ordered_jobs:
+            jobs_data.append({
+                "id": job.id,
+                "name": job.name,
+                "description": job.description,
+                "user_name": job.user.name if job.user else "Unbekannt",
+                "user_id": job.user_id,
+                "duration_minutes": job.duration_minutes,
+                "created_at": job.created_at.isoformat() if job.created_at else None,
+                "start_at": job.start_at.isoformat() if job.start_at else None,
+                "status": job.status,
+                "file_path": job.file_path
+            })
+        
+        printers_logger.info(f"✅ Job-Reihenfolge erfolgreich abgerufen: {len(jobs_data)} Jobs für Drucker {printer.name}")
+        
+        return jsonify({
+            "success": True,
+            "printer": {
+                "id": printer.id,
+                "name": printer.name,
+                "model": printer.model,
+                "location": printer.location
+            },
+            "jobs": jobs_data,
+            "job_order": job_order_ids,
+            "total_jobs": len(jobs_data),
+            "total_duration_minutes": sum(job.duration_minutes for job in ordered_jobs),
+            "timestamp": datetime.now().isoformat()
+        })
+        
+    except Exception as e:
+        printers_logger.error(f"❌ Fehler bei Job-Reihenfolge-Abfrage für Drucker {printer_id}: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Fehler beim Laden der Job-Reihenfolge: {str(e)}"
+        }), 500
+
+@printers_blueprint.route("/<int:printer_id>/jobs/order", methods=["POST"])
+@login_required
+@require_permission(Permission.APPROVE_JOBS)  # Nur Benutzer mit Job-Genehmigungsrechten können Reihenfolge ändern
+@measure_execution_time(logger=printers_logger, task_name="API-Job-Reihenfolge-Update")
+def update_job_order(printer_id):
+    """
+    Aktualisiert die Job-Reihenfolge für einen Drucker per Drag & Drop.
+    
+    Args:
+        printer_id: ID des Druckers
+    
+    JSON-Parameter:
+    - job_ids: Liste der Job-IDs in der gewünschten Reihenfolge
+    
+    Returns:
+        JSON mit Bestätigung der Aktualisierung
+    """
+    printers_logger.info(f"🔄 Job-Reihenfolge-Update für Drucker {printer_id} von Benutzer {current_user.name}")
+    
+    # Parameter validieren
+    data = request.get_json()
+    if not data or "job_ids" not in data:
+        return jsonify({
+            "success": False,
+            "error": "Parameter 'job_ids' fehlt"
+        }), 400
+    
+    job_ids = data["job_ids"]
+    if not isinstance(job_ids, list):
+        return jsonify({
+            "success": False,
+            "error": "Parameter 'job_ids' muss eine Liste sein"
+        }), 400
+    
+    if not all(isinstance(job_id, int) for job_id in job_ids):
+        return jsonify({
+            "success": False,
+            "error": "Alle Job-IDs müssen Zahlen sein"
+        }), 400
+    
+    try:
+        # Drucker existiert prüfen
+        db_session = get_db_session()
+        printer = db_session.query(Printer).filter(Printer.id == printer_id).first()
+        
+        if not printer:
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": f"Drucker mit ID {printer_id} nicht gefunden"
+            }), 404
+        
+        # Validierung: Alle Jobs gehören zum Drucker und sind editierbar
+        valid_jobs = db_session.query(Job).filter(
+            Job.id.in_(job_ids),
+            Job.printer_id == printer_id,
+            Job.status.in_(['scheduled', 'paused'])
+        ).all()
+        
+        db_session.close()
+        
+        if len(valid_jobs) != len(job_ids):
+            invalid_ids = set(job_ids) - {job.id for job in valid_jobs}
+            return jsonify({
+                "success": False,
+                "error": f"Ungültige oder nicht editierbare Job-IDs: {list(invalid_ids)}"
+            }), 400
+        
+        # Berechtigung prüfen: Benutzer kann nur eigene Jobs oder als Admin alle verschieben
+        if not current_user.is_admin:
+            user_job_ids = {job.id for job in valid_jobs if job.user_id == current_user.id}
+            if user_job_ids != set(job_ids):
+                unauthorized_ids = set(job_ids) - user_job_ids
+                return jsonify({
+                    "success": False,
+                    "error": f"Keine Berechtigung für Jobs: {list(unauthorized_ids)}"
+                }), 403
+        
+        # Job-Reihenfolge aktualisieren
+        success = drag_drop_manager.update_job_order(printer_id, job_ids)
+        
+        if success:
+            # Neue Reihenfolge zur Bestätigung laden
+            updated_order = drag_drop_manager.get_job_order(printer_id)
+            
+            printers_logger.info(f"✅ Job-Reihenfolge erfolgreich aktualisiert für Drucker {printer.name}")
+            printers_logger.info(f"   Neue Reihenfolge: {job_ids}")
+            printers_logger.info(f"   Benutzer: {current_user.name} (ID: {current_user.id})")
+            
+            return jsonify({
+                "success": True,
+                "message": "Job-Reihenfolge erfolgreich aktualisiert",
+                "printer": {
+                    "id": printer.id,
+                    "name": printer.name
+                },
+                "old_order": job_ids,  # Eingabe des Benutzers
+                "new_order": updated_order,  # Bestätigung aus Datenbank
+                "total_jobs": len(job_ids),
+                "updated_by": {
+                    "id": current_user.id,
+                    "name": current_user.name
+                },
+                "timestamp": datetime.now().isoformat()
+            })
+        else:
+            return jsonify({
+                "success": False,
+                "error": "Fehler beim Speichern der Job-Reihenfolge"
+            }), 500
+            
+    except Exception as e:
+        printers_logger.error(f"❌ Fehler bei Job-Reihenfolge-Update für Drucker {printer_id}: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Unerwarteter Fehler: {str(e)}"
+        }), 500
+
+@printers_blueprint.route("/<int:printer_id>/jobs/summary", methods=["GET"])
+@login_required
+@measure_execution_time(logger=printers_logger, task_name="API-Drucker-Job-Zusammenfassung")
+def get_printer_job_summary(printer_id):
+    """
+    Erstellt eine detaillierte Zusammenfassung der Jobs für einen Drucker.
+    
+    Args:
+        printer_id: ID des Druckers
+    
+    Returns:
+        JSON mit Zusammenfassung, Statistiken und Zeitschätzungen
+    """
+    printers_logger.info(f"📊 Drucker-Job-Zusammenfassung für Drucker {printer_id} von Benutzer {current_user.name}")
+    
+    try:
+        # Drucker existiert prüfen
+        db_session = get_db_session()
+        printer = db_session.query(Printer).filter(Printer.id == printer_id).first()
+        
+        if not printer:
+            db_session.close()
+            return jsonify({
+                "success": False,
+                "error": f"Drucker mit ID {printer_id} nicht gefunden"
+            }), 404
+        
+        db_session.close()
+        
+        # Zusammenfassung über Drag-Drop-Manager erstellen
+        summary = drag_drop_manager.get_printer_summary(printer_id)
+        
+        printers_logger.info(f"✅ Drucker-Job-Zusammenfassung erfolgreich erstellt für {printer.name}")
+        
+        return jsonify({
+            "success": True,
+            "printer": {
+                "id": printer.id,
+                "name": printer.name,
+                "model": printer.model,
+                "location": printer.location,
+                "status": printer.status
+            },
+            "summary": summary,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+    except Exception as e:
+        printers_logger.error(f"❌ Fehler bei Drucker-Job-Zusammenfassung für Drucker {printer_id}: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Fehler beim Erstellen der Zusammenfassung: {str(e)}"
+        }), 500
+
+@printers_blueprint.route("/jobs/cleanup-orders", methods=["POST"])
+@login_required
+@require_permission(Permission.ADMIN)
+@measure_execution_time(logger=printers_logger, task_name="API-Job-Reihenfolgen-Bereinigung")
+def cleanup_job_orders():
+    """
+    Bereinigt ungültige Job-Reihenfolgen (nur für Administratoren).
+    Entfernt Einträge für abgeschlossene oder gelöschte Jobs.
+    
+    Returns:
+        JSON mit Bereinigungsergebnis
+    """
+    printers_logger.info(f"🧹 Job-Reihenfolgen-Bereinigung von Admin {current_user.name}")
+    
+    try:
+        # Bereinigung durchführen
+        drag_drop_manager.cleanup_invalid_orders()
+        
+        printers_logger.info(f"✅ Job-Reihenfolgen-Bereinigung erfolgreich abgeschlossen")
+        
+        return jsonify({
+            "success": True,
+            "message": "Job-Reihenfolgen erfolgreich bereinigt",
+            "admin": {
+                "id": current_user.id,
+                "name": current_user.name
+            },
+            "timestamp": datetime.now().isoformat()
+        })
+        
+    except Exception as e:
+        printers_logger.error(f"❌ Fehler bei Job-Reihenfolgen-Bereinigung: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Fehler bei der Bereinigung: {str(e)}"
+        }), 500
+
+@printers_blueprint.route("/drag-drop/config", methods=["GET"])
+@login_required
+def get_drag_drop_config():
+    """
+    Liefert die Konfiguration für das Drag & Drop System.
+    
+    Returns:
+        JSON mit Drag & Drop Konfiguration und JavaScript/CSS
+    """
+    printers_logger.info(f"⚙️ Drag-Drop-Konfiguration abgerufen von Benutzer {current_user.name}")
+    
+    try:
+        from utils.drag_drop_system import get_drag_drop_javascript, get_drag_drop_css
+        
+        # Benutzerberechtigungen prüfen
+        can_reorder_jobs = check_permission(current_user, Permission.APPROVE_JOBS)
+        can_upload_files = check_permission(current_user, Permission.CREATE_JOB)
+        
+        config = {
+            "permissions": {
+                "can_reorder_jobs": can_reorder_jobs,
+                "can_upload_files": can_upload_files,
+                "is_admin": current_user.is_admin
+            },
+            "settings": {
+                "max_file_size": 50 * 1024 * 1024,  # 50MB
+                "accepted_file_types": ["gcode", "stl", "3mf", "obj"],
+                "auto_upload": False,
+                "show_preview": True,
+                "enable_progress_tracking": True
+            },
+            "endpoints": {
+                "get_job_order": f"/api/printers/{{printer_id}}/jobs/order",
+                "update_job_order": f"/api/printers/{{printer_id}}/jobs/order",
+                "get_summary": f"/api/printers/{{printer_id}}/jobs/summary"
+            },
+            "javascript": get_drag_drop_javascript(),
+            "css": get_drag_drop_css()
+        }
+        
+        return jsonify({
+            "success": True,
+            "config": config,
+            "user": {
+                "id": current_user.id,
+                "name": current_user.name,
+                "role": current_user.role
+            },
+            "timestamp": datetime.now().isoformat()
+        })
+        
+    except Exception as e:
+        printers_logger.error(f"❌ Fehler bei Drag-Drop-Konfiguration: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Fehler beim Laden der Konfiguration: {str(e)}"
+        }), 500
+
+# =============================================================================
+# ENDE DRAG & DROP API
+# ============================================================================= 

blueprints/user.py

@@ -0,0 +1,359 @@
+"""
+Benutzer-Blueprint für das 3D-Druck-Management-System
+
+Dieses Modul enthält alle Benutzer-spezifischen Routen und Funktionen,
+einschließlich Profilverwaltung, Einstellungen und Passwort-Änderung.
+"""
+
+import json
+from datetime import datetime
+from flask import Blueprint, render_template, request, jsonify, redirect, url_for, flash, make_response
+from flask_login import login_required, current_user
+from werkzeug.security import check_password_hash
+from models import User, get_db_session
+from utils.logging_config import get_logger
+
+# Blueprint erstellen
+user_blueprint = Blueprint('user', __name__, url_prefix='/user')
+
+# Logger initialisieren
+user_logger = get_logger("user")
+
+@user_blueprint.route("/profile", methods=["GET"])
+@login_required
+def profile():
+    """Benutzerprofil anzeigen"""
+    return render_template('user/profile.html', user=current_user)
+
+@user_blueprint.route("/settings", methods=["GET"])
+@login_required
+def settings():
+    """Benutzereinstellungen anzeigen"""
+    return render_template('user/settings.html', user=current_user)
+
+@user_blueprint.route("/update-profile", methods=["POST"])
+@login_required
+def update_profile():
+    """Benutzerprofil aktualisieren (Form-basiert)"""
+    try:
+        db_session = get_db_session()
+        user = db_session.query(User).filter(User.id == current_user.id).first()
+        
+        if not user:
+            db_session.close()
+            flash("Benutzer nicht gefunden", "error")
+            return redirect(url_for('user.profile'))
+        
+        # Aktualisierbare Felder aus dem Formular
+        user.name = request.form.get('name', user.name)
+        user.email = request.form.get('email', user.email)
+        user.department = request.form.get('department', user.department)
+        user.position = request.form.get('position', user.position)
+        user.phone = request.form.get('phone', user.phone)
+        user.bio = request.form.get('bio', user.bio)
+        
+        user.updated_at = datetime.now()
+        db_session.commit()
+        
+        user_logger.info(f"Profil aktualisiert für Benutzer {user.username}")
+        flash("Profil erfolgreich aktualisiert", "success")
+        
+        db_session.close()
+        return redirect(url_for('user.profile'))
+        
+    except Exception as e:
+        user_logger.error(f"Fehler beim Aktualisieren des Profils: {str(e)}")
+        flash("Fehler beim Aktualisieren des Profils", "error")
+        return redirect(url_for('user.profile'))
+
+@user_blueprint.route("/api/update-settings", methods=["POST"])
+@login_required
+def api_update_settings():
+    """API-Endpunkt für Einstellungen-Updates"""
+    try:
+        data = request.get_json()
+        
+        db_session = get_db_session()
+        user = db_session.query(User).filter(User.id == current_user.id).first()
+        
+        if not user:
+            db_session.close()
+            return jsonify({"error": "Benutzer nicht gefunden"}), 404
+        
+        # Einstellungen JSON aktualisieren
+        current_settings = user.settings or {}
+        if isinstance(current_settings, str):
+            try:
+                current_settings = json.loads(current_settings)
+            except json.JSONDecodeError:
+                current_settings = {}
+        
+        # Neue Einstellungen hinzufügen/aktualisieren
+        for key, value in data.items():
+            current_settings[key] = value
+        
+        user.settings = json.dumps(current_settings)
+        user.updated_at = datetime.now()
+        db_session.commit()
+        
+        user_logger.info(f"Einstellungen aktualisiert für Benutzer {user.username}")
+        
+        db_session.close()
+        return jsonify({
+            "success": True,
+            "message": "Einstellungen erfolgreich aktualisiert"
+        })
+        
+    except Exception as e:
+        user_logger.error(f"Fehler beim Aktualisieren der Einstellungen: {str(e)}")
+        return jsonify({"error": "Fehler beim Aktualisieren der Einstellungen"}), 500
+
+@user_blueprint.route("/update-settings", methods=["POST"])
+@login_required
+def update_settings():
+    """Benutzereinstellungen aktualisieren (Form-basiert)"""
+    try:
+        db_session = get_db_session()
+        user = db_session.query(User).filter(User.id == current_user.id).first()
+        
+        if not user:
+            db_session.close()
+            flash("Benutzer nicht gefunden", "error")
+            return redirect(url_for('user.settings'))
+        
+        # Einstellungen aus dem Formular sammeln
+        settings = {}
+        
+        # Theme-Einstellungen
+        settings['theme'] = request.form.get('theme', 'light')
+        settings['language'] = request.form.get('language', 'de')
+        
+        # Benachrichtigungseinstellungen
+        settings['email_notifications'] = request.form.get('email_notifications') == 'on'
+        settings['push_notifications'] = request.form.get('push_notifications') == 'on'
+        settings['job_completion_notifications'] = request.form.get('job_completion_notifications') == 'on'
+        settings['printer_error_notifications'] = request.form.get('printer_error_notifications') == 'on'
+        
+        # Dashboard-Einstellungen
+        settings['default_dashboard_view'] = request.form.get('default_dashboard_view', 'overview')
+        settings['auto_refresh_interval'] = int(request.form.get('auto_refresh_interval', 30))
+        
+        # Privacy-Einstellungen
+        settings['show_profile_publicly'] = request.form.get('show_profile_publicly') == 'on'
+        settings['allow_job_sharing'] = request.form.get('allow_job_sharing') == 'on'
+        
+        user.settings = json.dumps(settings)
+        user.updated_at = datetime.now()
+        db_session.commit()
+        
+        user_logger.info(f"Einstellungen aktualisiert für Benutzer {user.username}")
+        flash("Einstellungen erfolgreich aktualisiert", "success")
+        
+        db_session.close()
+        return redirect(url_for('user.settings'))
+        
+    except Exception as e:
+        user_logger.error(f"Fehler beim Aktualisieren der Einstellungen: {str(e)}")
+        flash("Fehler beim Aktualisieren der Einstellungen", "error")
+        return redirect(url_for('user.settings'))
+
+@user_blueprint.route("/change-password", methods=["POST"])
+@login_required
+def change_password():
+    """Passwort ändern"""
+    try:
+        # Daten aus Form oder JSON extrahieren
+        if request.is_json:
+            data = request.get_json()
+            current_password = data.get('current_password')
+            new_password = data.get('new_password')
+            confirm_password = data.get('confirm_password')
+        else:
+            current_password = request.form.get('current_password')
+            new_password = request.form.get('new_password')
+            confirm_password = request.form.get('confirm_password')
+        
+        # Validierung
+        if not all([current_password, new_password, confirm_password]):
+            error_msg = "Alle Passwort-Felder sind erforderlich"
+            if request.is_json:
+                return jsonify({"error": error_msg}), 400
+            flash(error_msg, "error")
+            return redirect(url_for('user.settings'))
+        
+        if new_password != confirm_password:
+            error_msg = "Neue Passwörter stimmen nicht überein"
+            if request.is_json:
+                return jsonify({"error": error_msg}), 400
+            flash(error_msg, "error")
+            return redirect(url_for('user.settings'))
+        
+        if len(new_password) < 8:
+            error_msg = "Das neue Passwort muss mindestens 8 Zeichen lang sein"
+            if request.is_json:
+                return jsonify({"error": error_msg}), 400
+            flash(error_msg, "error")
+            return redirect(url_for('user.settings'))
+        
+        db_session = get_db_session()
+        user = db_session.query(User).filter(User.id == current_user.id).first()
+        
+        if not user:
+            db_session.close()
+            error_msg = "Benutzer nicht gefunden"
+            if request.is_json:
+                return jsonify({"error": error_msg}), 404
+            flash(error_msg, "error")
+            return redirect(url_for('user.settings'))
+        
+        # Aktuelles Passwort überprüfen
+        if not user.check_password(current_password):
+            db_session.close()
+            error_msg = "Aktuelles Passwort ist falsch"
+            if request.is_json:
+                return jsonify({"error": error_msg}), 401
+            flash(error_msg, "error")
+            return redirect(url_for('user.settings'))
+        
+        # Neues Passwort setzen
+        user.set_password(new_password)
+        user.updated_at = datetime.now()
+        db_session.commit()
+        
+        user_logger.info(f"Passwort geändert für Benutzer {user.username}")
+        
+        db_session.close()
+        
+        success_msg = "Passwort erfolgreich geändert"
+        if request.is_json:
+            return jsonify({"success": True, "message": success_msg})
+        flash(success_msg, "success")
+        return redirect(url_for('user.settings'))
+        
+    except Exception as e:
+        user_logger.error(f"Fehler beim Ändern des Passworts: {str(e)}")
+        error_msg = "Fehler beim Ändern des Passworts"
+        if request.is_json:
+            return jsonify({"error": error_msg}), 500
+        flash(error_msg, "error")
+        return redirect(url_for('user.settings'))
+
+@user_blueprint.route("/export", methods=["GET"])
+@login_required
+def export_data():
+    """Benutzerdaten exportieren (DSGVO-Compliance)"""
+    try:
+        db_session = get_db_session()
+        user = db_session.query(User).filter(User.id == current_user.id).first()
+        
+        if not user:
+            db_session.close()
+            flash("Benutzer nicht gefunden", "error")
+            return redirect(url_for('user.settings'))
+        
+        # Benutzerdaten sammeln
+        user_data = {
+            "personal_information": {
+                "id": user.id,
+                "username": user.username,
+                "email": user.email,
+                "name": user.name,
+                "department": user.department,
+                "position": user.position,
+                "phone": user.phone,
+                "bio": user.bio,
+                "role": user.role,
+                "created_at": user.created_at.isoformat() if user.created_at else None,
+                "last_login": user.last_login.isoformat() if user.last_login else None,
+                "updated_at": user.updated_at.isoformat() if user.updated_at else None,
+                "last_activity": user.last_activity.isoformat() if user.last_activity else None
+            },
+            "settings": json.loads(user.settings) if user.settings else {},
+            "jobs": [],
+            "export_date": datetime.now().isoformat(),
+            "export_note": "Dies ist ein Export Ihrer persönlichen Daten gemäß DSGVO Art. 20"
+        }
+        
+        # Benutzer-Jobs sammeln (falls verfügbar)
+        try:
+            from models import Job
+            user_jobs = db_session.query(Job).filter(Job.user_id == user.id).all()
+            for job in user_jobs:
+                user_data["jobs"].append({
+                    "id": job.id,
+                    "filename": job.filename,
+                    "status": job.status,
+                    "created_at": job.created_at.isoformat() if job.created_at else None,
+                    "estimated_duration": job.estimated_duration,
+                    "material_used": job.material_used,
+                    "notes": job.notes
+                })
+        except Exception as job_error:
+            user_logger.warning(f"Fehler beim Sammeln der Job-Daten: {str(job_error)}")
+        
+        db_session.close()
+        
+        # JSON-Response erstellen
+        response = make_response(jsonify(user_data))
+        response.headers['Content-Disposition'] = f'attachment; filename=user_data_{user.username}_{datetime.now().strftime("%Y%m%d_%H%M%S")}.json'
+        response.headers['Content-Type'] = 'application/json'
+        
+        user_logger.info(f"Datenexport erstellt für Benutzer {user.username}")
+        
+        return response
+        
+    except Exception as e:
+        user_logger.error(f"Fehler beim Datenexport: {str(e)}")
+        flash("Fehler beim Erstellen des Datenexports", "error")
+        return redirect(url_for('user.settings'))
+
+@user_blueprint.route("/profile", methods=["PUT"])
+@login_required
+def update_profile_api():
+    """API-Endpunkt für Profil-Updates"""
+    try:
+        data = request.get_json()
+        
+        db_session = get_db_session()
+        user = db_session.query(User).filter(User.id == current_user.id).first()
+        
+        if not user:
+            db_session.close()
+            return jsonify({"error": "Benutzer nicht gefunden"}), 404
+        
+        # Aktualisierbare Felder (ohne sensitive Daten)
+        updatable_fields = ['name', 'email', 'department', 'position', 'phone', 'bio']
+        
+        for field in updatable_fields:
+            if field in data:
+                setattr(user, field, data[field])
+        
+        user.updated_at = datetime.now()
+        db_session.commit()
+        
+        user_logger.info(f"Profil über API aktualisiert für Benutzer {user.username}")
+        
+        # Aktuelle Benutzerdaten zurückgeben
+        user_data = {
+            "id": user.id,
+            "username": user.username,
+            "email": user.email,
+            "name": user.name,
+            "department": user.department,
+            "position": user.position,
+            "phone": user.phone,
+            "bio": user.bio,
+            "role": user.role,
+            "updated_at": user.updated_at.isoformat()
+        }
+        
+        db_session.close()
+        return jsonify({
+            "success": True,
+            "message": "Profil erfolgreich aktualisiert",
+            "user": user_data
+        })
+        
+    except Exception as e:
+        user_logger.error(f"Fehler beim API-Profil-Update: {str(e)}")
+        return jsonify({"error": "Fehler beim Aktualisieren des Profils"}), 500 

blueprints/users.py

@@ -0,0 +1,168 @@
+from flask import Blueprint, render_template, request, jsonify, redirect, url_for, abort
+from flask_login import current_user, login_required
+from sqlalchemy.exc import SQLAlchemyError
+from functools import wraps
+
+from models import User, UserPermission, get_cached_session
+from utils.logging_config import get_logger
+
+users_blueprint = Blueprint('users', __name__)
+logger = get_logger("users")
+
+def users_admin_required(f):
+    """Decorator zur Prüfung der Admin-Berechtigung für Users Blueprint."""
+    @wraps(f)
+    @login_required
+    def users_decorated_function(*args, **kwargs):
+        if not current_user.is_admin:
+            abort(403, "Nur Administratoren haben Zugriff auf diese Seite")
+        return f(*args, **kwargs)
+    return users_decorated_function
+
+@users_blueprint.route('/admin/users/<int:user_id>/permissions', methods=['GET'])
+@users_admin_required
+def admin_user_permissions(user_id):
+    """Benutzerberechtigungen anzeigen und bearbeiten."""
+    with get_cached_session() as db_session:
+        user = db_session.query(User).filter_by(id=user_id).first()
+        if not user:
+            abort(404, "Benutzer nicht gefunden")
+        
+        # Berechtigungen laden oder erstellen, falls nicht vorhanden
+        permission = db_session.query(UserPermission).filter_by(user_id=user_id).first()
+        if not permission:
+            permission = UserPermission(user_id=user_id)
+            db_session.add(permission)
+            db_session.commit()
+    
+    return render_template('admin_user_permissions.html', user=user, permission=permission)
+
+@users_blueprint.route('/api/users/<int:user_id>/permissions', methods=['GET'])
+@login_required
+def api_get_user_permissions(user_id):
+    """Benutzerberechtigungen als JSON zurückgeben."""
+    # Nur Admins oder der Benutzer selbst darf seine Berechtigungen sehen
+    if not current_user.is_admin and current_user.id != user_id:
+        return jsonify({"error": "Keine Berechtigung"}), 403
+    
+    try:
+        with get_cached_session() as db_session:
+            permission = db_session.query(UserPermission).filter_by(user_id=user_id).first()
+            
+            if not permission:
+                # Falls keine Berechtigungen existieren, Standard-Werte zurückgeben
+                return jsonify({
+                    "user_id": user_id,
+                    "can_start_jobs": False,
+                    "needs_approval": True,
+                    "can_approve_jobs": False
+                })
+            
+            return jsonify(permission.to_dict())
+            
+    except Exception as e:
+        logger.error(f"Fehler beim Abrufen der Benutzerberechtigungen: {str(e)}")
+        return jsonify({"error": "Fehler beim Verarbeiten der Anfrage"}), 500
+
+@users_blueprint.route('/api/users/<int:user_id>/permissions', methods=['PUT'])
+@users_admin_required
+def api_update_user_permissions(user_id):
+    """Benutzerberechtigungen aktualisieren."""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "Keine Daten erhalten"}), 400
+        
+        with get_cached_session() as db_session:
+            # Benutzer prüfen
+            user = db_session.query(User).filter_by(id=user_id).first()
+            if not user:
+                return jsonify({"error": "Benutzer nicht gefunden"}), 404
+            
+            # Berechtigungen laden oder erstellen
+            permission = db_session.query(UserPermission).filter_by(user_id=user_id).first()
+            if not permission:
+                permission = UserPermission(user_id=user_id)
+                db_session.add(permission)
+            
+            # Berechtigungen aktualisieren
+            if 'can_start_jobs' in data:
+                permission.can_start_jobs = bool(data['can_start_jobs'])
+            
+            if 'needs_approval' in data:
+                permission.needs_approval = bool(data['needs_approval'])
+            
+            if 'can_approve_jobs' in data:
+                permission.can_approve_jobs = bool(data['can_approve_jobs'])
+            
+            db_session.commit()
+            
+            logger.info(f"Berechtigungen für Benutzer {user_id} aktualisiert durch Admin {current_user.id}")
+            
+            return jsonify({
+                "success": True,
+                "permissions": permission.to_dict()
+            })
+            
+    except SQLAlchemyError as e:
+        logger.error(f"Datenbankfehler beim Aktualisieren der Benutzerberechtigungen: {str(e)}")
+        return jsonify({"error": "Datenbankfehler beim Verarbeiten der Anfrage"}), 500
+    except Exception as e:
+        logger.error(f"Fehler beim Aktualisieren der Benutzerberechtigungen: {str(e)}")
+        return jsonify({"error": "Fehler beim Verarbeiten der Anfrage"}), 500
+
+@users_blueprint.route('/admin/users/<int:user_id>/permissions/update', methods=['POST'])
+@users_admin_required
+def admin_update_user_permissions(user_id):
+    """Benutzerberechtigungen über Formular aktualisieren."""
+    try:
+        # Formularfelder auslesen
+        can_start_jobs = request.form.get('can_start_jobs') == 'on'
+        needs_approval = request.form.get('needs_approval') == 'on'
+        can_approve_jobs = request.form.get('can_approve_jobs') == 'on'
+        
+        with get_cached_session() as db_session:
+            # Benutzer prüfen
+            user = db_session.query(User).filter_by(id=user_id).first()
+            if not user:
+                abort(404, "Benutzer nicht gefunden")
+            
+            # Berechtigungen laden oder erstellen
+            permission = db_session.query(UserPermission).filter_by(user_id=user_id).first()
+            if not permission:
+                permission = UserPermission(user_id=user_id)
+                db_session.add(permission)
+            
+            # Berechtigungen aktualisieren
+            permission.can_start_jobs = can_start_jobs
+            permission.needs_approval = needs_approval
+            permission.can_approve_jobs = can_approve_jobs
+            
+            db_session.commit()
+            
+            logger.info(f"Berechtigungen für Benutzer {user_id} aktualisiert durch Admin {current_user.id} (Formular)")
+            
+            return redirect(url_for('users.admin_user_permissions', user_id=user_id))
+            
+    except Exception as e:
+        logger.error(f"Fehler beim Aktualisieren der Benutzerberechtigungen: {str(e)}")
+        abort(500, "Fehler beim Verarbeiten der Anfrage")
+
+# Erweiterung des bestehenden Benutzer-Bearbeitungsformulars
+@users_blueprint.route('/admin/users/<int:user_id>/edit/permissions', methods=['GET'])
+@users_admin_required
+def admin_edit_user_permissions_section(user_id):
+    """Rendert nur den Berechtigungsteil für das Benutzer-Edit-Formular."""
+    with get_cached_session() as db_session:
+        user = db_session.query(User).filter_by(id=user_id).first()
+        if not user:
+            abort(404, "Benutzer nicht gefunden")
+        
+        # Berechtigungen laden oder erstellen, falls nicht vorhanden
+        permission = db_session.query(UserPermission).filter_by(user_id=user_id).first()
+        if not permission:
+            permission = UserPermission(user_id=user_id)
+            db_session.add(permission)
+            db_session.commit()
+    
+    return render_template('_user_permissions_form.html', user=user, permission=permission) 

certs/mercedes/Corp-Prj-Root-CA.cer

@@ -0,0 +1,36 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----

certs/mercedes/Corp-Root-CA-G2.cer

@@ -0,0 +1,35 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----

certs/myp.crt

@@ -0,0 +1,39 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----

certs/myp.key

@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----

config/__init__.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""
+Configuration Package for MYP Platform
+======================================
+
+This package contains all configuration modules for the Mercedes-Benz 3D Printing Platform.
+
+Modules:
+    - security: Security configuration and middleware
+    - database: Database configuration and settings
+    - logging: Logging configuration
+    - app_config: Main application configuration
+"""
+
+__version__ = "2.0.0"
+__author__ = "MYP Development Team"
+
+# Import main configuration modules
+try:
+    from .security import SecurityConfig, get_security_headers
+    from .app_config import Config, DevelopmentConfig, ProductionConfig, TestingConfig
+except ImportError as e:
+    print(f"Warning: Could not import configuration modules: {e}")
+    # Fallback configurations
+    SecurityConfig = None
+    get_security_headers = None
+    Config = None
+
+# Export main configuration classes
+__all__ = [
+    'SecurityConfig',
+    'get_security_headers',
+    'Config',
+    'DevelopmentConfig', 
+    'ProductionConfig',
+    'TestingConfig'
+]
+
+def get_config(config_name='development'):
+    """
+    Get configuration object based on environment name.
+    
+    Args:
+        config_name (str): Configuration environment name
+        
+    Returns:
+        Config: Configuration object
+    """
+    configs = {
+        'development': DevelopmentConfig,
+        'production': ProductionConfig,
+        'testing': TestingConfig
+    }
+    
+    return configs.get(config_name, DevelopmentConfig)
+
+def validate_config(config_obj):
+    """
+    Validate configuration object.
+    
+    Args:
+        config_obj: Configuration object to validate
+        
+    Returns:
+        bool: True if valid, False otherwise
+    """
+    required_attrs = ['SECRET_KEY', 'DATABASE_URL']
+    
+    for attr in required_attrs:
+        if not hasattr(config_obj, attr):
+            print(f"Missing required configuration: {attr}")
+            return False
+    
+    return True 

config/app_config.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+"""
+Application Configuration Module for MYP Platform
+================================================
+
+Flask configuration classes for different environments.
+"""
+
+import os
+from datetime import timedelta
+
+# Base configuration directory
+BASE_DIR = os.path.abspath(os.path.dirname(__file__))
+PROJECT_ROOT = os.path.abspath(os.path.join(BASE_DIR, '..', '..'))
+
+class Config:
+    """Base configuration class with common settings."""
+    
+    # Secret key for Flask sessions and CSRF protection
+    SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-secret-key-change-in-production-744563017196A'
+    
+    # Session configuration
+    PERMANENT_SESSION_LIFETIME = timedelta(hours=24)
+    SESSION_COOKIE_SECURE = False  # Set to True in production with HTTPS
+    SESSION_COOKIE_HTTPONLY = True
+    SESSION_COOKIE_SAMESITE = 'Lax'
+    
+    # Database configuration
+    DATABASE_URL = os.environ.get('DATABASE_URL') or f'sqlite:///{os.path.join(PROJECT_ROOT, "database", "myp.db")}'
+    SQLALCHEMY_DATABASE_URI = DATABASE_URL
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+    SQLALCHEMY_ENGINE_OPTIONS = {
+        'pool_pre_ping': True,
+        'pool_recycle': 300,
+    }
+    
+    # Upload configuration
+    UPLOAD_FOLDER = os.path.join(PROJECT_ROOT, 'uploads')
+    MAX_CONTENT_LENGTH = 500 * 1024 * 1024  # 500MB max file size
+    ALLOWED_EXTENSIONS = {'gcode', 'stl', 'obj', '3mf', 'amf'}
+    
+    # Security configuration
+    WTF_CSRF_ENABLED = True
+    WTF_CSRF_TIME_LIMIT = 3600  # 1 hour
+    
+    # Mail configuration (optional)
+    MAIL_SERVER = os.environ.get('MAIL_SERVER')
+    MAIL_PORT = int(os.environ.get('MAIL_PORT') or 587)
+    MAIL_USE_TLS = os.environ.get('MAIL_USE_TLS', 'true').lower() in ['true', 'on', '1']
+    MAIL_USERNAME = os.environ.get('MAIL_USERNAME')
+    MAIL_PASSWORD = os.environ.get('MAIL_PASSWORD')
+    
+    # Logging configuration
+    LOG_LEVEL = os.environ.get('LOG_LEVEL', 'INFO')
+    LOG_FILE_MAX_BYTES = 10 * 1024 * 1024  # 10MB
+    LOG_BACKUP_COUNT = 5
+    
+    # Application-specific settings
+    SCHEDULER_ENABLED = os.environ.get('SCHEDULER_ENABLED', 'true').lower() in ['true', 'on', '1']
+    SCHEDULER_INTERVAL = int(os.environ.get('SCHEDULER_INTERVAL', '60'))  # seconds
+    
+    # SSL/HTTPS configuration
+    SSL_ENABLED = os.environ.get('SSL_ENABLED', 'false').lower() in ['true', 'on', '1']
+    SSL_CERT_PATH = os.environ.get('SSL_CERT_PATH')
+    SSL_KEY_PATH = os.environ.get('SSL_KEY_PATH')
+    
+    # Network configuration
+    DEFAULT_PORT = int(os.environ.get('PORT', '5000'))
+    DEFAULT_HOST = os.environ.get('HOST', '0.0.0.0')
+    
+    @staticmethod
+    def init_app(app):
+        """Initialize application with this configuration."""
+        pass
+
+
+class DevelopmentConfig(Config):
+    """Development environment configuration."""
+    
+    DEBUG = True
+    TESTING = False
+    
+    # More verbose logging in development
+    LOG_LEVEL = 'DEBUG'
+    
+    # Disable some security features for easier development
+    SESSION_COOKIE_SECURE = False
+    WTF_CSRF_ENABLED = False  # Disable CSRF for easier API testing
+    
+    @staticmethod
+    def init_app(app):
+        Config.init_app(app)
+        
+        # Development-specific initialization
+        import logging
+        logging.basicConfig(level=logging.DEBUG)
+
+
+class TestingConfig(Config):
+    """Testing environment configuration."""
+    
+    TESTING = True
+    DEBUG = True
+    
+    # Use in-memory database for testing
+    DATABASE_URL = 'sqlite:///:memory:'
+    SQLALCHEMY_DATABASE_URI = DATABASE_URL
+    
+    # Disable CSRF for testing
+    WTF_CSRF_ENABLED = False
+    
+    # Shorter session lifetime for testing
+    PERMANENT_SESSION_LIFETIME = timedelta(minutes=5)
+    
+    @staticmethod
+    def init_app(app):
+        Config.init_app(app)
+
+
+class ProductionConfig(Config):
+    """Production environment configuration."""
+    
+    DEBUG = False
+    TESTING = False
+    
+    # Strict security settings for production
+    SESSION_COOKIE_SECURE = True  # Requires HTTPS
+    WTF_CSRF_ENABLED = True
+    
+    # Production logging
+    LOG_LEVEL = 'WARNING'
+    
+    # SSL should be enabled in production
+    SSL_ENABLED = True
+    
+    @staticmethod
+    def init_app(app):
+        Config.init_app(app)
+        
+        # Production-specific initialization
+        import logging
+        from logging.handlers import RotatingFileHandler
+        
+        # Set up file logging for production
+        log_dir = os.path.join(os.path.dirname(app.instance_path), 'logs')
+        if not os.path.exists(log_dir):
+            os.makedirs(log_dir)
+        
+        file_handler = RotatingFileHandler(
+            os.path.join(log_dir, 'myp_platform.log'),
+            maxBytes=Config.LOG_FILE_MAX_BYTES,
+            backupCount=Config.LOG_BACKUP_COUNT
+        )
+        file_handler.setFormatter(logging.Formatter(
+            '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
+        ))
+        file_handler.setLevel(logging.WARNING)
+        app.logger.addHandler(file_handler)
+        app.logger.setLevel(logging.WARNING)
+
+
+# Configuration dictionary for easy access
+config = {
+    'development': DevelopmentConfig,
+    'testing': TestingConfig,
+    'production': ProductionConfig,
+    'default': DevelopmentConfig
+}
+
+
+def get_config_by_name(config_name):
+    """
+    Get configuration class by name.
+    
+    Args:
+        config_name (str): Name of the configuration ('development', 'testing', 'production')
+        
+    Returns:
+        Config: Configuration class
+    """
+    return config.get(config_name, config['default']) 

config/security.py

@@ -0,0 +1,81 @@
+"""
+Sicherheitskonfiguration für die MYP Platform
+"""
+
+# Sicherheits-Headers für HTTP-Responses
+SECURITY_HEADERS = {
+    'Content-Security-Policy': (
+        "default-src 'self'; "
+        "script-src 'self' 'unsafe-eval' 'unsafe-inline'; "
+        "script-src-elem 'self' 'unsafe-inline'; "
+        "style-src 'self' 'unsafe-inline'; "
+        "font-src 'self'; "
+        "img-src 'self' data:; "
+        "connect-src 'self'; "
+        "worker-src 'self' blob:; "
+        "frame-src 'none'; "
+        "object-src 'none'; "
+        "base-uri 'self'; "
+        "form-action 'self'; "
+        "frame-ancestors 'none';"
+    ),
+    'X-Content-Type-Options': 'nosniff',
+    'X-Frame-Options': 'DENY',
+    'X-XSS-Protection': '1; mode=block',
+    'Strict-Transport-Security': 'max-age=31536000; includeSubDomains',
+    'Referrer-Policy': 'strict-origin-when-cross-origin',
+    'Permissions-Policy': 'geolocation=(), microphone=(), camera=()'
+}
+
+# Rate Limiting Konfiguration
+RATE_LIMITS = {
+    'default': "200 per day, 50 per hour",
+    'login': "5 per minute",
+    'api': "100 per hour",
+    'admin': "500 per hour"
+}
+
+# Session-Sicherheit
+SESSION_CONFIG = {
+    'SESSION_COOKIE_SECURE': False,  # Für Offline-Betrieb auf False setzen
+    'SESSION_COOKIE_HTTPONLY': True,
+    'SESSION_COOKIE_SAMESITE': 'Lax',
+    'PERMANENT_SESSION_LIFETIME': 3600  # 1 Stunde
+}
+
+# CSRF-Schutz
+CSRF_CONFIG = {
+    'CSRF_ENABLED': True,
+    'CSRF_SESSION_KEY': 'csrf_token',
+    'CSRF_TIME_LIMIT': 3600
+}
+
+class SecurityConfig:
+    """Sicherheitskonfiguration für die Anwendung"""
+    
+    def __init__(self):
+        self.headers = SECURITY_HEADERS
+        self.rate_limits = RATE_LIMITS
+        self.session_config = SESSION_CONFIG
+        self.csrf_config = CSRF_CONFIG
+    
+    def get_headers(self):
+        """Gibt die Sicherheits-Headers zurück"""
+        return self.headers
+    
+    def get_rate_limits(self):
+        """Gibt die Rate-Limiting-Konfiguration zurück"""
+        return self.rate_limits
+    
+    def get_session_config(self):
+        """Gibt die Session-Konfiguration zurück"""
+        return self.session_config
+    
+    def get_csrf_config(self):
+        """Gibt die CSRF-Konfiguration zurück"""
+        return self.csrf_config
+
+
+def get_security_headers():
+    """Gibt die Sicherheits-Headers zurück"""
+    return SECURITY_HEADERS 

config/settings.py

@@ -0,0 +1,188 @@
+import os
+import json
+from datetime import timedelta
+
+def get_env_variable(name: str, default: str = None) -> str:
+    """
+    Holt eine Umgebungsvariable oder gibt den Standardwert zurück.
+    
+    Args:
+        name: Name der Umgebungsvariable
+        default: Standardwert, falls die Variable nicht gesetzt ist
+        
+    Returns:
+        str: Wert der Umgebungsvariable oder Standardwert
+    """
+    return os.environ.get(name, default)
+
+# Hardcodierte Konfiguration
+SECRET_KEY = "7445630171969DFAC92C53CEC92E67A9CB2E00B3CB2F"
+
+# Dynamische Pfade basierend auf dem aktuellen Arbeitsverzeichnis
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # backend/app
+PROJECT_ROOT = os.path.dirname(BASE_DIR)  # backend
+DATABASE_PATH = os.path.join(BASE_DIR, "database", "myp.db")
+
+# ===== SMART PLUG KONFIGURATION =====
+# TP-Link Tapo P110 Standardkonfiguration
+TAPO_USERNAME = "till.tomczak@mercedes-benz.com"
+TAPO_PASSWORD = "744563017196A"
+
+# Automatische Steckdosen-Erkennung aktivieren
+TAPO_AUTO_DISCOVERY = True
+
+# Standard-Steckdosen-IPs (diese können später in der Datenbank überschrieben werden)
+DEFAULT_TAPO_IPS = [
+    "192.168.0.103",  # Erreichbare Steckdose laut Test
+    "192.168.0.104",  # Erreichbare Steckdose laut Test
+    "192.168.0.100",
+    "192.168.0.101",
+    "192.168.0.102",
+    "192.168.0.105"
+]
+
+# Timeout-Konfiguration für Tapo-Verbindungen
+TAPO_TIMEOUT = 10  # Sekunden
+TAPO_RETRY_COUNT = 3  # Anzahl Wiederholungsversuche
+
+# Drucker-Konfiguration
+PRINTERS = {
+    "Printer 1": {"ip": "192.168.0.100"},
+    "Printer 2": {"ip": "192.168.0.101"},
+    "Printer 3": {"ip": "192.168.0.102"},
+    "Printer 4": {"ip": "192.168.0.103"},
+    "Printer 5": {"ip": "192.168.0.104"},
+    "Printer 6": {"ip": "192.168.0.106"}
+}
+
+# Logging-Konfiguration
+LOG_DIR = os.path.join(BASE_DIR, "logs")
+LOG_SUBDIRS = ["app", "scheduler", "auth", "jobs", "printers", "errors"]
+LOG_LEVEL = "INFO"
+LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+LOG_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+# Flask-Konfiguration
+FLASK_HOST = "0.0.0.0"
+FLASK_PORT = 443  # Geändert von 443 auf 8443 (nicht-privilegierter Port)
+FLASK_FALLBACK_PORT = 8080  # Geändert von 80 auf 8080 (nicht-privilegierter Port)
+FLASK_DEBUG = True
+SESSION_LIFETIME = timedelta(hours=2)  # Reduziert von 7 Tagen auf 2 Stunden für bessere Sicherheit
+
+# Upload-Konfiguration
+UPLOAD_FOLDER = os.path.join(BASE_DIR, "uploads")
+ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif', 'gcode', '3mf', 'stl'}
+MAX_CONTENT_LENGTH = 16 * 1024 * 1024  # 16MB Maximum-Dateigröße
+MAX_FILE_SIZE = 16 * 1024 * 1024  # 16MB Maximum-Dateigröße für Drag & Drop System
+
+# Umgebungskonfiguration
+ENVIRONMENT = get_env_variable("MYP_ENVIRONMENT", "development")
+
+# SSL-Konfiguration
+SSL_ENABLED = get_env_variable("MYP_SSL_ENABLED", "True").lower() in ("true", "1", "yes")
+SSL_CERT_PATH = os.path.join(BASE_DIR, "certs", "myp.crt")
+SSL_KEY_PATH = os.path.join(BASE_DIR, "certs", "myp.key")
+SSL_HOSTNAME = get_env_variable("MYP_SSL_HOSTNAME", "localhost")
+
+# Scheduler-Konfiguration
+SCHEDULER_INTERVAL = 60  # Sekunden
+SCHEDULER_ENABLED = True
+
+# Datenbank-Konfiguration
+DB_ENGINE = f"sqlite:///{DATABASE_PATH}"
+
+def get_log_file(category: str) -> str:
+    """
+    Gibt den Pfad zur Log-Datei für eine bestimmte Kategorie zurück.
+    
+    Args:
+        category: Log-Kategorie (app, scheduler, auth, jobs, printers, errors)
+        
+    Returns:
+        str: Pfad zur Log-Datei
+    """
+    if category not in LOG_SUBDIRS:
+        category = "app"
+    
+    return os.path.join(LOG_DIR, category, f"{category}.log")
+
+def ensure_log_directories():
+    """Erstellt alle erforderlichen Log-Verzeichnisse."""
+    os.makedirs(LOG_DIR, exist_ok=True)
+    for subdir in LOG_SUBDIRS:
+        os.makedirs(os.path.join(LOG_DIR, subdir), exist_ok=True)
+
+def ensure_database_directory():
+    """Erstellt das Datenbank-Verzeichnis."""
+    db_dir = os.path.dirname(DATABASE_PATH)
+    if db_dir:
+        os.makedirs(db_dir, exist_ok=True)
+
+def ensure_ssl_directory():
+    """Erstellt das SSL-Verzeichnis, falls es nicht existiert."""
+    ssl_dir = os.path.dirname(SSL_CERT_PATH)
+    if ssl_dir and not os.path.exists(ssl_dir):
+        os.makedirs(ssl_dir, exist_ok=True)
+
+def ensure_upload_directory():
+    """Erstellt das Upload-Verzeichnis, falls es nicht existiert."""
+    if not os.path.exists(UPLOAD_FOLDER):
+        os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+def get_ssl_context():
+    """
+    Gibt den SSL-Kontext für Flask zurück, wenn SSL aktiviert ist.
+    
+    Returns:
+        tuple oder None: Tuple mit Zertifikat- und Schlüsselpfad, wenn SSL aktiviert ist, sonst None
+    """
+    if not SSL_ENABLED:
+        return None
+    
+    # Wenn Zertifikate nicht existieren, diese automatisch erstellen
+    if not os.path.exists(SSL_CERT_PATH) or not os.path.exists(SSL_KEY_PATH):
+        ensure_ssl_directory()
+        
+        # Im Entwicklungsmodus versuchen wir, einfache Zertifikate zu erstellen
+        if FLASK_DEBUG:
+            print("SSL-Zertifikate nicht gefunden. Erstelle einfache selbstsignierte Zertifikate...")
+            try:
+                # Einfache Zertifikate mit Python erstellen
+                create_simple_ssl_cert()
+                
+                # Prüfen, ob die Zertifikate erfolgreich erstellt wurden
+                if not os.path.exists(SSL_CERT_PATH) or not os.path.exists(SSL_KEY_PATH):
+                    print("Konnte keine SSL-Zertifikate erstellen.")
+                    return None
+                    
+            except Exception as e:
+                print(f"Fehler beim Erstellen der SSL-Zertifikate: {e}")
+                return None
+        else:
+            print("WARNUNG: SSL-Zertifikate nicht gefunden und Nicht-Debug-Modus. SSL wird deaktiviert.")
+            return None
+    
+    return (SSL_CERT_PATH, SSL_KEY_PATH)
+
+def create_simple_ssl_cert():
+    """
+    Erstellt ein Mercedes-Benz SSL-Zertifikat mit dem neuen SSL-Manager.
+    """
+    try:
+        # Verwende den neuen SSL-Manager
+        from utils.ssl_manager import ssl_manager
+        success = ssl_manager.generate_mercedes_certificate()
+        
+        if success:
+            print(f"Mercedes-Benz SSL-Zertifikat erfolgreich erstellt: {SSL_CERT_PATH}")
+            return True
+        else:
+            print("Fehler beim Erstellen des Mercedes-Benz SSL-Zertifikats")
+            return None
+            
+    except ImportError as e:
+        print(f"SSL-Manager nicht verfügbar: {e}")
+        return None
+    except Exception as e:
+        print(f"Fehler beim Erstellen der SSL-Zertifikate: {e}")
+        return None

config/settings_copy.py

@@ -0,0 +1,173 @@
+import os
+import json
+from datetime import timedelta, datetime
+
+# Hardcodierte Konfiguration
+SECRET_KEY = "7445630171969DFAC92C53CEC92E67A9CB2E00B3CB2F"
+DATABASE_PATH = "database/myp.db"
+TAPO_USERNAME = "till.tomczak@mercedes-benz.com"
+TAPO_PASSWORD = "744563017196A"
+
+# Drucker-Konfiguration
+PRINTERS = {
+    "Printer 1": {"ip": "192.168.0.100"},
+    "Printer 2": {"ip": "192.168.0.101"},
+    "Printer 3": {"ip": "192.168.0.102"},
+    "Printer 4": {"ip": "192.168.0.103"},
+    "Printer 5": {"ip": "192.168.0.104"},
+    "Printer 6": {"ip": "192.168.0.106"}
+}
+
+# Logging-Konfiguration
+LOG_DIR = "logs"
+LOG_SUBDIRS = ["app", "scheduler", "auth", "jobs", "printers", "errors"]
+LOG_LEVEL = "INFO"
+LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+LOG_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+# Flask-Konfiguration
+FLASK_HOST = "0.0.0.0"
+FLASK_PORT = 443
+FLASK_FALLBACK_PORT = 80
+FLASK_DEBUG = True
+SESSION_LIFETIME = timedelta(days=7)
+
+# SSL-Konfiguration
+SSL_ENABLED = True
+SSL_CERT_PATH = "instance/ssl/myp.crt"
+SSL_KEY_PATH = "instance/ssl/myp.key"
+SSL_HOSTNAME = "raspberrypi"
+
+# Scheduler-Konfiguration
+SCHEDULER_INTERVAL = 60  # Sekunden
+SCHEDULER_ENABLED = True
+
+# Datenbank-Konfiguration
+DB_ENGINE = f"sqlite:///{DATABASE_PATH}"
+
+def get_log_file(category: str) -> str:
+    """
+    Gibt den Pfad zur Log-Datei für eine bestimmte Kategorie zurück.
+    
+    Args:
+        category: Log-Kategorie (app, scheduler, auth, jobs, printers, errors)
+        
+    Returns:
+        str: Pfad zur Log-Datei
+    """
+    if category not in LOG_SUBDIRS:
+        category = "app"
+    
+    return os.path.join(LOG_DIR, category, f"{category}.log")
+
+def ensure_log_directories():
+    """Erstellt alle erforderlichen Log-Verzeichnisse."""
+    os.makedirs(LOG_DIR, exist_ok=True)
+    for subdir in LOG_SUBDIRS:
+        os.makedirs(os.path.join(LOG_DIR, subdir), exist_ok=True)
+
+def ensure_database_directory():
+    """Erstellt das Datenbank-Verzeichnis."""
+    db_dir = os.path.dirname(DATABASE_PATH)
+    if db_dir:
+        os.makedirs(db_dir, exist_ok=True)
+
+def ensure_ssl_directory():
+    """Erstellt das SSL-Verzeichnis, falls es nicht existiert."""
+    ssl_dir = os.path.dirname(SSL_CERT_PATH)
+    if ssl_dir and not os.path.exists(ssl_dir):
+        os.makedirs(ssl_dir, exist_ok=True)
+
+def get_ssl_context():
+    """
+    Gibt den SSL-Kontext für Flask zurück, wenn SSL aktiviert ist.
+    
+    Returns:
+        tuple oder None: Tuple mit Zertifikat- und Schlüsselpfad, wenn SSL aktiviert ist, sonst None
+    """
+    if not SSL_ENABLED:
+        return None
+    
+    # Wenn Zertifikate nicht existieren, diese automatisch erstellen
+    if not os.path.exists(SSL_CERT_PATH) or not os.path.exists(SSL_KEY_PATH):
+        ensure_ssl_directory()
+               
+        # Prüfen, ob wir uns im Entwicklungsmodus befinden
+        if FLASK_DEBUG:
+            print("SSL-Zertifikate nicht gefunden. Erstelle selbstsignierte Zertifikate...")
+            
+            # SSL-Zertifikate direkt mit Python erstellen
+            try:
+                from cryptography import x509
+                from cryptography.x509.oid import NameOID
+                from cryptography.hazmat.primitives import hashes
+                from cryptography.hazmat.primitives.asymmetric import rsa
+                from cryptography.hazmat.primitives import serialization
+                import ipaddress
+                
+                # Private Key generieren
+                private_key = rsa.generate_private_key(
+                    public_exponent=65537,
+                    key_size=2048,
+                )
+                
+                # Subject und Issuer für Mercedes-Benz Werk Berlin 040
+                subject = issuer = x509.Name([
+                    x509.NameAttribute(NameOID.COUNTRY_NAME, "DE"),
+                    x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "Berlin"),
+                    x509.NameAttribute(NameOID.LOCALITY_NAME, "Berlin"),
+                    x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Mercedes-Benz AG"),
+                    x509.NameAttribute(NameOID.ORGANIZATIONAL_UNIT_NAME, "Werk Berlin 040"),
+                    x509.NameAttribute(NameOID.COMMON_NAME, "raspberrypi"),
+                ])
+                
+                # Zertifikat erstellen
+                cert = x509.CertificateBuilder().subject_name(
+                    subject
+                ).issuer_name(
+                    issuer
+                ).public_key(
+                    private_key.public_key()
+                ).serial_number(
+                    x509.random_serial_number()
+                ).not_valid_before(
+                    datetime.utcnow()
+                ).not_valid_after(
+                    datetime.utcnow() + timedelta(days=365)
+                ).add_extension(
+                    x509.SubjectAlternativeName([
+                        x509.DNSName("raspberrypi"),
+                        x509.DNSName("localhost"),
+                        x509.IPAddress(ipaddress.IPv4Address("192.168.0.105")),
+                        x509.IPAddress(ipaddress.IPv4Address("127.0.0.1")),
+                    ]),
+                    critical=False,
+                ).sign(private_key, hashes.SHA256())
+                
+                # Zertifikat speichern
+                with open(SSL_CERT_PATH, "wb") as f:
+                    f.write(cert.public_bytes(serialization.Encoding.PEM))
+                
+                # Private Key speichern
+                with open(SSL_KEY_PATH, "wb") as f:
+                    f.write(private_key.private_bytes(
+                        encoding=serialization.Encoding.PEM,
+                        format=serialization.PrivateFormat.PKCS8,
+                        encryption_algorithm=serialization.NoEncryption()
+                    ))
+                
+                print(f"✅ SSL-Zertifikate erfolgreich erstellt für Mercedes-Benz Werk Berlin 040")
+                print(f"   Hostname: raspberrypi")
+                print(f"   IP: 192.168.0.105")
+                
+            except ImportError:
+                print("FEHLER: cryptography-Bibliothek nicht installiert. Installiere mit: pip install cryptography")
+                return None
+            except Exception as e:
+                print(f"FEHLER beim Erstellen der SSL-Zertifikate: {e}")
+                return None
+        else:
+            print("WARNUNG: SSL-Zertifikate nicht gefunden und Nicht-Debug-Modus. SSL wird deaktiviert.")
+            return None
+    
+    return (SSL_CERT_PATH, SSL_KEY_PATH) 

database/__init__.py

@@ -0,0 +1,2 @@
+# Database package initialization file
+# Makes the directory a proper Python package 

database/db_manager.py

@@ -0,0 +1,133 @@
+import os
+import logging
+from typing import List, Optional, Any
+from datetime import datetime
+
+from sqlalchemy import create_engine, func
+from sqlalchemy.orm import sessionmaker, Session, joinedload
+
+from models import User, Printer, Job, Stats, Base
+from config.settings import DATABASE_PATH, ensure_database_directory
+
+logger = logging.getLogger(__name__)
+
+class DatabaseManager:
+    """Database manager class to handle database operations."""
+    
+    def __init__(self):
+        """Initialize the database manager."""
+        ensure_database_directory()
+        self.engine = create_engine(f"sqlite:///{DATABASE_PATH}")
+        self.Session = sessionmaker(bind=self.engine)
+    
+    def get_session(self) -> Session:
+        """Get a new database session.
+        
+        Returns:
+            Session: A new SQLAlchemy session.
+        """
+        return self.Session()
+    
+    def test_connection(self) -> bool:
+        """Test the database connection.
+        
+        Returns:
+            bool: True if the connection is successful, False otherwise.
+        """
+        try:
+            session = self.get_session()
+            session.execute("SELECT 1")
+            session.close()
+            return True
+        except Exception as e:
+            logger.error(f"Database connection test failed: {str(e)}")
+            return False
+    
+    def get_all_jobs(self) -> List[Job]:
+        """Get all jobs with eager loading of relationships.
+        
+        Returns:
+            List[Job]: A list of all jobs.
+        """
+        session = self.get_session()
+        try:
+            jobs = session.query(Job).options(
+                joinedload(Job.user),
+                joinedload(Job.printer)
+            ).all()
+            return jobs
+        finally:
+            session.close()
+    
+    def get_jobs_by_status(self, status: str) -> List[Job]:
+        """Get jobs by status with eager loading of relationships.
+        
+        Args:
+            status: The job status to filter by.
+            
+        Returns:
+            List[Job]: A list of jobs with the specified status.
+        """
+        session = self.get_session()
+        try:
+            jobs = session.query(Job).options(
+                joinedload(Job.user),
+                joinedload(Job.printer)
+            ).filter(Job.status == status).all()
+            return jobs
+        finally:
+            session.close()
+    
+    def get_job_by_id(self, job_id: int) -> Optional[Job]:
+        """Get a job by ID with eager loading of relationships.
+        
+        Args:
+            job_id: The job ID to find.
+            
+        Returns:
+            Optional[Job]: The job if found, None otherwise.
+        """
+        session = self.get_session()
+        try:
+            job = session.query(Job).options(
+                joinedload(Job.user),
+                joinedload(Job.printer)
+            ).filter(Job.id == job_id).first()
+            return job
+        finally:
+            session.close()
+    
+    def get_available_printers(self) -> List[Printer]:
+        """Get all available printers.
+        
+        Returns:
+            List[Printer]: A list of available printers.
+        """
+        session = self.get_session()
+        try:
+            printers = session.query(Printer).filter(
+                Printer.active == True,
+                Printer.status != "busy"
+            ).all()
+            return printers
+        finally:
+            session.close()
+    
+    def get_jobs_since(self, since_date: datetime) -> List[Job]:
+        """Get jobs created since a specific date.
+        
+        Args:
+            since_date: The date to filter jobs from.
+            
+        Returns:
+            List[Job]: A list of jobs created since the specified date.
+        """
+        session = self.get_session()
+        try:
+            jobs = session.query(Job).options(
+                joinedload(Job.user),
+                joinedload(Job.printer)
+            ).filter(Job.created_at >= since_date).all()
+            return jobs
+        finally:
+            session.close() 

instance/ssl/myp.crt

@@ -0,0 +1,22 @@
+-----BEGIN CERTIFICATE-----
+MIIDszCCApugAwIBAgIUSVsfL4Mso8Nzu5IGWnBnMkpIJ6YwDQYJKoZIhvcNAQEL
+BQAwejELMAkGA1UEBhMCREUxDzANBgNVBAgMBkJlcmxpbjEPMA0GA1UEBwwGQmVy
+bGluMRkwFwYDVQQKDBBNZXJjZWRlcy1CZW56IEFHMRgwFgYDVQQLDA9XZXJrIEJl
+cmxpbiAwNDAxFDASBgNVBAMMC3Jhc3BiZXJyeXBpMB4XDTI1MDYwMTAxNTA1NVoX
+DTI2MDYwMTAxNTA1NVowejELMAkGA1UEBhMCREUxDzANBgNVBAgMBkJlcmxpbjEP
+MA0GA1UEBwwGQmVybGluMRkwFwYDVQQKDBBNZXJjZWRlcy1CZW56IEFHMRgwFgYD
+VQQLDA9XZXJrIEJlcmxpbiAwNDAxFDASBgNVBAMMC3Jhc3BiZXJyeXBpMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAttoMziaTCV/snarEW3XmOHJvoeZP
+YkC3Lk/yCJuj1V8XJ/lYj7/eLWcCITEAUt+mFUDyfS1yuu4uiNy+prxMrFbTpn1x
+mJA9rZQMM1HE7buRsEniM8YDyyf0WdSUxipiq+IiCBkA+de5XqQqHLc/eKKRjlup
+V8mfVs38h7cIsi6b8CchHz3vFbI2oiED/pu2KJzV/rFMgvnAiRG0iHvoSmbGvJQM
+/DySPoW63oToSFcjkPJenPSrTAKH7IaKZ5uoSXZml9rf7J+OmJHysNvtyE49C9d9
+FPvHSmysvoOT6W1A4I/0l/wZWMWd0xOKeZrPF5h2OtWwCKIrw90P1b2dzQIDAQAB
+ozEwLzAtBgNVHREEJjAkggtyYXNwYmVycnlwaYIJbG9jYWxob3N0hwTAqABphwR/
+AAABMA0GCSqGSIb3DQEBCwUAA4IBAQCd+UKNUOAizOisaEGKou4i1vsa8a7TaJkR
+2LTLgRBKBTiFPddtEgrdSMFmsznUlCZnMk3SE3+tJZq3uAwCOHjGo8XOV0DKrXAz
+ZLICFlPGEqZBnifvXnxuOP14AWFewauygL2KSOmP0p4D7n0kqExa1Y0l6XU7ru2G
+6z9nfl/scBrrtBg1e1bhJ6X7jeNaZbUJG8jfdZ2EpC96QpbmKiy7JyUKYFZtggfD
+PQRnncdJO/3XRBxx6H0FAvJ34pSKA7OB9BqzLdXQoHfw2iy56C78urU8C51ErFYr
+hU2RFTzNrcXmw1unVCp64aY5P5yn0yaXi3VdM5qRxDq5KScYasrG
+-----END CERTIFICATE-----

instance/ssl/myp.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC22gzOJpMJX+yd
+qsRbdeY4cm+h5k9iQLcuT/IIm6PVXxcn+ViPv94tZwIhMQBS36YVQPJ9LXK67i6I
+3L6mvEysVtOmfXGYkD2tlAwzUcTtu5GwSeIzxgPLJ/RZ1JTGKmKr4iIIGQD517le
+pCoctz94opGOW6lXyZ9WzfyHtwiyLpvwJyEfPe8VsjaiIQP+m7YonNX+sUyC+cCJ
+EbSIe+hKZsa8lAz8PJI+hbrehOhIVyOQ8l6c9KtMAofshopnm6hJdmaX2t/sn46Y
+kfKw2+3ITj0L130U+8dKbKy+g5PpbUDgj/SX/BlYxZ3TE4p5ms8XmHY61bAIoivD
+3Q/VvZ3NAgMBAAECggEAIi/AZyalJQKPPac40RTI91LF9lIWE3ugBAOkb+GRjwoZ
+TTr8SNwJkRmKN2Ru+A+igKTE8Yx2v+ZaQvJqnsfj2fDd32nivDBzp6lfYpTuKbiA
+86HMrfteqDQPJmBtdGNmUVaVIEh0e0HPAZfV28qTDl3ustwGXEhxBwy6IzGgaZem
+OevJDp839FXb07DkrQt4BOr/trnp3N2SrauOk+eIlfdmdOAK6CPj0jYBz3155TIW
+w0EbHmt+tdvmL9eLqqN8XcCBIBrUHyCfi6wuATtU81AslOnS1NiYecyoNg0kGm/0
+6+q0R8hT0DmJOuN4bdKCvvv7kuPI/mjcMtmBnYo2QQKBgQDlss70/AOYlIQD4pTI
+DLELruBk6rViUd8SSlwhgwNY4ChRqVjb8koMvs10gCMyCMmae6UzRcQZ7Z/lBoRN
+bYZ+uzc0dLNGSJYKCIm6Bo5kfuUPpN3uC3XsFY+SqIalZOaZhF8LM0oluOsFOuJk
+EoBiFpbNmBZE7z6IxV37hV3DsQKBgQDLygQEOUjza08/UHIMOh6KoHM9qqEU0V02
+hh24TjJUQcZbPu25t0ysxnzK4a/tOWPK3hr0vJHiTNftgyDl9FAkiVGgOtkfNapm
+SGAad2v5LOO3UGbwJ264nt8GGPfkr5sUVv8es6LwKmMUWtYCQIPxlF6OuzSr4kGM
+OhwfApgO3QKBgE5trD534h5x71WIQva/ZqAvmMy8Wyxz+e+71hNXMYhiGUIwyXdo
+FiKd73bs3ZeS6otF1pVYJ+oWebbwb7IkSHzzHZlak2/XDuvkGGqdHHdx4HJj/6bs
+4Nm4TuprgnXsqtQWH4GqhJG2vwBtJ6m1q4JSZjFS0Z+99KMsiLd9xRMxAoGAHPMf
+yvHQWTQfV+E3smD3Qb41YMdChtCPK1W2Fx6Uq7+ETCYOY1mUvN6dj7yr30lN0d3n
+emjnWHyOGCGOpNwmHmqbe+WgPnzDLjCN5nSclBM6biov1WHkqrl2+UjGvmfr4eHR
+8CyYswFyfcvBpyQ/Gix3mlMh0mEb6q2+nPEjZMkCgYEAg+rTg9bN0Xr/SCXZ+cFe
+4xhvT0gcd4O/ETV6Mknrb5vzAN2k14VcFF7um87cUQ1YGhjn1x++f2LBHpuQzTrs
+ydh43ES1mxJPIYizGnjzDBUPsp2rdjg5/TXpFyxxzUhvFkbBl5KFlB403ff7d4Nh
+/mo2c+QK6guGtE2sH4nmZHU=
+-----END PRIVATE KEY-----

logs/analytics/analytics.log

@@ -0,0 +1,150 @@
+2025-06-01 03:01:13 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:04:47 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:06:06 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:29:14 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:31:39 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:35:40 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:38:47 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:43:02 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:30:47 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:49:33 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:50:54 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:39:15 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:42:25 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 03:42:33 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:01:30 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:05:28 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:14:22 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:16:09 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:22:49 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:26:29 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:26:32 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:28:39 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:28:58 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:29:28 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:31:09 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:36:21 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:36:33 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:38:00 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:39:28 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:39:58 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:41:49 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:46:30 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:46:58 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:48:23 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:48:29 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:48:43 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 04:54:12 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 13:15:28 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 13:18:20 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 13:19:07 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 13:19:13 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 13:19:37 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 13:19:50 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 13:21:18 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 13:22:49 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 13:36:31 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 13:39:56 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 14:29:35 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 14:32:50 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 14:36:04 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 14:42:11 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 14:43:52 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 14:50:43 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 14:51:11 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 14:59:56 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 14:59:58 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:01:11 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:03:04 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:03:59 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:08:13 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:15:41 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:16:42 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:18:30 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:19:18 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:20:14 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:32:53 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:46:51 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 15:48:59 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 16:04:33 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 16:48:43 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 17:04:59 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 17:13:03 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 17:14:39 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 17:14:58 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 17:16:36 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 17:36:07 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 17:55:20 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 18:02:30 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 18:02:47 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 19:03:52 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 21:12:55 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 21:13:49 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 21:16:33 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 22:06:59 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 22:07:02 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 22:09:22 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 22:39:54 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 22:39:56 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 22:40:09 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:08:24 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:10:01 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:16:55 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:32:06 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:40:58 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:42:51 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:43:48 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:47:39 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:50:28 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:53:31 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:55:32 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-01 23:56:38 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 07:05:23 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 07:10:47 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 07:14:29 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 07:16:41 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 08:21:39 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 08:22:36 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 10:02:52 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 14:26:41 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 14:26:51 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 14:28:19 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 14:30:43 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 14:34:09 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 14:43:36 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 14:50:27 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 14:51:08 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 15:18:14 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-02 15:29:06 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 13:18:50 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 13:23:53 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 13:27:14 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 14:14:07 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 15:19:24 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 15:21:43 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 15:22:52 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 15:57:19 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 20:42:02 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 22:00:22 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 22:15:15 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 22:15:51 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 23:03:59 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 23:04:27 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 23:05:08 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 23:06:43 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 23:07:16 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 23:09:46 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 23:16:45 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 23:27:45 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 23:33:58 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-03 23:45:52 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-04 00:35:56 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-04 00:36:23 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-04 00:36:31 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-04 00:49:47 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-04 00:50:42 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-04 00:56:10 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-04 00:56:22 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-04 07:21:03 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-04 09:22:06 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert
+2025-06-04 09:24:06 - [analytics] analytics - [INFO] INFO - 📈 Analytics Engine initialisiert

logs/backup/backup.log

@@ -0,0 +1,155 @@
+2025-06-01 03:01:13 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:04:47 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:06:06 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:29:14 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:31:39 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:35:40 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:38:47 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:43:02 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:30:47 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:49:33 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:50:54 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:39:15 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:42:25 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 03:42:33 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:01:29 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:05:28 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:14:22 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:16:09 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:22:49 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:26:29 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:26:32 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:28:39 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:28:58 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:29:28 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:31:09 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:36:21 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:36:33 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:38:00 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:39:28 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:39:58 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:41:49 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:46:30 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:46:58 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:48:23 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:48:29 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:48:43 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 04:54:11 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 13:15:28 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 13:18:20 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 13:19:07 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 13:19:13 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 13:19:37 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 13:19:50 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 13:21:18 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 13:22:49 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 13:36:31 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 13:39:56 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 14:29:35 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 14:32:50 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 14:36:04 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 14:42:11 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 14:43:52 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 14:50:43 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 14:51:11 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 14:59:56 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 14:59:58 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:01:11 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:03:04 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:03:59 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:08:13 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:15:41 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:16:42 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:18:30 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:19:18 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:20:14 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:32:53 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:46:50 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 15:48:59 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 16:04:33 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 16:48:43 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 17:04:59 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 17:13:03 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 17:14:39 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 17:14:57 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 17:16:36 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 17:36:07 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 17:55:20 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 18:02:30 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 18:02:47 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 19:03:52 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 21:12:55 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 21:12:56 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 21:12:56 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 21:13:49 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 21:13:50 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 21:13:50 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 21:16:33 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 22:07:00 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 22:07:03 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 22:09:23 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 22:39:54 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 22:39:56 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 22:40:09 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:08:24 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:10:01 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:16:55 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:32:06 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:40:58 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:42:51 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:43:48 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:47:39 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:50:28 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:53:31 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:55:32 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-01 23:56:38 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 07:05:23 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 07:10:47 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 07:14:29 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 07:16:41 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 08:21:39 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 08:22:36 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 10:02:52 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 14:26:41 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 14:26:51 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 14:28:19 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 14:30:43 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 14:34:08 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 14:43:36 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 14:50:27 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 14:51:08 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 15:18:14 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-02 15:29:06 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 13:18:50 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 13:23:53 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 13:27:14 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 14:14:07 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 15:19:24 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 15:21:43 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 15:22:52 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 15:56:54 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 15:57:19 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 20:42:02 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 22:00:22 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 22:15:15 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 22:15:51 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 23:03:59 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 23:04:27 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 23:05:08 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 23:06:43 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 23:07:15 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 23:09:45 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 23:16:45 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 23:27:45 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 23:33:58 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-03 23:45:52 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-04 00:35:56 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-04 00:36:23 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-04 00:36:31 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-04 00:49:46 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-04 00:50:42 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-04 00:56:09 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-04 00:56:22 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-04 07:21:03 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-04 09:22:06 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)
+2025-06-04 09:24:06 - [backup] backup - [INFO] INFO - BackupManager initialisiert (minimal implementation)

logs/calendar/calendar.log

@@ -0,0 +1,57 @@
+2025-06-01 03:06:34 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 03:08:04 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 03:38:56 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 03:43:14 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 03:49:50 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 03:50:49 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:01:49 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:05:41 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:06:37 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:08:27 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:08:48 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:16:18 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:31:18 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:31:38 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:31:41 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:40:13 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:42:56 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:42:59 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-08 00:00:00 bis 2025-06-15 00:00:00
+2025-06-01 04:43:00 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:43:00 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-05-25 00:00:00 bis 2025-06-01 00:00:00
+2025-06-01 04:43:02 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:43:02 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-08 00:00:00 bis 2025-06-15 00:00:00
+2025-06-01 04:46:41 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:54:34 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 04:54:51 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 13:23:09 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 13:23:21 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 13:36:49 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 14:29:52 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 15:11:03 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 15:15:50 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 0 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 17:17:49 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 17:40:49 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 17:57:47 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 18:03:05 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 19:04:25 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 19:09:10 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 21:14:20 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 21:14:43 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 23:32:26 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-01 23:41:21 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-02 14:31:48 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-02 15:19:57 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-02 15:29:46 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-02 15:29:51 - [calendar] calendar - [INFO] INFO - 📊 Verfügbarkeitsabfrage: 2/2 Drucker verfügbar
+2025-06-02 15:29:52 - [calendar] calendar - [INFO] INFO - 📊 Verfügbarkeitsabfrage: 2/2 Drucker verfügbar
+2025-06-03 15:23:10 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-03 22:16:10 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-03 23:17:27 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-03 23:36:29 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-03 23:37:22 - [calendar] calendar - [INFO] INFO - 📊 Verfügbarkeitsabfrage: 0/0 Drucker verfügbar
+2025-06-03 23:37:22 - [calendar] calendar - [INFO] INFO - 📊 Verfügbarkeitsabfrage: 0/0 Drucker verfügbar
+2025-06-03 23:37:35 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-04 00:37:45 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-04 00:49:34 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-04 00:49:54 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00
+2025-06-04 00:49:56 - [calendar] calendar - [INFO] INFO - 📅 Kalender-Events abgerufen: 16 Einträge für Zeitraum 2025-06-01 00:00:00 bis 2025-06-08 00:00:00

logs/dashboard/dashboard.log

@@ -0,0 +1,628 @@
+2025-06-01 03:01:14 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:01:15 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:01:15 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 03:01:15 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 03:04:48 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:04:48 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:04:48 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 03:04:48 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 03:06:07 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:06:07 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:06:07 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 03:06:07 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 03:29:15 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:29:16 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:29:16 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 03:29:16 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 03:31:40 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:35:41 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:38:47 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:38:47 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:38:47 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 03:38:47 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 03:43:03 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:43:03 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:43:03 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 03:43:03 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 03:49:33 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:49:34 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:49:34 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 03:49:34 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 03:50:55 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:50:55 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:50:55 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 03:50:55 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 03:39:15 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:42:26 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:42:26 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:42:26 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 03:42:26 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 03:42:34 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:42:34 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 03:42:34 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 03:42:34 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:01:31 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:01:31 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:01:31 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:01:31 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:05:29 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:05:29 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:05:29 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:05:29 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:14:22 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:14:23 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:14:23 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:14:23 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:16:10 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:16:10 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:16:10 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:16:10 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:22:50 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:22:50 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:22:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:22:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:26:30 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:26:30 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:26:30 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:26:30 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:26:33 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:26:33 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:26:33 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:26:33 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:28:40 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:28:40 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:28:40 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:28:40 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:28:59 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:28:59 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:28:59 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:28:59 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:29:28 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:29:29 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:29:29 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:29:29 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:31:10 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:31:10 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:31:10 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:31:10 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:36:22 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:36:22 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:36:22 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:36:22 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:36:34 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:36:34 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:36:34 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:36:34 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:38:01 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:38:01 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:38:01 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:38:01 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:39:29 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:39:29 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:39:29 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:39:29 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:39:59 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:39:59 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:39:59 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:39:59 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:41:50 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:41:50 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:41:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:41:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:46:31 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:46:31 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:46:31 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:46:31 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:46:58 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:46:58 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:46:58 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:46:58 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:48:24 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:48:24 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:48:24 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:48:24 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:48:30 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:48:30 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:48:30 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:48:30 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:48:44 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:48:44 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:48:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:48:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 04:54:12 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:54:12 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 04:54:12 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 04:54:13 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 13:15:29 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:15:30 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:15:30 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 13:15:30 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 13:18:21 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:18:21 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:18:21 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 13:18:21 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 13:19:08 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:19:08 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:19:08 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 13:19:08 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 13:19:13 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:19:13 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:19:13 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 13:19:13 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 13:19:37 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:19:38 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:19:38 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 13:19:38 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 13:19:51 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:19:51 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:19:51 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 13:19:51 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 13:21:19 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:21:19 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:21:19 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 13:21:19 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 13:22:50 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:22:50 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:22:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 13:22:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 13:36:33 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:36:33 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:36:33 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 13:36:33 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 13:39:57 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:39:58 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 13:39:58 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 13:39:58 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 14:29:36 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:29:36 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:29:36 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 14:29:36 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 14:32:51 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:32:51 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:32:51 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 14:32:51 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 14:36:05 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:36:06 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:36:06 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 14:36:06 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 14:42:12 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:42:12 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:42:12 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 14:42:12 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 14:43:53 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:43:53 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:43:53 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 14:43:53 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 14:50:44 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:50:44 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:50:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 14:50:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 14:51:12 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:51:12 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:51:12 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 14:51:12 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 14:59:56 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:59:57 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:59:57 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 14:59:57 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 14:59:58 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:59:58 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 14:59:58 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 14:59:58 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:01:12 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:01:12 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:01:12 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:01:12 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:03:05 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:03:05 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:03:05 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:03:05 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:03:59 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:04:00 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:04:00 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:04:00 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:08:14 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:08:14 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:08:14 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:08:14 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:15:41 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:15:42 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:15:42 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:15:42 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:16:43 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:16:43 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:16:43 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:16:43 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:18:30 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:18:31 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:18:31 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:18:31 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:19:19 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:19:19 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:19:19 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:19:19 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:20:15 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:20:15 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:20:15 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:20:15 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:32:54 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:32:54 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:32:54 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:32:54 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:46:52 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:46:52 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:46:52 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:46:52 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 15:49:00 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:49:00 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 15:49:00 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 15:49:00 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 16:04:34 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 16:04:34 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 16:04:34 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 16:04:34 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 16:48:44 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 16:48:44 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 16:48:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 16:48:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 17:04:59 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:04:59 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:04:59 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 17:04:59 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 17:13:04 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:13:04 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:13:04 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 17:13:04 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 17:14:40 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:14:40 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:14:40 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 17:14:40 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 17:14:58 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:14:58 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:14:58 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 17:14:58 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 17:16:36 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:16:36 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:16:36 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 17:16:36 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 17:36:08 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:36:08 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:36:08 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 17:36:08 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 17:55:21 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:55:21 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 17:55:21 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 17:55:21 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 18:02:30 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 18:02:31 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 18:02:31 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 18:02:31 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 18:02:48 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 18:02:48 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 18:02:48 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 18:02:48 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 19:03:53 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 19:03:53 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 19:03:53 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 19:03:53 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 21:12:56 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 21:12:56 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 21:12:56 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 21:12:56 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 21:12:56 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 21:12:56 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 21:12:56 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 21:12:56 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 21:12:56 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 21:12:56 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 21:13:50 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 21:13:50 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 21:13:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 21:13:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 21:13:50 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 21:13:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 21:13:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 21:13:50 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 21:13:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 21:13:50 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 22:07:00 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:07:00 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:07:00 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 22:07:00 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 22:07:03 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:07:03 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:07:03 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 22:07:03 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 22:09:23 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:09:23 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:09:23 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 22:09:23 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 22:39:54 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:39:55 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:39:55 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 22:39:55 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 22:39:57 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:39:57 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:39:57 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 22:39:57 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 22:40:10 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:40:10 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 22:40:10 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 22:40:10 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:08:25 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:08:25 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:08:25 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:08:25 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:10:02 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:10:02 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:10:02 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:10:02 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:16:56 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:16:56 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:16:56 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:16:56 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:32:07 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:32:07 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:32:07 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:32:07 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:40:59 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:40:59 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:40:59 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:40:59 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:42:52 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:42:52 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:42:52 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:42:52 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:43:48 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:43:49 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:43:49 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:43:49 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:47:40 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:47:40 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:47:40 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:47:40 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:50:28 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:50:29 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:50:29 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:50:29 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:53:32 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:53:32 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:53:32 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:53:32 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:55:33 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:55:33 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:55:33 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:55:33 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-01 23:56:38 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:56:38 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-01 23:56:38 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-01 23:56:38 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 07:05:25 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 07:05:25 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 07:05:25 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 07:05:25 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 07:10:48 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 07:10:48 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 07:10:48 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 07:10:48 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 07:14:30 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 07:14:30 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 07:14:30 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 07:14:30 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 07:16:41 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 07:16:41 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 07:16:41 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 07:16:41 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 08:21:40 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 08:21:40 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 08:21:40 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 08:21:40 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 08:22:37 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 08:22:37 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 08:22:37 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 08:22:37 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 10:02:53 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 10:02:54 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 10:02:54 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 10:02:54 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 14:26:42 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:26:42 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:26:42 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 14:26:42 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 14:26:52 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:26:52 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:26:52 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 14:26:52 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 14:28:20 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:28:20 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:28:20 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 14:28:20 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 14:30:44 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:30:44 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:30:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 14:30:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 14:34:09 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:34:09 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:34:09 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 14:34:09 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 14:43:37 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:43:37 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:43:37 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 14:43:37 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 14:50:28 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:50:28 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:50:28 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 14:50:28 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 14:51:09 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:51:09 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 14:51:09 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 14:51:09 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 15:18:15 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 15:18:16 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 15:18:16 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 15:18:16 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-02 15:20:26 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für system_alerts: 
+2025-06-02 15:29:07 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 15:29:07 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-02 15:29:07 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-02 15:29:07 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 13:18:51 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 13:18:52 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 13:18:52 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 13:18:52 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 13:23:54 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 13:23:54 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 13:23:54 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 13:23:54 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 13:27:15 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 13:27:15 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 13:27:15 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 13:27:15 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 14:14:08 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 14:14:08 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 14:14:08 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 14:14:08 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 15:19:26 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 15:19:26 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 15:19:26 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 15:19:26 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 15:21:44 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 15:21:44 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 15:21:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 15:21:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 15:22:53 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 15:22:53 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 15:22:53 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 15:22:53 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 15:57:19 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 15:57:20 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 15:57:20 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit eventlet initialisiert
+2025-06-03 15:57:20 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: eventlet)
+2025-06-03 20:42:04 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 20:42:04 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 20:42:04 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 20:42:04 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 22:00:23 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 22:00:23 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 22:00:23 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit eventlet initialisiert
+2025-06-03 22:00:23 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: eventlet)
+2025-06-03 22:15:16 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 22:15:16 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 22:15:16 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit eventlet initialisiert
+2025-06-03 22:15:16 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: eventlet)
+2025-06-03 22:15:51 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 22:15:51 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 22:15:51 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit eventlet initialisiert
+2025-06-03 22:15:51 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: eventlet)
+2025-06-03 23:04:00 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:04:00 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:04:00 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 23:04:00 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 23:04:28 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:04:28 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:04:28 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 23:04:28 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 23:05:09 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:05:09 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:05:09 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 23:05:09 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 23:06:43 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:06:44 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:06:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 23:06:44 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 23:07:16 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:07:16 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:07:16 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 23:07:16 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 23:09:46 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:09:46 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:09:46 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 23:09:46 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 23:16:46 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:16:46 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:16:46 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 23:16:46 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 23:27:45 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für active_jobs: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für online_printers: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für jobs_timeline: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für printer_status: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für recent_jobs: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für system_alerts: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für user_activity: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für guest_requests: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:27:45 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit eventlet initialisiert
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für active_jobs: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: eventlet)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für online_printers: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für jobs_timeline: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für printer_status: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für recent_jobs: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für system_alerts: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für user_activity: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:27:45 - [dashboard] dashboard - [ERROR] ERROR - Fehler beim Laden der Widget-Daten für guest_requests: (sqlite3.OperationalError) disk I/O error
+(Background on this error at: https://sqlalche.me/e/20/e3q8)
+2025-06-03 23:33:59 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:33:59 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:33:59 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 23:33:59 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-03 23:45:53 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:45:53 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-03 23:45:53 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-03 23:45:53 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-04 00:35:56 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:35:57 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:35:57 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-04 00:35:57 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-04 00:36:24 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:36:24 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:36:24 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-04 00:36:24 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-04 00:36:31 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:36:32 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:36:32 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-04 00:36:32 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-04 00:49:48 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:49:48 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:49:48 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-04 00:49:48 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-04 00:50:43 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:50:43 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:50:43 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-04 00:50:43 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-04 00:56:10 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:56:10 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:56:10 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-04 00:56:10 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-04 00:56:23 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:56:23 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 00:56:23 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit threading initialisiert (eventlet-Fallback)
+2025-06-04 00:56:23 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: threading)
+2025-06-04 07:21:04 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 07:21:04 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 07:21:04 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit eventlet initialisiert
+2025-06-04 07:21:04 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: eventlet)
+2025-06-04 09:22:06 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 09:22:06 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 09:22:06 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit eventlet initialisiert
+2025-06-04 09:22:06 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: eventlet)
+2025-06-04 09:24:06 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 09:24:06 - [dashboard] dashboard - [INFO] INFO - Dashboard-Background-Worker gestartet
+2025-06-04 09:24:06 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server wird mit eventlet initialisiert
+2025-06-04 09:24:06 - [dashboard] dashboard - [INFO] INFO - Dashboard WebSocket-Server initialisiert (async_mode: eventlet)

logs/database/database.log

@@ -0,0 +1,151 @@
+2025-06-01 03:01:13 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:04:47 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:06:06 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:29:14 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:31:39 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:35:40 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:38:47 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:43:02 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:30:47 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:49:33 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:50:54 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:39:15 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:42:25 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 03:42:33 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:01:29 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:05:28 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:14:22 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:16:09 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:22:49 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:26:29 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:26:32 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:28:39 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:28:58 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:29:28 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:31:09 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:36:21 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:36:33 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:38:00 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:39:28 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:39:58 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:41:49 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:46:30 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:46:58 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:48:23 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:48:29 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:48:43 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 04:54:11 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 13:15:28 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 13:18:20 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 13:19:07 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 13:19:13 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 13:19:37 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 13:19:50 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 13:21:18 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 13:22:49 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 13:36:31 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 13:39:56 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 14:29:35 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 14:32:50 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 14:36:04 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 14:42:11 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 14:43:52 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 14:50:43 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 14:51:11 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 14:59:56 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 14:59:58 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:01:11 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:03:04 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:03:59 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:08:13 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:15:41 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:16:42 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:18:30 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:19:18 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:20:14 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:32:53 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:46:50 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 15:48:59 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 16:04:33 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 16:48:43 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 17:04:59 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 17:13:03 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 17:14:39 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 17:14:57 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 17:16:36 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 17:36:07 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 17:55:20 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 18:02:30 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 18:02:47 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 19:03:52 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 21:12:55 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 21:13:49 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 21:16:33 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 22:07:00 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 22:07:03 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 22:09:23 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 22:39:54 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 22:39:56 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 22:40:09 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:08:24 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:10:01 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:16:55 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:32:06 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:40:58 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:42:51 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:43:48 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:47:39 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:50:28 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:53:31 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:55:32 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-01 23:56:38 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 07:05:23 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 07:10:47 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 07:14:29 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 07:16:41 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 08:21:39 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 08:22:36 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 10:02:52 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 14:26:41 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 14:26:51 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 14:28:19 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 14:30:43 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 14:34:08 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 14:43:36 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 14:50:27 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 14:51:08 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 15:18:14 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-02 15:29:06 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 13:18:50 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 13:23:53 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 13:27:14 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 14:14:07 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 15:19:24 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 15:21:43 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 15:22:52 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 15:56:54 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 15:57:19 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 20:42:02 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 22:00:22 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 22:15:15 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 22:15:51 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 23:03:59 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 23:04:27 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 23:05:08 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 23:06:43 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 23:07:15 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 23:09:45 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 23:16:45 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 23:27:45 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 23:33:58 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-03 23:45:52 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-04 00:35:56 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-04 00:36:23 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-04 00:36:31 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-04 00:49:46 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-04 00:50:42 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-04 00:56:09 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-04 00:56:22 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-04 07:21:03 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-04 09:22:06 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet
+2025-06-04 09:24:06 - [database] database - [INFO] INFO - Datenbank-Wartungs-Scheduler gestartet

logs/database_cleanup/database_cleanup.log

@@ -0,0 +1,105 @@
+2025-06-01 03:03:00 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-01 03:03:00 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-01 03:03:00 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-01 03:04:49 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-01 03:04:49 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-01 03:04:49 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-01 03:30:12 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-01 03:30:12 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-01 03:30:12 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-01 03:39:41 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-01 03:39:41 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-01 03:39:41 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-01 17:13:19 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-01 17:13:19 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-01 17:13:19 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-02 15:18:16 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-02 15:18:16 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-02 15:18:16 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-02 15:29:07 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-02 15:29:07 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-02 15:29:07 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 13:18:52 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 13:18:52 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 13:18:52 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 14:14:09 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 14:14:09 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 14:14:09 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 15:19:26 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 15:19:26 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 15:19:26 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 15:21:45 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 15:21:45 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 15:21:45 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 15:22:53 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 15:22:53 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 15:22:53 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 15:57:20 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 15:57:20 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 15:57:20 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 20:42:04 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 20:42:04 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 20:42:04 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 22:00:23 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 22:00:23 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 22:00:23 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 22:15:16 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 22:15:16 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 22:15:16 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 22:15:51 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 22:15:51 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 22:15:51 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 23:04:01 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 23:04:01 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 23:04:01 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 23:04:28 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 23:04:28 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 23:04:28 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 23:05:09 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 23:05:09 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 23:05:09 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 23:07:17 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 23:07:17 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 23:07:17 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 23:09:47 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 23:09:47 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 23:09:47 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 23:16:47 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 23:16:47 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 23:16:47 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 23:27:46 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 23:27:46 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 23:27:46 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 23:33:59 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 23:33:59 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 23:33:59 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-03 23:45:54 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-03 23:45:54 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-03 23:45:54 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-04 00:35:57 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-04 00:35:57 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-04 00:35:57 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-04 00:36:32 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-04 00:36:32 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-04 00:36:32 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-04 00:49:48 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-04 00:49:48 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-04 00:49:48 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-04 00:50:43 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-04 00:50:43 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-04 00:50:43 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-04 00:56:11 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-04 00:56:11 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-04 00:56:11 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-04 00:56:23 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-04 00:56:23 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-04 00:56:23 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-04 07:21:04 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-04 07:21:04 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-04 07:21:04 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-04 09:22:06 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-04 09:22:06 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-04 09:22:06 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...
+2025-06-04 09:24:07 - [database_cleanup] database_cleanup - [INFO] INFO - 🧹 Starte umfassendes Datenbank-Cleanup...
+2025-06-04 09:24:07 - [database_cleanup] database_cleanup - [INFO] INFO - 📝 Schritt 1: Schließe alle Datenbankverbindungen...
+2025-06-04 09:24:07 - [database_cleanup] database_cleanup - [INFO] INFO - 🔄 Schließe alle aktiven Datenbankverbindungen...

logs/debug.log

@@ -0,0 +1,40 @@
+=================================================================
+MYP Installation DEBUG Log - 2025-06-04 09:12:54
+=================================================================
+
+[2025-06-04 09:12:54] DEBUG von setup.sh:464
+Debian erkannt über /etc/debian_version: 12.11
+---
+
+[2025-06-04 09:12:54] DEBUG von setup.sh:532
+Kein Raspberry Pi erkannt. Hardware-Info:
+---
+
+[2025-06-04 09:12:54] DEBUG von setup.sh:533
+  - Device Tree: nicht verfügbar
+---
+
+[2025-06-04 09:12:54] DEBUG von setup.sh:534
+  - CPU Hardware: nicht verfügbar
+---
+
+[2025-06-04 09:12:54] DEBUG von setup.sh:574
+Vollständige Kernel-Info: Linux debian 6.1.0-37-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.140-1 (2025-05-22) x86_64 GNU/Linux
+---
+
+[2025-06-04 09:12:55] DEBUG von setup.sh:630
+DNS-Test Details: Teste DNS für 8.8.8.8: Erfolg mit nslookup. 
+---
+
+[2025-06-04 09:12:55] DEBUG von setup.sh:731
+Externe IP ermittelt über ifconfig.me: 163.116.178.114
+---
+
+[2025-06-04 09:18:00] DEBUG von setup.sh:995
+flask erfolgreich importiert
+---
+
+[2025-06-04 09:18:00] DEBUG von setup.sh:995
+requests erfolgreich importiert
+---
+

logs/email_notification/email_notification.log

@@ -0,0 +1,147 @@
+2025-06-01 03:01:14 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 03:04:48 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 03:06:07 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 03:29:15 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 03:31:40 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 03:35:41 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 03:38:47 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 03:43:03 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 03:49:34 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 03:50:55 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 03:42:26 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 03:42:34 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:01:31 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:05:29 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:14:23 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:16:10 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:22:50 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:26:30 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:26:33 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:28:40 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:28:59 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:29:28 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:31:10 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:36:22 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:36:34 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:38:01 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:39:29 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:39:59 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:41:50 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:46:31 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:46:58 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:48:24 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:48:30 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:48:44 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 04:54:12 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 13:15:29 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 13:18:21 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 13:19:08 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 13:19:13 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 13:19:37 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 13:19:51 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 13:21:19 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 13:22:50 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 13:36:33 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 13:39:57 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 14:29:36 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 14:32:51 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 14:36:06 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 14:42:12 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 14:43:53 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 14:50:44 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 14:51:12 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 14:59:56 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 14:59:58 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:01:12 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:03:05 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:03:59 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:08:14 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:15:41 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:16:43 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:18:31 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:19:19 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:20:15 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:32:54 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:46:52 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 15:49:00 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 16:04:34 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 16:48:44 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 17:04:59 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 17:13:04 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 17:14:40 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 17:14:58 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 17:16:36 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 17:36:08 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 17:55:21 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 18:02:30 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 18:02:48 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 19:03:53 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 21:12:56 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 21:13:50 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 22:07:00 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 22:07:03 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 22:09:23 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 22:39:54 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 22:39:57 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 22:40:10 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:08:25 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:10:02 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:16:56 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:32:07 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:40:59 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:42:52 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:43:48 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:47:40 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:50:29 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:53:32 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:55:33 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-01 23:56:38 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 07:05:25 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 07:10:48 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 07:14:30 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 07:16:41 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 08:21:40 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 08:22:37 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 10:02:53 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 14:26:42 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 14:26:52 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 14:28:20 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 14:30:44 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 14:34:09 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 14:43:37 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 14:50:28 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 14:51:09 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 15:18:15 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-02 15:29:07 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 13:18:51 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 13:23:54 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 13:27:15 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 14:14:08 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 15:19:26 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 15:21:44 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 15:22:53 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 15:57:20 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 20:42:04 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 22:00:23 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 22:15:16 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 22:15:51 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 23:04:00 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 23:04:28 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 23:05:09 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 23:06:44 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 23:07:16 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 23:09:46 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 23:16:46 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 23:27:45 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 23:33:59 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-03 23:45:53 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-04 00:35:56 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-04 00:36:24 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-04 00:36:31 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-04 00:49:48 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-04 00:50:43 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-04 00:56:10 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-04 00:56:23 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-04 07:21:04 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-04 09:22:06 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)
+2025-06-04 09:24:06 - [email_notification] email_notification - [INFO] INFO - 📧 Offline-E-Mail-Benachrichtigung initialisiert (kein echter E-Mail-Versand)

logs/error_recovery/error_recovery.log

@@ -0,0 +1,121 @@
+2025-06-02 15:18:16 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-02 15:18:16 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-02 15:18:16 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-02 15:18:16 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-02 15:29:07 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-02 15:29:07 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-02 15:29:07 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-02 15:29:07 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 13:18:52 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 13:18:52 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 13:18:52 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 13:18:52 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 14:14:08 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 14:14:08 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 14:14:09 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 14:14:09 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 15:19:26 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 15:19:26 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 15:19:26 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 15:19:26 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 15:21:44 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 15:21:44 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 15:21:45 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 15:21:45 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 15:22:53 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 15:22:53 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 15:22:53 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 15:22:53 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 15:57:20 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 15:57:20 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 15:57:20 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 15:57:20 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 20:42:04 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 20:42:04 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 20:42:04 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 20:42:04 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 22:00:23 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 22:00:23 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 22:00:23 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 22:00:23 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 22:15:16 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 22:15:16 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 22:15:16 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 22:15:16 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 22:15:51 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 22:15:51 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 22:15:51 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 22:15:51 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 23:04:01 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 23:04:01 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 23:04:01 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 23:04:01 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 23:04:28 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 23:04:28 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 23:04:28 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 23:04:28 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 23:05:09 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 23:05:09 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 23:05:09 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 23:05:09 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 23:07:17 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 23:07:17 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 23:07:17 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 23:07:17 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 23:09:46 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 23:09:46 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 23:09:47 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 23:09:47 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 23:16:46 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 23:16:46 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 23:16:47 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 23:16:47 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 23:27:45 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 23:27:45 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 23:27:46 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 23:27:46 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 23:27:51 - [error_recovery] error_recovery - [INFO] INFO - 🛑 Error-Monitoring gestoppt
+2025-06-03 23:33:59 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 23:33:59 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 23:33:59 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 23:33:59 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-03 23:45:54 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-03 23:45:54 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-03 23:45:54 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-03 23:45:54 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-04 00:35:57 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-04 00:35:57 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-04 00:35:57 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-04 00:35:57 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-04 00:36:32 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-04 00:36:32 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-04 00:36:32 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-04 00:36:32 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-04 00:49:48 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-04 00:49:48 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-04 00:49:48 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-04 00:49:48 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-04 00:50:43 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-04 00:50:43 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-04 00:50:43 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-04 00:50:43 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-04 00:56:11 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-04 00:56:11 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-04 00:56:11 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-04 00:56:11 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-04 00:56:23 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-04 00:56:23 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-04 00:56:23 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-04 00:56:23 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-04 07:21:04 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-04 07:21:04 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-04 07:21:04 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-04 07:21:04 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-04 09:22:06 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-04 09:22:06 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-04 09:22:06 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-04 09:22:06 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database
+2025-06-04 09:24:07 - [error_recovery] error_recovery - [INFO] INFO - 🛡️ Error-Recovery-Manager initialisiert
+2025-06-04 09:24:07 - [error_recovery] error_recovery - [INFO] INFO - 🔍 Error-Monitoring gestartet
+2025-06-04 09:24:07 - [error_recovery] error_recovery - [WARNING] WARNING - 🚨 Fehler erkannt: database_lock - 2025-06-01 00:29:13 - myp.app - ERROR - ❌ Fehler beim Datenbank-Cleanup: (sqlite3.OperationalError) database is locked
+2025-06-04 09:24:07 - [error_recovery] error_recovery - [INFO] INFO - 🔧 Führe Recovery-Aktion aus: reset_database

logs/errors.log

@@ -0,0 +1,4 @@
+=================================================================
+MYP Installation FEHLER Log - 2025-06-04 09:12:54
+=================================================================
+

logs/errors/csrf_fix_2025-05-29.log

@@ -0,0 +1,35 @@
+2025-05-29 11:51:15 - CSRF-TOKEN-FEHLER
+==========================================
+
+FEHLER-BESCHREIBUNG:
+- Typ: CSRF Token Missing
+- Endpunkt: POST /api/guest/requests
+- HTTP-Status: 400 Bad Request
+- IP-Adresse: 127.0.0.1
+
+FEHLER-URSACHE:
+1. Fehlender CSRF-Error-Handler in app.py
+2. JavaScript sendete CSRF-Token nicht mit API-Request
+3. Template guest_request.html hatte unvollständige CSRF-Implementation
+
+LÖSUNGS-MASSNAHMEN:
+1. ✅ CSRF-Error-Handler in app.py hinzugefügt (Zeile 53-66)
+2. ✅ JavaScript in guest_request.html korrigiert (Zeile 425-447)
+3. ✅ CSRF-Token-Validierung implementiert
+4. ✅ Detaillierte Fehler-Logging aktiviert
+
+IMPACT:
+- Betroffene Funktionalität: Gastanfragen-Formular
+- Sicherheits-Level: HOCH (CSRF-Schutz)
+- Benutzer-Impact: Vollständig behoben
+
+PRÄVENTIONS-MASSNAHMEN:
+- CSRF-Token-Validierung in allen API-Endpunkten
+- Konsistente Error-Handler-Implementation
+- Template-Standards für CSRF-Token-Verwendung
+- Automatische Tests für CSRF-Schutz
+
+STATUS: VOLLSTÄNDIG BEHOBEN ✅
+DOKUMENTATION: CSRF_FIX_DOCUMENTATION.md erstellt
+VERANTWORTLICH: Interner Engineering Agent
+ZEITSTEMPEL: 2025-05-29 11:55:00 

logs/guest/guest.log

@@ -0,0 +1 @@
+2025-06-01 17:19:50 - [guest] guest - [INFO] INFO - Neue Gastanfrage erstellt: ID 1, Name: Till Tomczak, OTP generiert

logs/install.log

@@ -0,0 +1,192 @@
+=================================================================
+MYP Installation Log - 2025-06-04 09:12:54
+Script Version: 4.1.0
+System: Linux debian 6.1.0-37-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.140-1 (2025-05-22) x86_64 GNU/Linux
+Arbeitsverzeichnis: /mnt
+Log-Verzeichnis: /mnt/logs
+=================================================================
+
+[2025-06-04 09:12:54] === MODUS: ROBUSTE ABHÄNGIGKEITEN-INSTALLATION FÜR MANUELLES TESTEN ===
+[2025-06-04 09:12:54] ✅ Root-Berechtigung bestätigt
+[2025-06-04 09:12:54] === SYSTEM-RESSOURCEN PRÜFUNG ===
+[FORTSCHRITT] Prüfe RAM...
+[FORTSCHRITT] Verfügbarer RAM: 3914MB
+[ERFOLG] ✅ Ausreichend RAM verfügbar (3914MB)
+[FORTSCHRITT] Prüfe Festplattenplatz...
+[FORTSCHRITT] Verfügbarer Festplattenplatz: 13,2GB (13473MB)
+[ERFOLG] ✅ Ausreichend Festplattenplatz verfügbar (13,2GB)
+[FORTSCHRITT] Prüfe CPU...
+[FORTSCHRITT] CPU: 4 Kern(e) - 11th Gen Intel(R) Core(TM) i7-11850H @ 2.50GHz
+[ERFOLG] ✅ CPU-Information erfolgreich ermittelt
+[2025-06-04 09:12:54] ✅ System-Ressourcen-Prüfung abgeschlossen
+[FORTSCHRITT] Prüfe Debian/Raspbian-System...
+[DEBUG] Debian erkannt über /etc/debian_version: 12.11
+[2025-06-04 09:12:54] ✅ Debian/Raspbian-basiertes System erkannt (Version: 12.11)
+[FORTSCHRITT] Prüfe Raspberry Pi Hardware...
+[INFO] 💻 Standard-PC/Server System (kein Raspberry Pi)
+[DEBUG] Kein Raspberry Pi erkannt. Hardware-Info:
+[DEBUG]   - Device Tree: nicht verfügbar
+[DEBUG]   - CPU Hardware: nicht verfügbar
+[FORTSCHRITT] Prüfe System-Architektur...
+[INFO] 📐 System-Architektur: x86_64
+[INFO]    → 64-Bit x86 Architektur erkannt
+[FORTSCHRITT] Prüfe Kernel-Version...
+[INFO] 🐧 Kernel-Version: 6.1.0-37-amd64
+[DEBUG] Vollständige Kernel-Info: Linux debian 6.1.0-37-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.140-1 (2025-05-22) x86_64 GNU/Linux
+[2025-06-04 09:12:54] ✅ System-Analyse abgeschlossen
+[FORTSCHRITT] Prüfe Internetverbindung (erweiterte Methoden)...
+[FORTSCHRITT] Teste DNS-Auflösung...
+[DEBUG] DNS-Test Details: Teste DNS für 8.8.8.8: Erfolg mit nslookup. 
+[ERFOLG] ✅ Internetverbindung verfügbar
+[INFO]    🔍 Erkannt via: DNS-Auflösung (nslookup: 8.8.8.8)
+[FORTSCHRITT] Ermittle externe IP-Adresse...
+[INFO]    🌐 Externe IP: 163.116.178.114
+[DEBUG] Externe IP ermittelt über ifconfig.me: 163.116.178.114
+[2025-06-04 09:12:55] === KONFIGURIERE HOSTNAME ===
+[FORTSCHRITT] Setze Hostname von 'debian' auf 'raspberrypi'...
+[2025-06-04 09:12:55] ✅ Hostname erfolgreich auf 'raspberrypi' gesetzt
+[2025-06-04 09:12:55] ✅ Hostname-Auflösung funktioniert: raspberrypi -> 127.0.1.1
+[2025-06-04 09:12:55] === ANTI-HÄNGE SYSTEM-UPDATE MIT TIMEOUTS ===
+[FORTSCHRITT] Konfiguriere APT für bessere Zuverlässigkeit (timeout-gesichert)...
+[FORTSCHRITT] Validiere APT-Repositories (timeout-gesichert)...
+[FORTSCHRITT] Bereinige APT-Lock-Dateien...
+[FORTSCHRITT] Aktualisiere Paketlisten (max 60s timeout)...
+[ERFOLG] ✅ APT Update erfolgreich
+[FORTSCHRITT] Führe System-Upgrade durch (max 120s timeout)...
+[ERFOLG] ✅ System Upgrade erfolgreich
+[FORTSCHRITT] Installiere essenzielle System-Tools...
+[FORTSCHRITT] Installiere Pakete: ca-certificates
+[FORTSCHRITT] Installiere Pakete: gnupg
+[FORTSCHRITT] Installiere Pakete: curl
+[FORTSCHRITT] Installiere Pakete: wget
+[FORTSCHRITT] Installiere Pakete: git
+[FORTSCHRITT] Installiere Pakete: nano
+[FORTSCHRITT] Installiere Pakete: htop
+[FORTSCHRITT] Installiere Pakete: rsync
+[FORTSCHRITT] Installiere Pakete: unzip
+[FORTSCHRITT] Installiere Pakete: sudo
+[FORTSCHRITT] Installiere Pakete: systemd
+[FORTSCHRITT] Installiere Pakete: lsb-release
+[FORTSCHRITT] Installiere Pakete: apt-transport-https
+[FORTSCHRITT] Installiere Pakete: software-properties-common
+[FORTSCHRITT] Installiere Pakete: bc
+[FORTSCHRITT] Installiere Pakete: dbus
+[FORTSCHRITT] Installiere Pakete: systemd-timesyncd
+[FORTSCHRITT] Synchronisiere Systemzeit...
+[2025-06-04 09:13:28] ✅ Robustes System-Update abgeschlossen
+[2025-06-04 09:13:28] === SIMPLE NETZWERK-SICHERHEIT (ANTI-HÄNGE VERSION) ===
+[INFO] 🚀 Netzwerk-Sicherheit übersprungen für schnellere Installation
+[INFO] 📝 Kann später manuell aktiviert werden mit: SKIP_NETWORK_SECURITY=0
+[2025-06-04 09:13:28] === ROBUSTE PYTHON-INSTALLATION ===
+[FORTSCHRITT] Installiere Python 3 und Build-Abhängigkeiten...
+[FORTSCHRITT] Installiere Pakete: python3
+[FORTSCHRITT] Installiere Pakete: python3-pip
+[FORTSCHRITT] Installiere Pakete: python3-dev
+[FORTSCHRITT] Installiere Pakete: python3-setuptools
+[FORTSCHRITT] Installiere Pakete: python3-venv
+[FORTSCHRITT] Installiere Pakete: python3-wheel
+[FORTSCHRITT] Installiere Pakete: build-essential
+[FORTSCHRITT] Installiere Pakete: libssl-dev
+[FORTSCHRITT] Installiere Pakete: libffi-dev
+[FORTSCHRITT] Installiere Pakete: libbz2-dev
+[FORTSCHRITT] Installiere Pakete: libreadline-dev
+[FORTSCHRITT] Installiere Pakete: libsqlite3-dev
+[FORTSCHRITT] Installiere Pakete: libncurses5-dev
+[FORTSCHRITT] Installiere Pakete: libncursesw5-dev
+[FORTSCHRITT] Installiere Pakete: zlib1g-dev
+[FORTSCHRITT] Installiere Pakete: sqlite3
+[FORTSCHRITT] Validiere Python-Installation...
+[2025-06-04 09:14:40] ✅ Python Version: 3.11.2
+[FORTSCHRITT] Konfiguriere pip für bessere Zuverlässigkeit...
+[FORTSCHRITT] Erstelle systemweite pip-Konfiguration...
+[FORTSCHRITT] Konfiguriere pip für alle Benutzer...
+[2025-06-04 09:14:40] ✅ pip konfiguriert für Benutzer: user
+[FORTSCHRITT] Aktualisiere pip mit Retry...
+[2025-06-04 09:14:43] ✅ pip Version: 25.1.1
+[2025-06-04 09:14:43] ✅ Robuste Python-Umgebung installiert
+[2025-06-04 09:14:43] === ROBUSTE NODE.JS UND NPM INSTALLATION ===
+[FORTSCHRITT] Bereinige alte Node.js-Installationen...
+[FORTSCHRITT] Installiere Node.js mit Fallback-Strategie...
+[FORTSCHRITT] Verwende Debian Repository als Fallback...
+[FORTSCHRITT] Installiere Pakete: nodejs npm
+[2025-06-04 09:17:21] ✅ Node.js via Debian Repository installiert
+[FORTSCHRITT] Validiere Node.js Installation...
+[2025-06-04 09:17:21] ✅ Node.js Version: v18.19.0
+[2025-06-04 09:17:21] ✅ npm Version: 9.2.0
+[FORTSCHRITT] Optimiere npm-Konfiguration...
+[2025-06-04 09:17:23] ✅ Node.js und npm erfolgreich installiert
+[2025-06-04 09:17:23] === ANTI-HÄNGE SSL-ZERTIFIKATE KONFIGURATION ===
+[FORTSCHRITT] Installiere SSL-Grundkomponenten (timeout-gesichert)...
+[ERFOLG] ✅ SSL-Grundkomponenten installiert
+[FORTSCHRITT] Überspringe CA-Update um Hänger zu vermeiden...
+[INFO] 💡 CA-Zertifikate werden beim nächsten Boot automatisch aktualisiert
+[FORTSCHRITT] Kopiere Mercedes-Zertifikate (max 30s)...
+[INFO] Mercedes-Zertifikate werden beim nächsten Boot aktiv
+[FORTSCHRITT] Konfiguriere SSL-Umgebungsvariablen (schnell)...
+[2025-06-04 09:17:23] ✅ SSL-Zertifikate anti-hänge konfiguriert
+[INFO] 📝 CA-Updates werden automatisch beim nächsten Boot durchgeführt
+[2025-06-04 09:17:23] === PYTHON-PAKETE INSTALLATION ===
+[FORTSCHRITT] Installiere Python-Pakete...
+[FORTSCHRITT] Installiere requirements.txt...
+[ERFOLG] ✅ requirements.txt erfolgreich installiert
+[FORTSCHRITT] Validiere essenzielle Python-Module...
+[DEBUG] flask erfolgreich importiert
+[DEBUG] requests erfolgreich importiert
+[ERFOLG] ✅ Essenzielle Python-Module verfügbar
+[2025-06-04 09:18:00] ✅ Python-Pakete Installation abgeschlossen
+[FORTSCHRITT] Zeige installierte Python-Pakete...
+[2025-06-04 09:18:01] === ROBUSTES ANWENDUNGS-DEPLOYMENT ===
+[FORTSCHRITT] Erstelle sicheres Zielverzeichnis: /opt/myp
+[FORTSCHRITT] Validiere Source-Dateien...
+[FORTSCHRITT] Kopiere Anwendungsdateien (robust)...
+[FORTSCHRITT] Kopiere kritische Datei: app.py
+[ERFOLG] ✅ app.py erfolgreich kopiert
+[FORTSCHRITT] Kopiere kritische Datei: models.py
+[ERFOLG] ✅ models.py erfolgreich kopiert
+[FORTSCHRITT] Kopiere kritische Datei: requirements.txt
+[ERFOLG] ✅ requirements.txt erfolgreich kopiert
+[FORTSCHRITT] Kopiere Verzeichnis: blueprints
+[ERFOLG] ✅ blueprints erfolgreich kopiert
+[FORTSCHRITT] Kopiere Verzeichnis: config
+[ERFOLG] ✅ config erfolgreich kopiert
+[FORTSCHRITT] Kopiere Verzeichnis: database
+[ERFOLG] ✅ database erfolgreich kopiert
+[FORTSCHRITT] Kopiere Verzeichnis: static
+[ERFOLG] ✅ static erfolgreich kopiert
+[FORTSCHRITT] Kopiere Verzeichnis: templates
+[ERFOLG] ✅ templates erfolgreich kopiert
+[FORTSCHRITT] Kopiere Verzeichnis: uploads
+[ERFOLG] ✅ uploads erfolgreich kopiert
+[FORTSCHRITT] Kopiere Verzeichnis: utils
+[ERFOLG] ✅ utils erfolgreich kopiert
+[FORTSCHRITT] Kopiere Verzeichnis: logs
+[ERFOLG] ✅ logs erfolgreich kopiert
+[FORTSCHRITT] Kopiere Verzeichnis: certs
+[ERFOLG] ✅ certs erfolgreich kopiert
+[FORTSCHRITT] Kopiere optionale Datei: package.json
+[FORTSCHRITT] Kopiere optionale Datei: package-lock.json
+[FORTSCHRITT] Kopiere optionale Datei: tailwind.config.js
+[FORTSCHRITT] Kopiere optionale Datei: postcss.config.js
+[FORTSCHRITT] Kopiere optionale Datei: README.md
+[FORTSCHRITT] Erstelle Verzeichnisstruktur...
+[FORTSCHRITT] Setze sichere Berechtigungen...
+[FORTSCHRITT] Konfiguriere robuste Python-Umgebung...
+[2025-06-04 09:18:33] ✅ Python-Pfad konfiguriert: /usr/local/lib/python3.11/dist-packages/myp-app.pth
+[FORTSCHRITT] Konfiguriere Umgebungsvariablen...
+[FORTSCHRITT] Versuche Bash-Profile zu aktualisieren (optional)...
+[2025-06-04 09:18:33] ✅ Root Bash-Profile aktualisiert
+[FORTSCHRITT] Validiere Application Deployment...
+[ERFOLG] ✅ Application Deployment vollständig validiert
+[2025-06-04 09:18:33] ✅ Robustes Anwendungs-Deployment abgeschlossen
+[2025-06-04 09:18:33]    📁 App-Verzeichnis: /opt/myp
+[2025-06-04 09:18:33]    🐍 Python-Pfad konfiguriert
+[2025-06-04 09:18:33]    🔧 Bash-Profile konfiguriert
+[2025-06-04 09:18:33]    🛡️ Sichere Berechtigungen gesetzt
+[2025-06-04 09:18:33] === NPM-ABHÄNGIGKEITEN INSTALLATION ===
+[FORTSCHRITT] Installiere npm-Abhängigkeiten...
+[2025-06-04 09:18:43] ✅ npm install erfolgreich (Standard)
+[2025-06-04 09:18:43] ✅ NPM-Abhängigkeiten verarbeitet
+[2025-06-04 09:18:43] === ROBUSTE SYSTEMD-SERVICES INSTALLATION ===
+[FORTSCHRITT] Validiere und kopiere Service-Dateien...
+[FORTSCHRITT] Kopiere essenziellen Service: myp-https.service
+[ERFOLG] ✅ myp-https.service erfolgreich installiert

logs/jobs/jobs.log

@@ -0,0 +1,157 @@
+2025-05-29 10:07:15 - myp.jobs - INFO - Test für Kategorie jobs
+2025-05-30 21:50:48 - myp.jobs - INFO - 📦 Erstelle Sofort-Job für Drucker Tapo P110 (192.168.0.103) (Start: 2025-05-30 21:50:00)
+2025-05-30 21:50:48 - myp.jobs - INFO - 📦 Erstelle Sofort-Job für Drucker Tapo P110 (192.168.0.103) (Start: 2025-05-30 21:50:00)
+2025-05-30 21:50:48 - myp.jobs - INFO - ✅ Job 2 erstellt für Drucker 4, Start: 2025-05-30 21:50:00, Dauer: 60 Minuten, Status: waiting_for_printer
+2025-05-30 21:50:48 - myp.jobs - INFO - ✅ Job 3 erstellt für Drucker 4, Start: 2025-05-30 21:50:00, Dauer: 60 Minuten, Status: waiting_for_printer
+2025-05-30 21:50:48 - myp.jobs - INFO - ⚡ Sofort-Job 3 erfolgreich gestartet - Drucker automatisch eingeschaltet
+2025-05-30 21:50:48 - myp.jobs - INFO - ⚡ Sofort-Job 2 erfolgreich gestartet - Drucker automatisch eingeschaltet
+2025-05-30 21:51:45 - myp.jobs - INFO - ⏰ Erstelle geplanten Job für Drucker Tapo P110 (192.168.0.104) (Start in 0.2 Min)
+2025-05-30 21:51:45 - myp.jobs - INFO - ✅ Job 4 erstellt für Drucker 5, Start: 2025-05-30 21:52:00, Dauer: 60 Minuten, Status: scheduled
+2025-05-30 21:51:45 - myp.jobs - INFO - ⏰ Erstelle geplanten Job für Drucker Tapo P110 (192.168.0.104) (Start in 0.2 Min)
+2025-05-30 21:51:45 - myp.jobs - INFO - ✅ Job 5 erstellt für Drucker 5, Start: 2025-05-30 21:52:00, Dauer: 60 Minuten, Status: scheduled
+2025-06-01 01:14:30 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:14:45 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:15:00 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:15:00 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:15:14 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:15:30 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:15:30 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:15:44 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:16:03 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:16:18 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:19:40 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:23:29 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:31:25 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:46:18 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:46:27 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:47:00 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:47:07 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:50:52 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:51:03 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 01:51:40 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 02:42:45 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 02:43:03 - myp.jobs - INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 03:06:28 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 03:07:42 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 03:07:55 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 03:29:28 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 03:43:13 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 03:49:46 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 03:50:44 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 03:50:53 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:01:40 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:05:38 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:06:36 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:08:18 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:08:50 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:16:16 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:16:58 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:17:52 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:22:55 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:31:23 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:31:36 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:31:53 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:32:03 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:40:15 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:43:07 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:46:41 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:54:35 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 04:54:44 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 13:23:06 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 13:23:19 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 13:36:46 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 14:29:47 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 14:50:50 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 15:11:06 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 15:15:48 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 15:34:46 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 15:35:01 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 0 (Seite 1)
+2025-06-01 15:35:03 - [jobs] jobs - [ERROR] ERROR - Fehler beim Erstellen eines Jobs: (sqlite3.InterfaceError) bad parameter or other API misuse
+[SQL: SELECT printers.id AS printers_id, printers.name AS printers_name, printers.model AS printers_model, printers.location AS printers_location, printers.ip_address AS printers_ip_address, printers.mac_address AS printers_mac_address, printers.plug_ip AS printers_plug_ip, printers.plug_username AS printers_plug_username, printers.plug_password AS printers_plug_password, printers.status AS printers_status, printers.active AS printers_active, printers.created_at AS printers_created_at, printers.last_checked AS printers_last_checked 
+FROM printers 
+WHERE printers.id = ?]
+[parameters: (4,)]
+(Background on this error at: https://sqlalche.me/e/20/rvf5)
+2025-06-01 15:35:10 - [jobs] jobs - [INFO] INFO - Neuer Job 1 erstellt für Drucker 4, Start: 2025-06-01 15:36:00, Dauer: 60 Minuten
+2025-06-01 15:35:10 - [jobs] jobs - [INFO] INFO - Neuer Job 2 erstellt für Drucker 4, Start: 2025-06-01 15:36:00, Dauer: 60 Minuten
+2025-06-01 15:35:11 - [jobs] jobs - [INFO] INFO - Neuer Job 3 erstellt für Drucker 4, Start: 2025-06-01 15:36:00, Dauer: 60 Minuten
+2025-06-01 15:35:11 - [jobs] jobs - [INFO] INFO - Neuer Job 4 erstellt für Drucker 4, Start: 2025-06-01 15:36:00, Dauer: 60 Minuten
+2025-06-01 15:35:12 - [jobs] jobs - [INFO] INFO - Neuer Job 5 erstellt für Drucker 4, Start: 2025-06-01 15:36:00, Dauer: 60 Minuten
+2025-06-01 15:35:12 - [jobs] jobs - [INFO] INFO - Neuer Job 6 erstellt für Drucker 4, Start: 2025-06-01 15:36:00, Dauer: 60 Minuten
+2025-06-01 15:35:16 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 6 von 6 (Seite 1)
+2025-06-01 15:35:16 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 6 von 6 (Seite 1)
+2025-06-01 15:35:29 - [jobs] jobs - [INFO] INFO - Neuer Job 7 erstellt für Drucker 4, Start: 2025-06-01 15:36:00, Dauer: 2 Minuten
+2025-06-01 15:35:29 - [jobs] jobs - [INFO] INFO - Neuer Job 8 erstellt für Drucker 4, Start: 2025-06-01 15:36:00, Dauer: 2 Minuten
+2025-06-01 15:35:31 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 8 von 8 (Seite 1)
+2025-06-01 16:05:10 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 8 von 8 (Seite 1)
+2025-06-01 16:49:44 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 8 von 8 (Seite 1)
+2025-06-01 16:49:59 - [jobs] jobs - [INFO] INFO - Neuer Job 9 erstellt für Drucker 5, Start: 2025-06-01 16:50:00, Dauer: 60 Minuten
+2025-06-01 16:49:59 - [jobs] jobs - [INFO] INFO - ✅ API-Job-Erstellung 'create_job' erfolgreich in 2073.02ms
+2025-06-01 16:49:59 - [jobs] jobs - [INFO] INFO - Neuer Job 10 erstellt für Drucker 5, Start: 2025-06-01 16:50:00, Dauer: 60 Minuten
+2025-06-01 16:49:59 - [jobs] jobs - [INFO] INFO - ✅ API-Job-Erstellung 'create_job' erfolgreich in 2073.13ms
+2025-06-01 16:49:59 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 10 von 10 (Seite 1)
+2025-06-01 16:50:08 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 10 von 10 (Seite 1)
+2025-06-01 16:51:38 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 10 von 10 (Seite 1)
+2025-06-01 16:51:53 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 10 von 10 (Seite 1)
+2025-06-01 16:51:55 - [jobs] jobs - [INFO] INFO - Neuer Job 12 erstellt für Drucker 5, Start: 2025-06-01 16:51:00, Dauer: 122 Minuten
+2025-06-01 16:51:55 - [jobs] jobs - [INFO] INFO - Neuer Job 11 erstellt für Drucker 5, Start: 2025-06-01 16:51:00, Dauer: 122 Minuten
+2025-06-01 16:51:55 - [jobs] jobs - [INFO] INFO - ✅ API-Job-Erstellung 'create_job' erfolgreich in 2059.93ms
+2025-06-01 16:51:55 - [jobs] jobs - [INFO] INFO - ✅ API-Job-Erstellung 'create_job' erfolgreich in 2058.83ms
+2025-06-01 16:52:08 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 12 von 12 (Seite 1)
+2025-06-01 16:52:08 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 12 von 12 (Seite 1)
+2025-06-01 16:52:09 - [jobs] jobs - [INFO] INFO - Neuer Job 13 erstellt für Drucker 4, Start: 2025-06-01 16:51:00, Dauer: 222 Minuten
+2025-06-01 16:52:09 - [jobs] jobs - [INFO] INFO - ✅ API-Job-Erstellung 'create_job' erfolgreich in 2064.36ms
+2025-06-01 16:52:09 - [jobs] jobs - [INFO] INFO - Neuer Job 14 erstellt für Drucker 4, Start: 2025-06-01 16:51:00, Dauer: 222 Minuten
+2025-06-01 16:52:09 - [jobs] jobs - [INFO] INFO - ✅ API-Job-Erstellung 'create_job' erfolgreich in 2070.85ms
+2025-06-01 17:15:30 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 14 von 14 (Seite 1)
+2025-06-01 17:15:35 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 14 von 14 (Seite 1)
+2025-06-01 17:15:35 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 14 von 14 (Seite 1)
+2025-06-01 17:15:48 - [jobs] jobs - [INFO] INFO - ✅ API-Job-Erstellung 'create_job' erfolgreich in 1.31ms
+2025-06-01 17:15:50 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 14 von 14 (Seite 1)
+2025-06-01 17:15:50 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 14 von 14 (Seite 1)
+2025-06-01 17:15:50 - [jobs] jobs - [INFO] INFO - Neuer Job 15 erstellt für Drucker 4, Start: 2025-06-01 17:16:00, Dauer: 60 Minuten
+2025-06-01 17:15:50 - [jobs] jobs - [INFO] INFO - ✅ API-Job-Erstellung 'create_job' erfolgreich in 2061.18ms
+2025-06-01 17:15:50 - [jobs] jobs - [INFO] INFO - Neuer Job 16 erstellt für Drucker 4, Start: 2025-06-01 17:16:00, Dauer: 60 Minuten
+2025-06-01 17:15:50 - [jobs] jobs - [INFO] INFO - ✅ API-Job-Erstellung 'create_job' erfolgreich in 2076.70ms
+2025-06-01 17:15:59 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 17:17:42 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 17:17:43 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 17:17:44 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 17:17:48 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 17:17:51 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 17:20:00 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 18:03:01 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 19:04:21 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 21:14:21 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 21:14:25 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 23:10:14 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 23:17:20 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 23:32:17 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-01 23:41:18 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-02 10:03:40 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-02 10:03:47 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-02 10:26:53 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-02 14:51:31 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-02 14:51:46 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-02 14:52:01 - [jobs] jobs - [ERROR] ERROR - Fehler beim Abrufen von Jobs: tuple index out of range
+2025-06-02 14:52:01 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-02 14:52:16 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-02 15:18:34 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 0 von 16 (Seite 1)
+2025-06-02 15:18:34 - [jobs] jobs - [ERROR] ERROR - Fehler beim Abrufen von Jobs: (sqlite3.InterfaceError) bad parameter or other API misuse
+[SQL: SELECT jobs.id AS jobs_id, jobs.name AS jobs_name, jobs.description AS jobs_description, jobs.user_id AS jobs_user_id, jobs.printer_id AS jobs_printer_id, jobs.start_at AS jobs_start_at, jobs.end_at AS jobs_end_at, jobs.actual_end_time AS jobs_actual_end_time, jobs.status AS jobs_status, jobs.created_at AS jobs_created_at, jobs.notes AS jobs_notes, jobs.material_used AS jobs_material_used, jobs.file_path AS jobs_file_path, jobs.owner_id AS jobs_owner_id, jobs.duration_minutes AS jobs_duration_minutes, users_1.id AS users_1_id, users_1.email AS users_1_email, users_1.username AS users_1_username, users_1.password_hash AS users_1_password_hash, users_1.name AS users_1_name, users_1.role AS users_1_role, users_1.active AS users_1_active, users_1.created_at AS users_1_created_at, users_1.last_login AS users_1_last_login, users_1.updated_at AS users_1_updated_at, users_1.settings AS users_1_settings, users_1.last_activity AS users_1_last_activity, users_1.department AS users_1_department, users_1.position AS users_1_position, users_1.phone AS users_1_phone, users_1.bio AS users_1_bio, printers_1.id AS printers_1_id, printers_1.name AS printers_1_name, printers_1.model AS printers_1_model, printers_1.location AS printers_1_location, printers_1.ip_address AS printers_1_ip_address, printers_1.mac_address AS printers_1_mac_address, printers_1.plug_ip AS printers_1_plug_ip, printers_1.plug_username AS printers_1_plug_username, printers_1.plug_password AS printers_1_plug_password, printers_1.status AS printers_1_status, printers_1.active AS printers_1_active, printers_1.created_at AS printers_1_created_at, printers_1.last_checked AS printers_1_last_checked 
+FROM jobs LEFT OUTER JOIN users AS users_1 ON users_1.id = jobs.user_id LEFT OUTER JOIN printers AS printers_1 ON printers_1.id = jobs.printer_id ORDER BY jobs.created_at DESC
+ LIMIT ? OFFSET ?]
+[parameters: (50, 0)]
+(Background on this error at: https://sqlalche.me/e/20/rvf5)
+2025-06-02 15:19:34 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-02 15:19:34 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-02 15:20:02 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-03 13:31:45 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-03 20:43:48 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-03 22:16:06 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-03 23:08:51 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-03 23:10:12 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-03 23:34:14 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-03 23:37:28 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-03 23:49:42 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)
+2025-06-04 00:56:35 - [jobs] jobs - [INFO] INFO - Jobs abgerufen: 16 von 16 (Seite 1)

logs/maintenance/maintenance.log

@@ -0,0 +1,298 @@
+2025-06-01 03:01:14 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:01:15 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:04:48 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:04:48 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:06:07 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:06:07 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:29:16 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:29:16 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:31:40 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:35:41 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:38:47 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:38:47 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:43:03 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:43:03 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:49:34 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:49:34 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:50:55 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:50:55 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:42:26 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:42:26 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:42:34 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 03:42:34 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:01:31 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:01:31 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:05:29 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:05:29 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:14:23 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:14:23 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:16:10 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:16:10 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:22:50 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:22:50 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:26:30 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:26:30 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:26:33 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:26:33 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:28:40 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:28:40 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:28:59 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:28:59 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:29:28 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:29:29 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:31:10 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:31:10 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:36:22 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:36:22 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:36:34 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:36:34 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:38:01 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:38:01 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:39:29 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:39:29 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:39:59 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:39:59 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:41:50 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:41:50 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:46:31 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:46:31 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:46:58 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:46:58 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:48:24 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:48:24 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:48:30 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:48:30 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:48:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:48:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:54:12 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 04:54:12 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:15:29 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:15:30 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:18:21 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:18:21 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:19:08 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:19:08 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:19:13 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:19:13 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:19:37 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:19:38 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:19:51 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:19:51 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:21:19 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:21:19 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:22:50 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:22:50 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:36:33 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:36:33 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:39:57 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 13:39:58 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:29:36 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:29:36 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:32:51 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:32:51 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:36:06 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:36:06 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:42:12 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:42:12 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:43:53 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:43:53 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:50:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:50:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:51:12 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:51:12 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:59:56 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:59:57 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:59:58 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 14:59:58 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:01:12 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:01:12 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:03:05 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:03:05 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:03:59 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:04:00 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:08:14 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:08:14 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:15:42 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:15:42 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:16:43 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:16:43 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:18:31 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:18:31 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:19:19 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:19:19 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:20:15 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:20:15 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:32:54 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:32:54 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:46:52 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:46:52 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:49:00 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 15:49:00 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 16:04:34 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 16:04:34 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 16:48:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 16:48:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:04:59 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:04:59 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:13:04 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:13:04 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:14:40 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:14:40 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:14:58 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:14:58 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:16:36 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:16:36 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:36:08 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:36:08 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:55:21 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 17:55:21 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 18:02:30 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 18:02:31 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 18:02:48 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 18:02:48 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 19:03:53 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 19:03:53 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 21:12:56 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 21:12:56 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 21:12:56 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 21:12:56 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 21:13:50 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 21:13:50 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 21:13:50 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 21:13:50 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:07:00 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:07:00 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:07:03 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:07:03 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:09:23 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:09:23 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:39:54 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:39:55 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:39:57 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:39:57 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:40:10 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 22:40:10 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:08:25 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:08:25 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:10:02 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:10:02 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:16:56 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:16:56 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:32:07 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:32:07 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:40:59 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:40:59 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:42:52 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:42:52 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:43:49 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:43:49 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:47:40 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:47:40 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:50:29 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:50:29 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:53:32 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:53:32 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:55:33 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:55:33 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:56:38 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-01 23:56:38 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 07:05:25 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 07:05:25 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 07:10:48 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 07:10:48 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 07:14:30 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 07:14:30 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 07:16:41 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 07:16:41 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 08:00:41 - [maintenance] maintenance - [INFO] INFO - Generiere wöchentlichen Wartungsbericht...
+2025-06-02 08:00:41 - [maintenance] maintenance - [INFO] INFO - Generiere wöchentlichen Wartungsbericht...
+2025-06-02 08:21:40 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 08:21:40 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 08:22:37 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 08:22:37 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 10:02:53 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 10:02:54 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:26:42 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:26:42 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:26:52 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:26:52 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:28:20 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:28:20 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:30:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:30:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:34:09 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:34:09 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:43:37 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:43:37 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:50:28 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:50:28 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:51:09 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 14:51:09 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 15:18:15 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 15:18:16 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 15:29:07 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-02 15:29:07 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 13:18:51 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 13:18:52 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 13:23:54 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 13:23:54 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 13:27:15 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 13:27:15 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 14:14:08 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 14:14:08 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 15:19:26 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 15:19:26 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 15:21:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 15:21:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 15:22:53 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 15:22:53 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 15:57:20 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 15:57:20 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 20:42:04 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 20:42:04 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 22:00:23 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 22:00:23 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 22:15:16 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 22:15:16 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 22:15:51 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 22:15:51 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:04:00 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:04:00 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:04:28 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:04:28 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:05:09 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:05:09 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:06:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:06:44 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:07:16 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:07:16 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:09:46 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:09:46 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:16:46 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:16:46 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:27:45 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:27:45 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:33:59 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:33:59 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:45:53 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-03 23:45:53 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:35:57 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:35:57 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:36:24 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:36:24 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:36:31 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:36:32 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:49:48 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:49:48 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:50:43 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:50:43 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:56:10 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:56:10 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:56:23 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 00:56:23 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 07:21:04 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 07:21:04 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 09:22:06 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 09:22:06 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 09:24:06 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet
+2025-06-04 09:24:06 - [maintenance] maintenance - [INFO] INFO - Wartungs-Scheduler gestartet

logs/multi_location/multi_location.log

@@ -0,0 +1,296 @@
+2025-06-01 03:01:15 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:01:15 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:04:48 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:04:48 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:06:07 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:06:07 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:29:16 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:29:16 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:31:40 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:35:41 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:38:47 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:38:47 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:43:03 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:43:03 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:49:34 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:49:34 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:50:55 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:50:55 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:42:26 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:42:26 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:42:34 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 03:42:34 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:01:31 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:01:31 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:05:29 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:05:29 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:14:23 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:14:23 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:16:10 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:16:10 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:22:50 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:22:50 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:26:30 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:26:30 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:26:33 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:26:33 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:28:40 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:28:40 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:28:59 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:28:59 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:29:28 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:29:29 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:31:10 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:31:10 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:36:22 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:36:22 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:36:34 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:36:34 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:38:01 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:38:01 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:39:29 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:39:29 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:39:59 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:39:59 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:41:50 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:41:50 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:46:31 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:46:31 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:46:58 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:46:58 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:48:24 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:48:24 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:48:30 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:48:30 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:48:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:48:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:54:12 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 04:54:12 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:15:30 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:15:30 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:18:21 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:18:21 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:19:08 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:19:08 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:19:13 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:19:13 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:19:37 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:19:38 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:19:51 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:19:51 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:21:19 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:21:19 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:22:50 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:22:50 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:36:33 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:36:33 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:39:58 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 13:39:58 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:29:36 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:29:36 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:32:51 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:32:51 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:36:06 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:36:06 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:42:12 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:42:12 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:43:53 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:43:53 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:50:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:50:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:51:12 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:51:12 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:59:57 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:59:57 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:59:58 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 14:59:58 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:01:12 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:01:12 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:03:05 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:03:05 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:04:00 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:04:00 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:08:14 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:08:14 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:15:42 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:15:42 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:16:43 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:16:43 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:18:31 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:18:31 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:19:19 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:19:19 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:20:15 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:20:15 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:32:54 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:32:54 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:46:52 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:46:52 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:49:00 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 15:49:00 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 16:04:34 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 16:04:34 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 16:48:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 16:48:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:04:59 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:04:59 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:13:04 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:13:04 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:14:40 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:14:40 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:14:58 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:14:58 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:16:36 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:16:36 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:36:08 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:36:08 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:55:21 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 17:55:21 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 18:02:31 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 18:02:31 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 18:02:48 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 18:02:48 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 19:03:53 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 19:03:53 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 21:12:56 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 21:12:56 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 21:12:56 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 21:12:56 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 21:13:50 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 21:13:50 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 21:13:50 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 21:13:50 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:07:00 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:07:00 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:07:03 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:07:03 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:09:23 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:09:23 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:39:55 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:39:55 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:39:57 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:39:57 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:40:10 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 22:40:10 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:08:25 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:08:25 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:10:02 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:10:02 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:16:56 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:16:56 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:32:07 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:32:07 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:40:59 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:40:59 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:42:52 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:42:52 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:43:49 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:43:49 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:47:40 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:47:40 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:50:29 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:50:29 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:53:32 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:53:32 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:55:33 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:55:33 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:56:38 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-01 23:56:38 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 07:05:25 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 07:05:25 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 07:10:48 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 07:10:48 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 07:14:30 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 07:14:30 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 07:16:41 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 07:16:41 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 08:21:40 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 08:21:40 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 08:22:37 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 08:22:37 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 10:02:54 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 10:02:54 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:26:42 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:26:42 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:26:52 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:26:52 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:28:20 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:28:20 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:30:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:30:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:34:09 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:34:09 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:43:37 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:43:37 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:50:28 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:50:28 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:51:09 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 14:51:09 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 15:18:16 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 15:18:16 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 15:29:07 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-02 15:29:07 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 13:18:52 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 13:18:52 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 13:23:54 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 13:23:54 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 13:27:15 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 13:27:15 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 14:14:08 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 14:14:08 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 15:19:26 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 15:19:26 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 15:21:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 15:21:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 15:22:53 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 15:22:53 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 15:57:20 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 15:57:20 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 20:42:04 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 20:42:04 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 22:00:23 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 22:00:23 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 22:15:16 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 22:15:16 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 22:15:51 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 22:15:51 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:04:00 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:04:00 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:04:28 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:04:28 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:05:09 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:05:09 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:06:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:06:44 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:07:16 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:07:16 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:09:46 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:09:46 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:16:46 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:16:46 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:27:45 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:27:45 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:33:59 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:33:59 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:45:53 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-03 23:45:53 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:35:57 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:35:57 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:36:24 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:36:24 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:36:31 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:36:32 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:49:48 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:49:48 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:50:43 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:50:43 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:56:10 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:56:10 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:56:23 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 00:56:23 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 07:21:04 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 07:21:04 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 09:22:06 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 09:22:06 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 09:24:06 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt
+2025-06-04 09:24:06 - [multi_location] multi_location - [INFO] INFO - Standard-Standort erstellt

logs/myp-install-debug.log

@@ -0,0 +1,56 @@
+=================================================================
+MYP Installation DEBUG Log - 2025-06-03 22:24:29
+=================================================================
+
+[2025-06-03 22:24:29] DEBUG von setup.sh:465
+Debian erkannt über /etc/debian_version: 12.11
+---
+
+[2025-06-03 22:24:29] DEBUG von setup.sh:533
+Kein Raspberry Pi erkannt. Hardware-Info:
+---
+
+[2025-06-03 22:24:29] DEBUG von setup.sh:534
+  - Device Tree: nicht verfügbar
+---
+
+[2025-06-03 22:24:29] DEBUG von setup.sh:535
+  - CPU Hardware: nicht verfügbar
+---
+
+[2025-06-03 22:24:29] DEBUG von setup.sh:575
+Vollständige Kernel-Info: Linux raspberrypi 6.1.0-37-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.140-1 (2025-05-22) x86_64 GNU/Linux
+---
+
+[2025-06-03 22:24:29] DEBUG von setup.sh:631
+DNS-Test Details: Teste DNS für 8.8.8.8: Erfolg mit nslookup. 
+---
+
+[2025-06-03 22:24:30] DEBUG von setup.sh:732
+Externe IP ermittelt über ifconfig.me: 163.116.179.142
+---
+
+[2025-06-03 22:24:40] DEBUG von setup.sh:1148
+sysctl-Konfiguration erstellt: /etc/sysctl.d/99-myp-security.conf
+---
+
+[2025-06-03 22:24:40] DEBUG von setup.sh:1204
+Sysctl-Phase abgeschlossen - fahre mit Installation fort
+---
+
+[2025-06-03 22:24:40] DEBUG von setup.sh:1230
+systemd-networkd nicht aktiv - überspringe
+---
+
+[2025-06-03 22:24:40] DEBUG von setup.sh:1256
+NetworkManager nicht aktiv - überspringe
+---
+
+[2025-06-03 22:24:40] DEBUG von setup.sh:1262
+IPv6 Einträge in /etc/hosts auskommentiert
+---
+
+[2025-06-03 22:24:40] DEBUG von setup.sh:1279
+Netzwerk-Sicherheit ohne Blockierung abgeschlossen
+---
+

logs/myp-install-errors.log

@@ -0,0 +1,4 @@
+=================================================================
+MYP Installation FEHLER Log - 2025-06-03 22:24:29
+=================================================================
+

logs/myp-install-warnings.log

@@ -0,0 +1,4 @@
+=================================================================
+MYP Installation WARNUNGEN Log - 2025-06-03 22:24:29
+=================================================================
+