"feat: Implement printer management

backend/app/app.py

@@ -1923,154 +1923,4 @@ def validate_ssl_certificate():
         
     except Exception as e:
         app_logger.error(f"Fehler bei der SSL-Validierung: {e}")
-        return jsonify({"error": f"Fehler bei der Validierung: {str(e)}"}), 500
-@login_required
-def get_ssl_info():
-    """Gibt Informationen über das aktuelle SSL-Zertifikat zurück."""
-    if not current_user.is_admin:
-        return jsonify({"error": "Nur Administratoren können SSL-Informationen abrufen"}), 403
-    
-    try:
-        from utils.ssl_manager import ssl_manager
-        cert_info = ssl_manager.get_certificate_info()
-        
-        if not cert_info:
-            return jsonify({
-                "exists": False,
-                "message": "Kein SSL-Zertifikat gefunden"
-            })
-        
-        return jsonify({
-            "exists": True,
-            "certificate": cert_info,
-            "paths": {
-                "cert": ssl_manager.cert_path,
-                "key": ssl_manager.key_path
-            }
-        })
-        
-    except Exception as e:
-        ssl_logger.error(f"Fehler beim Abrufen der SSL-Informationen: {e}")
-        return jsonify({"error": f"Fehler beim Abrufen der SSL-Informationen: {str(e)}"}), 500
-
-@app.route("/api/ssl/generate", methods=["POST"])
-@login_required
-def generate_ssl_certificate():
-    """Generiert ein neues SSL-Zertifikat."""
-    if not current_user.is_admin:
-        return jsonify({"error": "Nur Administratoren können SSL-Zertifikate generieren"}), 403
-    
-    try:
-        from utils.ssl_manager import ssl_manager
-        
-        # Parameter aus Request extrahieren
-        data = request.json or {}
-        key_size = data.get("key_size", 4096)
-        validity_days = data.get("validity_days", 365)
-        
-        # Zertifikat generieren
-        success = ssl_manager.generate_mercedes_certificate(key_size, validity_days)
-        
-        if success:
-            cert_info = ssl_manager.get_certificate_info()
-            ssl_logger.info(f"SSL-Zertifikat von {current_user.username} generiert")
-            
-            return jsonify({
-                "success": True,
-                "message": "SSL-Zertifikat erfolgreich generiert",
-                "certificate": cert_info
-            })
-        else:
-            return jsonify({
-                "success": False,
-                "error": "Fehler beim Generieren des SSL-Zertifikats"
-            }), 500
-            
-    except Exception as e:
-        ssl_logger.error(f"Fehler beim Generieren des SSL-Zertifikats: {e}")
-        return jsonify({"error": f"Fehler beim Generieren: {str(e)}"}), 500
-
-@app.route("/api/ssl/install", methods=["POST"])
-@login_required
-def install_ssl_certificate():
-    """Installiert das SSL-Zertifikat im System."""
-    if not current_user.is_admin:
-        return jsonify({"error": "Nur Administratoren können SSL-Zertifikate installieren"}), 403
-    
-    try:
-        from utils.ssl_manager import ssl_manager
-        
-        success = ssl_manager.install_system_certificate()
-        
-        if success:
-            ssl_logger.info(f"SSL-Zertifikat von {current_user.username} im System installiert")
-            return jsonify({
-                "success": True,
-                "message": "SSL-Zertifikat erfolgreich im System installiert"
-            })
-        else:
-            return jsonify({
-                "success": False,
-                "error": "Fehler bei der Installation des SSL-Zertifikats im System"
-            }), 500
-            
-    except Exception as e:
-        ssl_logger.error(f"Fehler bei der SSL-Installation: {e}")
-        return jsonify({"error": f"Fehler bei der Installation: {str(e)}"}), 500
-
-@app.route("/api/ssl/copy-raspberry", methods=["POST"])
-@login_required
-def copy_ssl_to_raspberry():
-    """Kopiert das SSL-Zertifikat auf den Raspberry Pi."""
-    if not current_user.is_admin:
-        return jsonify({"error": "Nur Administratoren können SSL-Zertifikate kopieren"}), 403
-    
-    try:
-        from utils.ssl_manager import ssl_manager
-        
-        # Parameter aus Request extrahieren
-        data = request.json or {}
-        host = data.get("host", "raspberrypi")
-        user = data.get("user", "pi")
-        dest = data.get("dest", "/home/pi/myp/ssl")
-        
-        success = ssl_manager.copy_to_raspberry(host, user, dest)
-        
-        if success:
-            ssl_logger.info(f"SSL-Zertifikat von {current_user.username} auf Raspberry Pi kopiert")
-            return jsonify({
-                "success": True,
-                "message": f"SSL-Zertifikat erfolgreich auf {host} kopiert"
-            })
-        else:
-            return jsonify({
-                "success": False,
-                "error": "Fehler beim Kopieren des SSL-Zertifikats auf den Raspberry Pi"
-            }), 500
-            
-    except Exception as e:
-        ssl_logger.error(f"Fehler beim Kopieren auf Raspberry Pi: {e}")
-        return jsonify({"error": f"Fehler beim Kopieren: {str(e)}"}), 500
-
-@app.route("/api/ssl/validate", methods=["GET"])
-@login_required
-def validate_ssl_certificate():
-    """Validiert das aktuelle SSL-Zertifikat."""
-    if not current_user.is_admin:
-        return jsonify({"error": "Nur Administratoren können SSL-Zertifikate validieren"}), 403
-    
-    try:
-        from utils.ssl_manager import ssl_manager
-        
-        is_valid = ssl_manager.is_certificate_valid()
-        cert_info = ssl_manager.get_certificate_info()
-        
-        return jsonify({
-            "valid": is_valid,
-            "certificate": cert_info,
-            "message": "Zertifikat ist gültig" if is_valid else "Zertifikat ist ungültig oder läuft bald ab"
-        })
-        
-    except Exception as e:
-        ssl_logger.error(f"Fehler bei der SSL-Validierung: {e}")
         return jsonify({"error": f"Fehler bei der Validierung: {str(e)}"}), 500 

backend/app/clean_and_add_printers.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+Skript zur Bereinigung der Drucker-Datenbank und Hinzufügung der korrekten hardkodierten Drucker.
+"""
+
+import sys
+import os
+sys.path.append('.')
+
+from config.settings import PRINTERS
+from database.db_manager import DatabaseManager
+from models import Printer
+from datetime import datetime
+
+def clean_and_add_printers():
+    """Bereinigt die Drucker-Datenbank und fügt die korrekten hardkodierten Drucker hinzu."""
+    
+    print("=== Drucker-Datenbank bereinigen und neu erstellen ===")
+    print(f"Hardkodierte Drucker: {len(PRINTERS)}")
+    
+    try:
+        db = DatabaseManager()
+        session = db.get_session()
+        
+        # Alle existierenden Drucker löschen
+        existing_printers = session.query(Printer).all()
+        print(f"Lösche {len(existing_printers)} existierende Drucker...")
+        
+        for printer in existing_printers:
+            session.delete(printer)
+        
+        session.commit()
+        print("✅ Alle alten Drucker gelöscht")
+        
+        # Neue Drucker hinzufügen
+        added_count = 0
+        
+        for printer_name, config in PRINTERS.items():
+            # Neuen Drucker erstellen
+            new_printer = Printer(
+                name=printer_name,
+                model="P115",  # Standard-Modell
+                location="Labor",  # Standard-Standort
+                ip_address=config["ip"],
+                mac_address=f"98:25:4A:E1:{printer_name[-1]}0:0{printer_name[-1]}",  # Dummy MAC
+                plug_ip=config["ip"],
+                plug_username="admin",
+                plug_password="admin",
+                status="available",  # Verfügbar, da in Konfiguration
+                active=True,
+                created_at=datetime.now()
+            )
+            
+            session.add(new_printer)
+            print(f"✅ {printer_name}: Hinzugefügt (IP: {config['ip']})")
+            added_count += 1
+        
+        # Änderungen speichern
+        session.commit()
+        session.close()
+        
+        print(f"\n✅ {added_count} neue Drucker hinzugefügt")
+        print("Drucker-Datenbank erfolgreich bereinigt und neu erstellt!")
+        
+    except Exception as e:
+        print(f"❌ Fehler beim Bereinigen: {e}")
+        if 'session' in locals():
+            session.rollback()
+            session.close()
+
+def list_final_printers():
+    """Zeigt die finalen Drucker in der Datenbank an."""
+    
+    print("\n=== Finale Drucker-Liste ===")
+    
+    try:
+        db = DatabaseManager()
+        session = db.get_session()
+        
+        printers = session.query(Printer).all()
+        
+        if not printers:
+            print("Keine Drucker in der Datenbank gefunden.")
+            return
+        
+        print(f"{'ID':<5} {'Name':<15} {'Status':<12} {'IP-Adresse':<15} {'Aktiv':<8}")
+        print("-" * 60)
+        
+        for printer in printers:
+            active_str = "✅" if printer.active else "❌"
+            print(f"{printer.id:<5} {printer.name:<15} {printer.status:<12} {printer.ip_address:<15} {active_str:<8}")
+        
+        session.close()
+        
+        print(f"\nGesamt: {len(printers)} Drucker")
+        
+    except Exception as e:
+        print(f"❌ Fehler beim Abrufen: {e}")
+        if 'session' in locals():
+            session.close()
+
+if __name__ == "__main__":
+    print("Drucker-Datenbank Bereinigung und Neuerstellung")
+    print("=" * 50)
+    
+    # Datenbank bereinigen und neue Drucker hinzufügen
+    clean_and_add_printers()
+    
+    # Finale Liste anzeigen
+    list_final_printers() 

backend/app/config/settings.py

@@ -128,95 +128,22 @@ def get_ssl_context():
 
 def create_simple_ssl_cert():
     """
-    Erstellt ein einfaches selbstsigniertes Zertifikat mit Python.
-    Dies ist ein Fallback, falls OpenSSL nicht verfügbar ist.
+    Erstellt ein Mercedes-Benz SSL-Zertifikat mit dem neuen SSL-Manager.
     """
     try:
-        import datetime
-        import socket
-        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.serialization import Encoding, PrivateFormat, NoEncryption
-
-        # Generiere privaten Schlüssel
-        private_key = rsa.generate_private_key(
-            public_exponent=65537,
-            key_size=4096,  # Stärkere Schlüsselgröße
-        )
-
-        # Schreibe privaten Schlüssel
-        with open(SSL_KEY_PATH, "wb") as f:
-            f.write(private_key.private_bytes(
-                encoding=Encoding.PEM,
-                format=PrivateFormat.TraditionalOpenSSL,
-                encryption_algorithm=NoEncryption()
-            ))
-
-        # Aktuelles Datum und Ablaufdatum berechnen
-        now = datetime.datetime.now()
-        valid_until = now + datetime.timedelta(days=3650)  # 10 Jahre gültig
-
-        # Erstelle Zertifikat mit erweiterten Attributen
-        subject = issuer = x509.Name([
-            x509.NameAttribute(NameOID.COMMON_NAME, SSL_HOSTNAME),
-            x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Mercedes-Benz AG"),
-            x509.NameAttribute(NameOID.ORGANIZATIONAL_UNIT_NAME, "Werk 040 Berlin"),
-            x509.NameAttribute(NameOID.COUNTRY_NAME, "DE"),
-            x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "Berlin"),
-            x509.NameAttribute(NameOID.LOCALITY_NAME, "Berlin")
-        ])
-
-        cert = x509.CertificateBuilder().subject_name(
-            subject
-        ).issuer_name(
-            issuer
-        ).public_key(
-            private_key.public_key()
-        ).serial_number(
-            x509.random_serial_number()
-        ).not_valid_before(
-            now
-        ).not_valid_after(
-            valid_until
-        ).add_extension(
-            x509.SubjectAlternativeName([
-                x509.DNSName(SSL_HOSTNAME), 
-                x509.DNSName("localhost"),
-                x509.IPAddress(socket.inet_aton("127.0.0.1"))
-            ]),
-            critical=False,
-        ).add_extension(
-            x509.BasicConstraints(ca=True, path_length=None), critical=True
-        ).add_extension(
-            x509.KeyUsage(
-                digital_signature=True,
-                content_commitment=False,
-                key_encipherment=True,
-                data_encipherment=False,
-                key_agreement=False,
-                key_cert_sign=True,
-                crl_sign=True,
-                encipher_only=False,
-                decipher_only=False
-            ), critical=True
-        ).add_extension(
-            x509.ExtendedKeyUsage([
-                x509.oid.ExtendedKeyUsageOID.SERVER_AUTH,
-                x509.oid.ExtendedKeyUsageOID.CLIENT_AUTH
-            ]), critical=False
-        ).sign(private_key, hashes.SHA256())
-
-        # Schreibe Zertifikat
-        with open(SSL_CERT_PATH, "wb") as f:
-            f.write(cert.public_bytes(Encoding.PEM))
+        # Verwende den neuen SSL-Manager
+        from utils.ssl_manager import ssl_manager
+        success = ssl_manager.generate_mercedes_certificate()
         
-        print(f"Verbessertes selbstsigniertes Zertifikat erstellt: {SSL_CERT_PATH}")
-        print(f"Gültig bis: {valid_until.strftime('%d.%m.%Y')}")
-        
-    except ImportError:
-        print("Konnte keine SSL-Zertifikate erstellen: cryptography-Paket nicht installiert")
+        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}")

backend/app/create_ssl_cert.py

@@ -86,8 +86,8 @@ if __name__ == "__main__":
     import argparse
     
     parser = argparse.ArgumentParser(description="Erstellt selbstsignierte SSL-Zertifikate für die lokale Entwicklung")
-    parser.add_argument("-c", "--cert", default="instance/ssl/myp.crt", help="Pfad zur Zertifikatsdatei")
-    parser.add_argument("-k", "--key", default="instance/ssl/myp.key", help="Pfad zur Schlüsseldatei")
+    parser.add_argument("-c", "--cert", default="../certs/myp.crt", help="Pfad zur Zertifikatsdatei")
+    parser.add_argument("-k", "--key", default="../certs/myp.key", help="Pfad zur Schlüsseldatei")
     parser.add_argument("-n", "--hostname", default="localhost", help="Hostname für das Zertifikat")
     
     args = parser.parse_args()

backend/app/templates/admin.html

@@ -416,6 +416,12 @@
                 </svg>
                 Logs
             </a>
+            <a href="{{ url_for('admin_page', tab='ssl') }}" class="tab-modern {{ 'active' if active_tab == 'ssl' else '' }}">
+                <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 15v2m-6 4h12a2 2 0 002-2v-6a2 2 0 00-2-2H6a2 2 0 00-2 2v6a2 2 0 002 2zm10-10V7a4 4 0 00-8 0v4h8z" />
+                </svg>
+                SSL
+            </a>
         </div>
 
         <!-- Tab Content -->
@@ -658,11 +664,270 @@
                 </div>
             </div>
         </div>
+        {% endif %}
+
+        <!-- SSL Tab -->
+        {% if active_tab == 'ssl' %}
+        <div class="content-card-modern">
+            <div class="flex flex-col md:flex-row md:justify-between md:items-center mb-8 gap-4">
+                <h3 class="text-3xl font-bold text-slate-900 dark:text-white">SSL-Zertifikatsverwaltung</h3>
+                <button onclick="loadSSLInfo()" class="btn-modern">
+                    <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"/>
+                    </svg>
+                    Aktualisieren
+                </button>
+            </div>
+
+            <div class="grid grid-cols-1 lg:grid-cols-2 gap-8">
+                <!-- Zertifikatsinformationen -->
+                <div class="form-modern">
+                    <h4 class="text-xl font-semibold text-slate-900 dark:text-white mb-6">Aktuelles Zertifikat</h4>
+                    <div id="ssl-info-container">
+                        <div class="text-center py-8">
+                            <div class="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600 mx-auto"></div>
+                            <p class="mt-2 text-slate-600 dark:text-slate-400">Lade Zertifikatsinformationen...</p>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- SSL-Aktionen -->
+                <div class="form-modern">
+                    <h4 class="text-xl font-semibold text-slate-900 dark:text-white mb-6">Zertifikatsverwaltung</h4>
+                    <div class="space-y-4">
+                        <button onclick="generateSSLCertificate()" class="btn-modern w-full justify-center">
+                            <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 6v6m0 0v6m0-6h6m-6 0H6" />
+                            </svg>
+                            Neues Zertifikat generieren
+                        </button>
+                        
+                        <button onclick="installSSLCertificate()" class="btn-success-modern w-full justify-center">
+                            <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4" />
+                            </svg>
+                            Im System installieren
+                        </button>
+                        
+                        <button onclick="copyToRaspberry()" class="btn-modern w-full justify-center">
+                            <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z" />
+                            </svg>
+                            Auf Raspberry Pi kopieren
+                        </button>
+                        
+                        <button onclick="validateSSLCertificate()" class="btn-modern w-full justify-center">
+                            <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z" />
+                            </svg>
+                            Zertifikat validieren
+                        </button>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Erweiterte Optionen -->
+            <div class="form-modern mt-8">
+                <h4 class="text-xl font-semibold text-slate-900 dark:text-white mb-6">Erweiterte Optionen</h4>
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
+                    <div>
+                        <label for="ssl-key-size" class="block text-sm font-medium text-slate-700 dark:text-slate-300 mb-2">Schlüsselgröße (Bits)</label>
+                        <select id="ssl-key-size" class="input-modern w-full">
+                            <option value="2048">2048 Bit</option>
+                            <option value="4096" selected>4096 Bit (Empfohlen)</option>
+                            <option value="8192">8192 Bit</option>
+                        </select>
+                    </div>
+                    <div>
+                        <label for="ssl-validity" class="block text-sm font-medium text-slate-700 dark:text-slate-300 mb-2">Gültigkeitsdauer (Tage)</label>
+                        <input type="number" id="ssl-validity" value="365" min="30" max="3650" class="input-modern w-full">
+                    </div>
+                </div>
+            </div>
+        </div>
         {% endif %}
 
                  <!-- Weitere Tabs können hier hinzugefügt werden -->
     </div>
 </div>
+
+<script>
+// SSL-Verwaltungsfunktionen
+async function loadSSLInfo() {
+    const container = document.getElementById('ssl-info-container');
+    container.innerHTML = `
+        <div class="text-center py-8">
+            <div class="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600 mx-auto"></div>
+            <p class="mt-2 text-slate-600 dark:text-slate-400">Lade Zertifikatsinformationen...</p>
+        </div>
+    `;
+    
+    try {
+        const response = await fetch('/api/ssl/info');
+        const data = await response.json();
+        
+        if (data.exists) {
+            const cert = data.certificate;
+            const isExpired = cert.is_expired;
+            const daysUntilExpiry = cert.days_until_expiry;
+            
+            container.innerHTML = `
+                <div class="space-y-4">
+                    <div class="flex items-center justify-between p-4 bg-white dark:bg-slate-700 rounded-lg">
+                        <span class="font-medium text-slate-900 dark:text-white">Status</span>
+                        <span class="inline-flex items-center px-3 py-1 rounded-full text-xs font-medium ${isExpired ? 'bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200' : daysUntilExpiry < 30 ? 'bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200' : 'bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200'}">
+                            ${isExpired ? 'Abgelaufen' : daysUntilExpiry < 30 ? 'Läuft bald ab' : 'Gültig'}
+                        </span>
+                    </div>
+                    <div class="p-4 bg-white dark:bg-slate-700 rounded-lg">
+                        <div class="text-sm text-slate-600 dark:text-slate-400 mb-1">Gültig bis</div>
+                        <div class="font-medium text-slate-900 dark:text-white">${cert.not_valid_after}</div>
+                    </div>
+                    <div class="p-4 bg-white dark:bg-slate-700 rounded-lg">
+                        <div class="text-sm text-slate-600 dark:text-slate-400 mb-1">Verbleibende Tage</div>
+                        <div class="font-medium text-slate-900 dark:text-white">${daysUntilExpiry} Tage</div>
+                    </div>
+                    <div class="p-4 bg-white dark:bg-slate-700 rounded-lg">
+                        <div class="text-sm text-slate-600 dark:text-slate-400 mb-1">Schlüsselgröße</div>
+                        <div class="font-medium text-slate-900 dark:text-white">${cert.key_size || 'Unbekannt'} Bit</div>
+                    </div>
+                    <div class="p-4 bg-white dark:bg-slate-700 rounded-lg">
+                        <div class="text-sm text-slate-600 dark:text-slate-400 mb-1">Fingerprint (SHA256)</div>
+                        <div class="font-mono text-xs text-slate-900 dark:text-white break-all">${cert.fingerprint}</div>
+                    </div>
+                </div>
+            `;
+        } else {
+            container.innerHTML = `
+                <div class="text-center py-8">
+                    <svg class="w-16 h-16 text-slate-400 mx-auto mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 15v2m-6 4h12a2 2 0 002-2v-6a2 2 0 00-2-2H6a2 2 0 00-2 2v6a2 2 0 002 2zm10-10V7a4 4 0 00-8 0v4h8z" />
+                    </svg>
+                    <p class="text-slate-600 dark:text-slate-400">Kein SSL-Zertifikat gefunden</p>
+                    <p class="text-sm text-slate-500 dark:text-slate-500 mt-2">Generieren Sie ein neues Zertifikat</p>
+                </div>
+            `;
+        }
+    } catch (error) {
+        container.innerHTML = `
+            <div class="text-center py-8">
+                <svg class="w-16 h-16 text-red-400 mx-auto mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
+                </svg>
+                <p class="text-red-600 dark:text-red-400">Fehler beim Laden der Zertifikatsinformationen</p>
+                <p class="text-sm text-slate-500 dark:text-slate-500 mt-2">${error.message}</p>
+            </div>
+        `;
+    }
+}
+
+async function generateSSLCertificate() {
+    const keySize = document.getElementById('ssl-key-size').value;
+    const validity = document.getElementById('ssl-validity').value;
+    
+    try {
+        const response = await fetch('/api/ssl/generate', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRFToken': document.querySelector('meta[name="csrf-token"]').getAttribute('content')
+            },
+            body: JSON.stringify({
+                key_size: parseInt(keySize),
+                validity_days: parseInt(validity)
+            })
+        });
+        
+        const data = await response.json();
+        
+        if (data.success) {
+            alert('SSL-Zertifikat erfolgreich generiert!');
+            loadSSLInfo();
+        } else {
+            alert('Fehler beim Generieren des SSL-Zertifikats: ' + data.error);
+        }
+    } catch (error) {
+        alert('Fehler beim Generieren des SSL-Zertifikats: ' + error.message);
+    }
+}
+
+async function installSSLCertificate() {
+    try {
+        const response = await fetch('/api/ssl/install', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRFToken': document.querySelector('meta[name="csrf-token"]').getAttribute('content')
+            }
+        });
+        
+        const data = await response.json();
+        
+        if (data.success) {
+            alert('SSL-Zertifikat erfolgreich im System installiert!');
+        } else {
+            alert('Fehler bei der Installation: ' + data.error);
+        }
+    } catch (error) {
+        alert('Fehler bei der Installation: ' + error.message);
+    }
+}
+
+async function copyToRaspberry() {
+    const host = prompt('Raspberry Pi Hostname:', 'raspberrypi');
+    if (!host) return;
+    
+    const user = prompt('Benutzername:', 'pi');
+    if (!user) return;
+    
+    try {
+        const response = await fetch('/api/ssl/copy-raspberry', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRFToken': document.querySelector('meta[name="csrf-token"]').getAttribute('content')
+            },
+            body: JSON.stringify({
+                host: host,
+                user: user
+            })
+        });
+        
+        const data = await response.json();
+        
+        if (data.success) {
+            alert('SSL-Zertifikat erfolgreich auf Raspberry Pi kopiert!');
+        } else {
+            alert('Fehler beim Kopieren: ' + data.error);
+        }
+    } catch (error) {
+        alert('Fehler beim Kopieren: ' + error.message);
+    }
+}
+
+async function validateSSLCertificate() {
+    try {
+        const response = await fetch('/api/ssl/validate');
+        const data = await response.json();
+        
+        if (data.valid) {
+            alert('SSL-Zertifikat ist gültig!');
+        } else {
+            alert('SSL-Zertifikat ist ungültig oder läuft bald ab: ' + data.message);
+        }
+    } catch (error) {
+        alert('Fehler bei der Validierung: ' + error.message);
+    }
+}
+
+// SSL-Informationen beim Laden des SSL-Tabs laden
+document.addEventListener('DOMContentLoaded', function() {
+    if (window.location.search.includes('tab=ssl')) {
+        loadSSLInfo();
+    }
+});
+</script>
+
 {% endblock %}
 
 {% block scripts %}

backend/app/utils/ssl_manager.py

@@ -79,8 +79,8 @@ class SSLCertificateManager:
         """Entfernt alte Zertifikate und veraltete Verzeichnisse"""
         # Alte SSL-Verzeichnisse löschen
         old_ssl_dirs = [
-            os.path.join(os.path.dirname(self.certs_dir), "instance", "ssl"),
-            os.path.join(os.path.dirname(self.certs_dir), "ssl")
+            os.path.join(os.path.dirname(os.path.dirname(self.certs_dir)), "app", "instance", "ssl"),
+            os.path.join(os.path.dirname(os.path.dirname(self.certs_dir)), "app", "certs")
         ]
         
         for old_dir in old_ssl_dirs: