core/Projektarbeit-MYP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

🎉 Refactor and reorganize backend files for improved structure and maintainability:

Browse Source
This commit is contained in:
Till Tomczak
2025-05-31 16:54:46 +02:00
parent 62f227dc78
commit e02d4c416c
9 changed files with 1056 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
backend/app/utils/aktiviere_drucker.py Normal file
View File

@@ -0,0 +1,37 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from models import get_db_session, Printer
def aktiviere_alle_drucker():
"""Aktiviert alle Drucker in der Datenbank."""
try:
session = get_db_session()
drucker = session.query(Printer).all()
if not drucker:
print("Keine Drucker in der Datenbank gefunden.")
session.close()
return
print(f"Anzahl Drucker: {len(drucker)}")
print("Aktiviere alle Drucker...")
for d in drucker:
d.active = True
print(f"Drucker {d.id}: {d.name} - IP: {d.plug_ip} - Aktiv: {d.active}")
session.commit()
print("Alle Drucker wurden erfolgreich aktiviert!")
session.close()
except Exception as e:
print(f"Fehler: {str(e)}")
try:
session.rollback()
session.close()
except:
pass
if __name__ == "__main__":
aktiviere_alle_drucker()

80
backend/app/utils/debug_guest_requests.py Normal file
View File

@@ -0,0 +1,80 @@
#!/usr/bin/env python3
"""
Debug-Script für Gastanträge und Admin-Berechtigungen
"""
from models import get_cached_session, GuestRequest, User, UserPermission
from flask_login import current_user
def check_guest_requests():
"""Prüfe Gastanträge nach Status"""
print("=== GASTANTRÄGE STATUS ===")
with get_cached_session() as db:
pending = db.query(GuestRequest).filter_by(status='pending').count()
approved = db.query(GuestRequest).filter_by(status='approved').count()
rejected = db.query(GuestRequest).filter_by(status='rejected').count()
total = db.query(GuestRequest).count()
print(f"Gesamt: {total}")
print(f"Pending (Wird geprüft): {pending}")
print(f"Approved (Genehmigt): {approved}")
print(f"Rejected (Abgelehnt): {rejected}")
if pending == 0:
print("\n⚠️ PROBLEM: Keine Anträge mit Status 'pending' gefunden!")
print(" → Die Genehmigen/Ablehnen-Buttons werden nur bei Status 'pending' angezeigt")
# Erstelle einen Test-Antrag
print("\n🔧 Erstelle Test-Gastantrag...")
test_request = GuestRequest(
name="Test Admin",
email="admin@test.de",
reason="Test für Admin-Buttons",
duration_min=30,
status="pending"
)
db.add(test_request)
db.commit()
print(f"✅ Test-Antrag erstellt (ID: {test_request.id})")
else:
print(f"\n✅ {pending} Anträge mit Status 'pending' gefunden")
# Zeige pending Anträge
pending_requests = db.query(GuestRequest).filter_by(status='pending').all()
for req in pending_requests:
print(f" ID {req.id}: {req.name} - {req.email}")
def check_admin_users():
"""Prüfe Admin-Benutzer und Berechtigungen"""
print("\n=== ADMIN-BENUTZER ===")
with get_cached_session() as db:
# Alle Admins
admins = db.query(User).filter_by(is_admin=True).all()
print(f"Admin-Benutzer: {len(admins)}")
for admin in admins:
print(f" {admin.username} (ID: {admin.id}) - Email: {admin.email}")
# Benutzer mit can_approve_jobs
users_with_approval = db.query(User).join(UserPermission).filter(
UserPermission.can_approve_jobs == True
).all()
print(f"\nBenutzer mit can_approve_jobs: {len(users_with_approval)}")
for user in users_with_approval:
print(f" {user.username} (ID: {user.id}) - Email: {user.email}")
if __name__ == "__main__":
try:
check_guest_requests()
check_admin_users()
print("\n=== LÖSUNG ===")
print("1. Gehen Sie zu: http://127.0.0.1:5000/requests/overview")
print("2. Öffnen Sie die Browser-Konsole (F12)")
print("3. Suchen Sie nach 'Admin-Berechtigungen:' in der Konsole")
print("4. Die Buttons sollten bei Anträgen mit Status 'pending' erscheinen")
except Exception as e:
print(f"❌ Fehler: {e}")
import traceback
traceback.print_exc()

1
backend/app/utils/test_korrekturen.py Normal file
View File

@@ -0,0 +1 @@

175
backend/app/utils/test_p110.py Normal file
View File

@@ -0,0 +1,175 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
P110-TAPO-TEST - Speziell für TP-Link Tapo P110-Steckdosen
Testet verschiedene Versionen des PyP100-Moduls
"""
import sys
import time
import socket
import subprocess
from datetime import datetime
# Anmeldedaten
TAPO_USERNAME = "till.tomczak@mercedes-benz.com"
TAPO_PASSWORD = "744563017196"
# Standard-IP-Adressen zum Testen (anpassen an tatsächliche IPs)
TEST_IPS = [
"192.168.0.103", # Diese IPs waren erreichbar im vorherigen Test
"192.168.0.104"
]
def log(message):
"""Logge eine Nachricht mit Zeitstempel"""
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(f"[{timestamp}] {message}")
def check_connection(ip, port=80, timeout=1):
"""Prüft eine TCP-Verbindung"""
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(timeout)
result = sock.connect_ex((ip, port))
sock.close()
return result == 0
except:
return False
def install_package(package):
"""Installiert ein Python-Paket"""
try:
log(f"Installiere {package}...")
subprocess.run([sys.executable, "-m", "pip", "install", package, "--force-reinstall"], check=True)
log(f"✅ {package} erfolgreich installiert")
return True
except Exception as e:
log(f"❌ Fehler bei Installation von {package}: {e}")
return False
def test_p110_connection():
"""Testet verschiedene Möglichkeiten, um mit P110-Steckdosen zu kommunizieren"""
log("🚀 TAPO P110 TEST - STARTER")
log(f"👤 Benutzername: {TAPO_USERNAME}")
log(f"🔑 Passwort: {TAPO_PASSWORD}")
# Verfügbare Module testen
log("\n1️⃣ SCHRITT 1: Teste verfügbare Module")
try:
from PyP100 import PyP110
log("✅ PyP100 Modul gefunden")
except ImportError:
log("❌ PyP100 Modul nicht gefunden")
install_package("PyP100==0.1.2")
try:
from PyP100 import PyP110
log("✅ PyP100 Modul jetzt installiert")
except ImportError:
log("❌ Konnte PyP100 nicht importieren")
return
# Erreichbare Steckdosen finden
log("\n2️⃣ SCHRITT 2: Suche erreichbare IPs")
available_ips = []
for ip in TEST_IPS:
if check_connection(ip):
log(f"✅ IP {ip} ist erreichbar")
available_ips.append(ip)
else:
log(f"❌ IP {ip} nicht erreichbar")
if not available_ips:
log("❌ Keine erreichbaren IPs gefunden!")
return
# P110-Verbindung testen
log("\n3️⃣ SCHRITT 3: Teste PyP100 Bibliothek")
for ip in available_ips:
try:
log(f"🔄 Verbinde zu Steckdose {ip} mit PyP100.PyP110...")
# Neue Instanz erstellen
from PyP100 import PyP110
p110 = PyP110.P110(ip, TAPO_USERNAME, TAPO_PASSWORD)
# Handshake und Login
log(" Handshake...")
p110.handshake()
log(" Login...")
p110.login()
# Geräteinformationen abrufen
log(" Geräteinformationen abrufen...")
device_info = p110.getDeviceInfo()
# Erfolg!
log(f"✅ ERFOLG! Steckdose {ip} gefunden")
log(f" Name: {device_info.get('nickname', 'Unbekannt')}")
log(f" Status: {'Eingeschaltet' if device_info.get('device_on', False) else 'Ausgeschaltet'}")
# Ein-/Ausschalten testen
if "--toggle" in sys.argv:
current_state = device_info.get('device_on', False)
if current_state:
log(" Schalte AUS...")
p110.turnOff()
else:
log(" Schalte EIN...")
p110.turnOn()
time.sleep(1)
# Status prüfen
device_info = p110.getDeviceInfo()
new_state = device_info.get('device_on', False)
log(f" Neuer Status: {'Eingeschaltet' if new_state else 'Ausgeschaltet'}")
return True
except Exception as e:
log(f"❌ Fehler bei Verbindung zu {ip}: {e}")
# Alternative Bibliothek testen
log("\n4️⃣ SCHRITT 4: Teste PyP100 mit alternativer Version")
if install_package("pytapo==1.1.2"):
try:
import pytapo
from pytapo.tapo import Tapo
for ip in available_ips:
try:
log(f"🔄 Verbinde zu Steckdose {ip} mit pytapo...")
# Neue Verbindung
tapo = Tapo(ip, TAPO_USERNAME, TAPO_PASSWORD)
# Geräteinformationen abrufen
device_info = tapo.get_device_info()
# Erfolg!
log(f"✅ ERFOLG mit pytapo! Steckdose {ip} gefunden")
log(f" Name: {device_info.get('nickname', 'Unbekannt')}")
return True
except Exception as e:
log(f"❌ Fehler bei pytapo-Verbindung zu {ip}: {e}")
except Exception as e:
log(f"❌ Fehler beim Import von pytapo: {e}")
log("\n❌ Keine funktionierenden Tapo-Steckdosen gefunden!")
log("Bitte überprüfen Sie die Anmeldedaten und IP-Adressen")
if __name__ == "__main__":
print("\n======= TAPO P110 TEST =======\n")
test_p110_connection()
print("\n======= TEST BEENDET =======\n")

212
backend/app/utils/test_tapo_direkt.py Normal file
View File

@@ -0,0 +1,212 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
DIREKT-TEST für TP-Link Tapo P110-Steckdosen
Umgeht Ping-Befehle und testet direkte TCP-Verbindung
"""
import sys
import os
import socket
import time
from datetime import datetime
# Anmeldedaten für Tapo-Steckdosen
TAPO_USERNAME = "till.tomczak@mercedes-benz.com"
TAPO_PASSWORD = "744563017196A"
# Standard-IPs für Tapo-Steckdosen
# (falls nicht verfügbar, passen Sie diese an die tatsächlichen IPs in Ihrem Netzwerk an)
TAPO_IPS = [
# Typische IP-Bereiche
"192.168.1.100",
"192.168.1.101",
"192.168.1.102",
"192.168.1.103",
"192.168.1.104",
"192.168.1.105",
"192.168.0.100",
"192.168.0.101",
"192.168.0.102",
"192.168.0.103",
"192.168.0.104",
"192.168.0.105",
# Mercedes-Benz Netzwerk spezifisch
"10.0.0.100",
"10.0.0.101",
"10.0.0.102",
"10.0.0.103",
"10.0.0.104",
"10.0.0.105",
# Zusätzliche mögliche IPs
"192.168.178.100",
"192.168.178.101",
"192.168.178.102",
"192.168.178.103",
"192.168.178.104",
"192.168.178.105",
]
def log_message(message, level="INFO"):
"""Logge eine Nachricht mit Zeitstempel"""
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(f"[{timestamp}] [{level}] {message}")
def check_tcp_connection(host, port=80, timeout=1):
"""
Prüft ob eine TCP-Verbindung zu einem Host und Port möglich ist.
Vermeidet Ping und charmap-Probleme.
Args:
host: Hostname oder IP-Adresse
port: TCP-Port (Standard: 80)
timeout: Timeout in Sekunden
Returns:
bool: True wenn Verbindung erfolgreich
"""
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(timeout)
result = sock.connect_ex((host, port))
sock.close()
return result == 0
except:
return False
def test_tapo_connection():
"""
Testet die Verbindung zu TP-Link Tapo P110-Steckdosen.
"""
log_message("🔄 Überprüfe ob PyP100-Modul installiert ist...")
try:
from PyP100 import PyP110
log_message("✅ PyP100-Modul erfolgreich importiert")
except ImportError:
log_message("❌ PyP100-Modul nicht installiert", "ERROR")
log_message(" Installiere jetzt mit: pip install PyP100==0.1.2")
try:
import subprocess
subprocess.run([sys.executable, "-m", "pip", "install", "PyP100==0.1.2"], check=True)
log_message("✅ PyP100-Modul erfolgreich installiert")
# Erneut importieren
from PyP100 import PyP110
except Exception as e:
log_message(f"❌ Fehler bei Installation von PyP100: {str(e)}", "ERROR")
log_message(" Bitte installieren Sie manuell: pip install PyP100==0.1.2")
return
log_message("🔍 Starte Test für Tapo-Steckdosen...")
log_message(f"🔐 Anmeldedaten: {TAPO_USERNAME} / {TAPO_PASSWORD}")
successful_connections = 0
found_ips = []
for ip in TAPO_IPS:
log_message(f"🔄 Teste IP-Adresse: {ip}")
# TCP-Verbindungstest für Grundkonnektivität (Port 80 für HTTP)
conn_success = check_tcp_connection(ip, port=80)
if not conn_success:
# Alternativ Port 443 testen für HTTPS
conn_success = check_tcp_connection(ip, port=443)
if not conn_success:
log_message(f" ❌ IP {ip} nicht erreichbar (Verbindung fehlgeschlagen)")
continue
log_message(f" ✅ IP {ip} ist erreichbar (TCP-Verbindung erfolgreich)")
# Tapo-Verbindung testen
try:
log_message(f" 🔄 Verbinde zu Tapo-Steckdose {ip}...")
p110 = PyP110.P110(ip, TAPO_USERNAME, TAPO_PASSWORD)
p110.handshake() # Authentifizierung
p110.login() # Login
# Geräteinformationen abrufen
device_info = p110.getDeviceInfo()
# Status abrufen
is_on = device_info.get('device_on', False)
nickname = device_info.get('nickname', "Unbekannt")
log_message(f" ✅ Verbindung zu Tapo-Steckdose '{nickname}' ({ip}) erfolgreich")
log_message(f" 📱 Gerätename: {nickname}")
log_message(f" ⚡ Status: {'Eingeschaltet' if is_on else 'Ausgeschaltet'}")
if 'on_time' in device_info:
on_time = device_info.get('on_time', 0)
hours, minutes = divmod(on_time // 60, 60)
log_message(f" ⏱️ Betriebszeit: {hours}h {minutes}m")
successful_connections += 1
found_ips.append(ip)
# Steckdose testen: EIN/AUS
if len(sys.argv) > 1 and sys.argv[1] == '--toggle':
if is_on:
log_message(f" 🔄 Schalte Steckdose {nickname} AUS...")
p110.turnOff()
log_message(f" ✅ Steckdose ausgeschaltet")
else:
log_message(f" 🔄 Schalte Steckdose {nickname} EIN...")
p110.turnOn()
log_message(f" ✅ Steckdose eingeschaltet")
# Kurze Pause
time.sleep(1)
# Status erneut abrufen
device_info = p110.getDeviceInfo()
is_on = device_info.get('device_on', False)
log_message(f" ⚡ Neuer Status: {'Eingeschaltet' if is_on else 'Ausgeschaltet'}")
except Exception as e:
log_message(f" ❌ Verbindung zu Tapo-Steckdose {ip} fehlgeschlagen: {str(e)}", "ERROR")
# Zusammenfassung
log_message("\n📊 Zusammenfassung:")
log_message(f" Getestete IPs: {len(TAPO_IPS)}")
log_message(f" Gefundene Tapo-Steckdosen: {successful_connections}")
if successful_connections > 0:
log_message("✅ Tapo-Steckdosen erfolgreich gefunden und getestet!")
log_message(f"📝 Gefundene IPs: {found_ips}")
# Ausgabe für Konfiguration
log_message("\n🔧 Konfiguration für settings.py:")
log_message(f"""
# TP-Link Tapo Standard-Anmeldedaten
TAPO_USERNAME = "{TAPO_USERNAME}"
TAPO_PASSWORD = "{TAPO_PASSWORD}"
# Automatische Steckdosen-Erkennung aktivieren
TAPO_AUTO_DISCOVERY = True
# Standard-Steckdosen-IPs
DEFAULT_TAPO_IPS = {found_ips}
""")
else:
log_message("❌ Keine Tapo-Steckdosen gefunden!", "ERROR")
log_message(" Bitte überprüfen Sie die IP-Adressen und Anmeldedaten")
# Fehlerbehebungs-Tipps
log_message("\n🔧 Fehlerbehebungs-Tipps:")
log_message("1. Stellen Sie sicher, dass die Steckdosen mit dem WLAN verbunden sind")
log_message("2. Prüfen Sie die IP-Adressen in der Tapo-App oder im Router")
log_message("3. Stellen Sie sicher, dass die Anmeldedaten korrekt sind")
log_message("4. Prüfen Sie ob die Steckdosen über die Tapo-App erreichbar sind")
log_message("5. Führen Sie einen Neustart der Steckdosen durch (aus- und wieder einstecken)")
if __name__ == "__main__":
print("\n====== TAPO P110 DIREKT-TEST (OHNE PING) ======\n")
test_tapo_connection()
print("\n====== TEST ABGESCHLOSSEN ======\n")

132
backend/app/utils/test_tapo_sofort.py Normal file
View File

@@ -0,0 +1,132 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
SOFORT-TEST für TP-Link Tapo P110-Steckdosen
Nutzt direkt PyP100 mit hardkodierten Anmeldedaten
"""
import os
import sys
import time
from datetime import datetime
# TAPO Anmeldedaten direkt hardkodiert (wie in den funktionierenden Versionen)
os.environ["TAPO_USERNAME"] = "till.tomczak@mercedes-benz.com"
os.environ["TAPO_PASSWORD"] = "744563017196A" # Das 'A' am Ende ist wichtig
# IPs der Steckdosen
TAPO_IPS = [
"192.168.0.103",
"192.168.0.104",
"192.168.0.100",
"192.168.0.101",
"192.168.0.102"
]
def log(msg):
"""Protokolliert eine Nachricht mit Zeitstempel"""
timestamp = datetime.now().strftime("%H:%M:%S")
print(f"[{timestamp}] {msg}")
def test_connection():
"""Teste Verbindung zu den Steckdosen"""
log("🔄 Teste PyP100-Import...")
try:
from PyP100 import PyP100
log("✅ PyP100-Modul erfolgreich importiert")
except ImportError:
log("❌ PyP100-Modul nicht gefunden. Installiere es...")
try:
import subprocess
subprocess.run([sys.executable, "-m", "pip", "install", "PyP100==0.0.12"], check=True)
from PyP100 import PyP100
log("✅ PyP100-Modul installiert")
except Exception as e:
log(f"❌ Fehler bei Installation: {str(e)}")
return False
# Anmeldedaten aus Umgebungsvariablen lesen
username = os.environ.get("TAPO_USERNAME")
password = os.environ.get("TAPO_PASSWORD")
log(f"👤 Benutzername: {username}")
log(f"🔑 Passwort: {password}")
# Teste jede IP
success = False
for ip in TAPO_IPS:
log(f"🔄 Teste Steckdose mit IP: {ip}")
try:
# Wichtig: Verwende PyP100 (nicht PyP110) wie in den funktionierenden Versionen
p100 = PyP100.P100(ip, username, password)
# Handshake und Login
log(" 🔄 Handshake...")
p100.handshake()
log(" 🔄 Login...")
p100.login()
# Status abfragen
log(" 🔄 Status abfragen...")
device_info = p100.getDeviceInfo()
# Erfolg!
state = "Eingeschaltet" if device_info.get("device_on", False) else "Ausgeschaltet"
log(f"✅ ERFOLG! Steckdose {ip} erfolgreich verbunden")
log(f" 📱 Name: {device_info.get('nickname', 'Unbekannt')}")
log(f" ⚡ Status: {state}")
# Steckdose ein-/ausschalten wenn gewünscht
if "--toggle" in sys.argv:
if device_info.get("device_on", False):
log(" 🔄 Schalte Steckdose AUS...")
p100.turnOff()
else:
log(" 🔄 Schalte Steckdose EIN...")
p100.turnOn()
time.sleep(1)
# Neuen Status abrufen
device_info = p100.getDeviceInfo()
state = "Eingeschaltet" if device_info.get("device_on", False) else "Ausgeschaltet"
log(f" ⚡ Neuer Status: {state}")
success = True
# Konfiguration für settings.py ausgeben
log("\n✅ KONFIGURATION FÜR SETTINGS.PY:")
log(f"""
# TP-Link Tapo Standard-Anmeldedaten
TAPO_USERNAME = "{username}"
TAPO_PASSWORD = "{password}"
# Standard-Steckdosen-IPs
DEFAULT_TAPO_IPS = ["{ip}"]
""")
# Nur die erste erfolgreiche Steckdose testen
break
except Exception as e:
log(f"❌ Fehler bei Steckdose {ip}: {str(e)}")
if not success:
log("\n❌ Keine Tapo-Steckdose konnte verbunden werden!")
log("Prüfen Sie folgende mögliche Ursachen:")
log("1. Steckdosen sind nicht eingesteckt oder mit dem WLAN verbunden")
log("2. IP-Adressen sind falsch")
log("3. Anmeldedaten sind falsch (prüfen Sie das 'A' am Ende des Passworts)")
log("4. Netzwerkprobleme verhindern den Zugriff")
return success
if __name__ == "__main__":
print("\n====== TAPO P110 SOFORT-TEST ======\n")
test_connection()
print("\n====== TEST BEENDET ======\n")