🚀 Refactor database logs: Cleaned up and optimized backend/logs directory by removing unnecessary files (myp.db-shm, myp.db-wal) and updated various log files (analytics.log, app.log, backup.log, calendar.log, dashboard.log, database.log, email_notification.log, jobs.log, maintenance.log, multi_location.log, permissions.log, printer_monitor.log, printers.log,

backend/app.py

@@ -1881,50 +1881,7 @@ def admin_page():
 @login_required
 @admin_required
 def admin():
-    """Admin-Dashboard-Seite mit Live-Funktionen"""
-    # Daten für das Template sammeln (gleiche Logik wie admin-dashboard)
-    db_session = get_db_session()
-    try:
-        # Erfolgsrate berechnen
-        completed_jobs = db_session.query(Job).filter(Job.status == 'completed').count() if db_session else 0
-        total_jobs = db_session.query(Job).count() if db_session else 0
-        success_rate = round((completed_jobs / total_jobs * 100), 1) if total_jobs > 0 else 0
-
-        # Statistiken sammeln
-        stats = {
-            'total_users': db_session.query(User).count(),
-            'total_printers': db_session.query(Printer).count(),
-            'online_printers': db_session.query(Printer).filter(Printer.status == 'online').count(),
-            'active_jobs': db_session.query(Job).filter(Job.status.in_(['running', 'queued'])).count(),
-            'queued_jobs': db_session.query(Job).filter(Job.status == 'queued').count(),
-            'success_rate': success_rate
-        }
-        
-        # Tab-Parameter
-        active_tab = request.args.get('tab', 'users')
-        
-        # Benutzer laden (für users tab)
-        users = []
-        if active_tab == 'users':
-            users = db_session.query(User).all()
-        
-        # Drucker laden (für printers tab)
-        printers = []
-        if active_tab == 'printers':
-            printers = db_session.query(Printer).all()
-        
-        db_session.close()
-        
-        return render_template("admin.html",
-                             stats=stats,
-                             active_tab=active_tab,
-                             users=users,
-                             printers=printers)
-    except Exception as e:
-        app_logger.error(f"Fehler beim Laden der Admin-Daten: {str(e)}")
-        db_session.close()
-        flash("Fehler beim Laden des Admin-Bereichs.", "error")
-        return redirect(url_for("index"))
+    return render_template(url_for("admin_page"))
 
 @app.route("/socket-test")
 @login_required
@@ -2170,58 +2127,155 @@ def create_user_api():
         return jsonify({"error": "Nur Administratoren können Benutzer erstellen"}), 403
     
     try:
-        data = request.json
+        # JSON-Daten sicher extrahieren
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "Keine JSON-Daten empfangen"}), 400
         
-        # Pflichtfelder prüfen
+        # Pflichtfelder prüfen mit detaillierteren Meldungen
         required_fields = ["username", "email", "password"]
+        missing_fields = []
+        
         for field in required_fields:
-            if field not in data or not data[field]:
-                return jsonify({"error": f"Feld '{field}' ist erforderlich"}), 400
+            if field not in data:
+                missing_fields.append(f"'{field}' fehlt")
+            elif not data[field] or not str(data[field]).strip():
+                missing_fields.append(f"'{field}' ist leer")
+        
+        if missing_fields:
+            return jsonify({
+                "error": "Pflichtfelder fehlen oder sind leer",
+                "details": missing_fields
+            }), 400
+        
+        # Daten extrahieren und bereinigen
+        username = str(data["username"]).strip()
+        email = str(data["email"]).strip().lower()
+        password = str(data["password"])
+        name = str(data.get("name", "")).strip()
+        
+        # E-Mail-Validierung
+        import re
+        email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+        if not re.match(email_pattern, email):
+            return jsonify({"error": "Ungültige E-Mail-Adresse"}), 400
+        
+        # Username-Validierung (nur alphanumerische Zeichen und Unterstriche)
+        username_pattern = r'^[a-zA-Z0-9_]{3,30}$'
+        if not re.match(username_pattern, username):
+            return jsonify({
+                "error": "Ungültiger Benutzername",
+                "details": "Benutzername muss 3-30 Zeichen lang sein und darf nur Buchstaben, Zahlen und Unterstriche enthalten"
+            }), 400
+        
+        # Passwort-Validierung
+        if len(password) < 6:
+            return jsonify({
+                "error": "Passwort zu kurz",
+                "details": "Passwort muss mindestens 6 Zeichen lang sein"
+            }), 400
+        
+        # Starke Passwort-Validierung (optional)
+        if len(password) < 8:
+            user_logger.warning(f"Schwaches Passwort für neuen Benutzer {username}")
         
         db_session = get_db_session()
         
-        # Prüfen, ob bereits ein Benutzer mit diesem Benutzernamen oder E-Mail existiert
-        existing_user = db_session.query(User).filter(
-            (User.username == data["username"]) | (User.email == data["email"])
-        ).first()
-        
-        if existing_user:
+        try:
+            # Prüfen, ob bereits ein Benutzer mit diesem Benutzernamen existiert
+            existing_username = db_session.query(User).filter(User.username == username).first()
+            if existing_username:
+                db_session.close()
+                return jsonify({
+                    "error": "Benutzername bereits vergeben",
+                    "details": f"Ein Benutzer mit dem Benutzernamen '{username}' existiert bereits"
+                }), 400
+            
+            # Prüfen, ob bereits ein Benutzer mit dieser E-Mail existiert
+            existing_email = db_session.query(User).filter(User.email == email).first()
+            if existing_email:
+                db_session.close()
+                return jsonify({
+                    "error": "E-Mail-Adresse bereits vergeben",
+                    "details": f"Ein Benutzer mit der E-Mail-Adresse '{email}' existiert bereits"
+                }), 400
+            
+            # Rolle bestimmen
+            is_admin = bool(data.get("is_admin", False))
+            role = "admin" if is_admin else "user"
+            
+            # Neuen Benutzer erstellen
+            new_user = User(
+                username=username,
+                email=email,
+                name=name if name else username,  # Fallback auf username wenn name leer
+                role=role,
+                active=True,
+                created_at=datetime.now()
+            )
+            
+            # Optionale Felder setzen
+            if "department" in data and data["department"]:
+                new_user.department = str(data["department"]).strip()
+            if "position" in data and data["position"]:
+                new_user.position = str(data["position"]).strip()
+            if "phone" in data and data["phone"]:
+                new_user.phone = str(data["phone"]).strip()
+            
+            # Passwort setzen
+            new_user.set_password(password)
+            
+            # Benutzer zur Datenbank hinzufügen
+            db_session.add(new_user)
+            db_session.commit()
+            
+            # Erfolgreiche Antwort mit Benutzerdaten
+            user_data = {
+                "id": new_user.id,
+                "username": new_user.username,
+                "email": new_user.email,
+                "name": new_user.name,
+                "role": new_user.role,
+                "is_admin": new_user.is_admin,
+                "active": new_user.active,
+                "department": new_user.department,
+                "position": new_user.position,
+                "phone": new_user.phone,
+                "created_at": new_user.created_at.isoformat()
+            }
+            
             db_session.close()
-            return jsonify({"error": "Ein Benutzer mit diesem Benutzernamen oder E-Mail existiert bereits"}), 400
+            
+            user_logger.info(f"Neuer Benutzer '{new_user.username}' ({new_user.email}) erfolgreich erstellt von Admin {current_user.id}")
+            
+            return jsonify({
+                "success": True,
+                "message": f"Benutzer '{new_user.username}' erfolgreich erstellt",
+                "user": user_data
+            }), 201
+            
+        except Exception as db_error:
+            db_session.rollback()
+            db_session.close()
+            user_logger.error(f"Datenbankfehler beim Erstellen des Benutzers: {str(db_error)}")
+            return jsonify({
+                "error": "Datenbankfehler beim Erstellen des Benutzers",
+                "details": "Bitte versuchen Sie es erneut"
+            }), 500
         
-        # Neuen Benutzer erstellen
-        new_user = User(
-            username=data["username"],
-            email=data["email"],
-            name=data.get("name", ""),
-            role="admin" if data.get("is_admin", False) else "user",
-            created_at=datetime.now()
-        )
-        
-        # Passwort setzen
-        new_user.set_password(data["password"])
-        
-        db_session.add(new_user)
-        db_session.commit()
-        
-        user_data = {
-            "id": new_user.id,
-            "username": new_user.username,
-            "email": new_user.email,
-            "name": new_user.name,
-            "role": new_user.role,
-            "is_admin": new_user.is_admin,
-            "created_at": new_user.created_at.isoformat()
-        }
-        
-        db_session.close()
-        
-        user_logger.info(f"Neuer Benutzer '{new_user.username}' erstellt von Admin {current_user.id}")
-        return jsonify({"user": user_data}), 201
+    except ValueError as ve:
+        user_logger.warning(f"Validierungsfehler beim Erstellen eines Benutzers: {str(ve)}")
+        return jsonify({
+            "error": "Ungültige Eingabedaten",
+            "details": str(ve)
+        }), 400
         
     except Exception as e:
-        user_logger.error(f"Fehler beim Erstellen eines Benutzers: {str(e)}")
-        return jsonify({"error": "Interner Serverfehler"}), 500
+        user_logger.error(f"Unerwarteter Fehler beim Erstellen eines Benutzers: {str(e)}")
+        return jsonify({
+            "error": "Interner Serverfehler",
+            "details": "Ein unerwarteter Fehler ist aufgetreten"
+        }), 500
 
 @app.route("/api/admin/users/<int:user_id>", methods=["GET"])
 @login_required
@@ -7171,6 +7225,12 @@ if __name__ == "__main__":
         # Cleanup bei Fehler
         if shutdown_manager:
             shutdown_manager.force_shutdown(1)
+        else:
+            try:
+                stop_queue_manager()
+            except:
+                pass
+            sys.exit(1)
         else:
             try:
                 stop_queue_manager()