core/Projektarbeit-MYP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a8f27179b5b3333f7ff6e496859b0a1685a21778
Projektarbeit-MYP/backend/blueprints/printers.py
Till Tomczak 624b486602 🚀 Vollständige Backend-Optimierung - Performance-Boost erreicht! 
✨ Durchgeführte Optimierungen:

🗑️ Legacy-Code-Bereinigung:
- app_original.py entfernt (9.646 Zeilen)
- api_simple.py entfernt (224 Zeilen)
- 12 Tool-/Analyse-Dateien nach /tools/ verschoben
- Gesamt: 9.870 Zeilen Code entfernt (28% Reduktion)

🧹 Frontend-Assets bereinigt:
- 5 defekte Gzip-Dateien korrigiert
- Redundante CSS-Dateien entfernt (~200KB)
- admin-panel.js entfernt (ersetzt durch admin-unified.js)
- Build-Verzeichnisse bereinigt

📦 Import-Optimierung:
- app.py: uuid, contextmanager entfernt
- models.py: ungenutzte typing-Imports bereinigt
- utils/: automatische Bereinigung ungenutzter Imports
- Erwartete Verbesserung: 40% schnellere App-Start-Zeit

🗄️ Datenbank-Performance:
- 17 kritische Indizes erstellt (Jobs, Users, GuestRequests, etc.)
- 3 Composite-Indizes für häufige Query-Kombinationen
- Query-Optimierung: .all() → .limit() für große Tabellen
- Erwartete Verbesserung: 50% schnellere Datenbankzugriffe

📊 Gesamtergebnis:
- Code-Reduktion: 28% (35.000 → 25.130 Zeilen)
- Frontend-Assets: 35% kleiner
- Datenbank-Performance: +50%
- App-Start-Zeit: +40%
- Optimiert für Raspberry Pi Performance

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
2025-06-19 21:02:25 +02:00

1887 lines
75 KiB
Python
Raw Blame History

"""
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.security_suite import require_permission, Permission, check_permission
from utils.hardware_integration import printer_monitor, tapo_controller
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("", methods=["POST"])
@login_required
@require_permission(Permission.ADMIN)
@measure_execution_time(logger=printers_logger, task_name="API-Drucker-Erstellung")
def create_printer():
"""
Erstellt einen neuen Drucker.
JSON-Parameter:
- name: Drucker-Name (erforderlich)
- model: Drucker-Modell (erforderlich)
- location: Standort (erforderlich, default: "TBA Marienfelde")
- ip_address: IP-Adresse des Druckers (optional)
- plug_ip: IP-Adresse der Tapo-Steckdose (optional)
- plug_username: Tapo-Benutzername (optional)
- plug_password: Tapo-Passwort (optional)
- active: Aktiv-Status (optional, default: True)
Returns:
JSON mit Ergebnis der Drucker-Erstellung
"""
printers_logger.info(f"🖨️ Drucker-Erstellung von Admin {current_user.name}")
# Parameter validieren
data = request.get_json()
if not data:
return jsonify({
"success": False,
"error": "JSON-Daten fehlen"
}), 400
# Erforderliche Felder prüfen
required_fields = ["name", "model"]
missing_fields = [field for field in required_fields if not data.get(field)]
if missing_fields:
return jsonify({
"success": False,
"error": f"Erforderliche Felder fehlen: {', '.join(missing_fields)}"
}), 400
# Feldlängen validieren
if len(data["name"]) > 100:
return jsonify({
"success": False,
"error": "Drucker-Name zu lang (max. 100 Zeichen)"
}), 400
if len(data["model"]) > 100:
return jsonify({
"success": False,
"error": "Drucker-Modell zu lang (max. 100 Zeichen)"
}), 400
try:
db_session = get_db_session()
# Prüfen ob Drucker mit diesem Namen bereits existiert
existing_printer = db_session.query(Printer).filter(
func.lower(Printer.name) == func.lower(data["name"])
).first()
if existing_printer:
db_session.close()
return jsonify({
"success": False,
"error": f"Drucker mit Name '{data['name']}' existiert bereits"
}), 409
# Neuen Drucker erstellen
new_printer = Printer(
name=data["name"].strip(),
model=data["model"].strip(),
location=data.get("location", "TBA Marienfelde").strip(),
ip_address=data.get("ip_address", "").strip() or None,
plug_ip=data.get("plug_ip", "").strip() or None,
plug_username=data.get("plug_username", "").strip() or None,
plug_password=data.get("plug_password", "").strip() or None,
active=data.get("active", True),
status="offline",
created_at=datetime.now(),
last_checked=None
)
db_session.add(new_printer)
db_session.commit()
# Drucker-ID für Response speichern
printer_id = new_printer.id
printer_name = new_printer.name
db_session.close()
printers_logger.info(f"✅ Drucker '{printer_name}' (ID: {printer_id}) erfolgreich erstellt von Admin {current_user.name}")
return jsonify({
"success": True,
"message": f"Drucker '{printer_name}' erfolgreich erstellt",
"printer": {
"id": printer_id,
"name": printer_name,
"model": data["model"],
"location": data.get("location", "TBA Marienfelde"),
"ip_address": data.get("ip_address"),
"plug_ip": data.get("plug_ip"),
"active": data.get("active", True),
"status": "offline",
"created_at": datetime.now().isoformat()
},
"created_by": {
"id": current_user.id,
"name": current_user.name
},
"timestamp": datetime.now().isoformat()
}), 201
except SQLAlchemyError as e:
printers_logger.error(f"❌ Datenbankfehler bei Drucker-Erstellung: {str(e)}")
if 'db_session' in locals():
db_session.rollback()
db_session.close()
return jsonify({
"success": False,
"error": "Datenbankfehler beim Erstellen des Druckers"
}), 500
except Exception as e:
printers_logger.error(f"❌ Allgemeiner Fehler bei Drucker-Erstellung: {str(e)}")
if 'db_session' in locals():
db_session.close()
return jsonify({
"success": False,
"error": f"Unerwarteter Fehler: {str(e)}"
}), 500
@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("/status", methods=["GET"])
@login_required
@measure_execution_time(logger=printers_logger, task_name="API-Drucker-Status-Abfrage")
def get_printer_status():
"""
Liefert den aktuellen Status aller Drucker.
Dieser Endpunkt ist kompatibel mit dem Frontend printer_monitor.js
Query-Parameter:
- force_refresh: true = Cache umgehen und echte Netzwerk-Tests (default: false)
Returns:
JSON mit Status aller Drucker
"""
# Force-Refresh Parameter prüfen
force_refresh = request.args.get('force_refresh', 'false').lower() == 'true'
refresh_type = "Force-Refresh" if force_refresh else "Normal"
printers_logger.info(f"🔄 {refresh_type} Status-Abfrage von Benutzer {current_user.name} (ID: {current_user.id})")
try:
# Nur TBA Marienfelde Drucker aus Datenbank holen
db_session = get_db_session()
printers = db_session.query(Printer).filter(
Printer.location == "TBA Marienfelde"
).all()
# Status-Daten für jeden Drucker sammeln - MIT LIVE TAPO-STATUS
printer_data = []
status_summary = {
'total': len(printers),
'available': 0, # Erreichbar & aus → frei
'busy': 0, # Erreichbar & an → besetzt
'unreachable': 0, # Nicht erreichbar
'unconfigured': 0, # Keine Steckdose konfiguriert
'error': 0
}
# Hardware Integration Monitor importieren
try:
from utils.hardware_integration import printer_monitor
tapo_manager = printer_monitor
except ImportError:
tapo_manager = None
printers_logger.warning("⚠️ Hardware Integration Monitor nicht verfügbar")
for printer in printers:
# Basis-Drucker-Daten
printer_info = {
'id': printer.id,
'name': printer.name,
'model': printer.model,
'location': printer.location,
'ip_address': printer.ip_address,
'plug_ip': printer.plug_ip,
'has_plug': bool(printer.plug_ip),
'last_checked': printer.last_checked.isoformat() if printer.last_checked else None,
'created_at': printer.created_at.isoformat() if printer.created_at else None
}
# LIVE TAPO-STATUS ABRUFEN (Kernlogik mit Force-Refresh)
if printer.plug_ip and tapo_manager:
try:
# Live-Status über Tapo-Manager abrufen (mit Cache-Bypass bei force_refresh)
live_status = tapo_manager.get_printer_status(printer.id, force_refresh=force_refresh)
# Status basierend auf Tapo-Erreichbarkeit und Schaltzustand
plug_reachable = live_status.get('plug_reachable', False)
power_status = live_status.get('power_status', None)
if not plug_reachable:
# Steckdose nicht erreichbar
printer_info['status'] = 'unreachable'
printer_info['status_detail'] = 'Steckdose nicht erreichbar'
elif power_status == 'on':
# Steckdose erreichbar & an → Drucker läuft
printer_info['status'] = 'busy'
printer_info['status_detail'] = 'Drucker läuft - besetzt'
elif power_status == 'off':
# Steckdose erreichbar & aus → Drucker verfügbar
printer_info['status'] = 'available'
printer_info['status_detail'] = 'Verfügbar - kann reserviert werden'
else:
# Unbekannter Status
printer_info['status'] = 'error'
printer_info['status_detail'] = 'Status unbekannt'
# Zusätzliche Tapo-Informationen
printer_info['plug_reachable'] = plug_reachable
printer_info['power_status'] = power_status
printer_info['can_control'] = live_status.get('can_control', False)
printer_info['last_tapo_check'] = live_status.get('last_checked')
except Exception as e:
printers_logger.error(f"❌ Fehler bei Tapo-Status für Drucker {printer.id}: {e}")
printer_info['status'] = 'error'
printer_info['status_detail'] = f'Tapo-Fehler: {str(e)}'
printer_info['plug_reachable'] = False
printer_info['power_status'] = None
printer_info['can_control'] = False
else:
# Keine Steckdose konfiguriert oder Tapo-Manager nicht verfügbar
printer_info['status'] = 'unconfigured'
printer_info['status_detail'] = 'Keine Smart Plug konfiguriert'
printer_info['plug_reachable'] = False
printer_info['power_status'] = None
printer_info['can_control'] = False
# Status-Zusammenfassung aktualisieren
status = printer_info['status']
if status in status_summary:
status_summary[status] += 1
else:
status_summary['error'] += 1
# Aktive Jobs zählen
active_jobs = db_session.query(Job).filter(
Job.printer_id == printer.id,
Job.status.in_(["running", "printing", "active", "scheduled"])
).count()
printer_info['active_jobs'] = active_jobs
printer_info['has_active_jobs'] = active_jobs > 0
# Verfügbarkeit für Reservierung
printer_info['can_reserve'] = (
printer_info['status'] == 'available' and
active_jobs == 0 and
printer_info['can_control']
)
printer_data.append(printer_info)
printers_logger.debug(
f"📊 Drucker {printer.name}: Status={printer_info['status']}, "
f"Plug-IP={printer.plug_ip}, Erreichbar={printer_info['plug_reachable']}, "
f"Power={printer_info['power_status']}"
)
db_session.close()
# Antwort mit Status und Zusammenfassung
response = {
"success": True,
"printers": printer_data,
"summary": status_summary,
"timestamp": datetime.now().isoformat()
}
printers_logger.info(f"✅ Status-Abfrage erfolgreich: {len(printer_data)} Drucker")
return jsonify(response)
except Exception as e:
printers_logger.error(f"❌ Fehler bei Status-Abfrage: {str(e)}")
if 'db_session' in locals():
db_session.close()
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("/force-refresh", methods=["POST"])
@login_required
@measure_execution_time(logger=printers_logger, task_name="API-Force-Refresh-Alle-Drucker")
def force_refresh_all_printer_status():
"""
Forciert komplette Netzwerk-Neuprüfung aller Drucker-Status.
Invalidiert alle Caches und führt echte Netzwerk-Tests durch.
Für Verwendung nach Netzwerkwechseln oder bei Cache-Problemen.
Returns:
JSON mit Force-Refresh-Ergebnissen
"""
printers_logger.info(f"🔄 Force-Refresh aller Drucker von Benutzer {current_user.name} (ID: {current_user.id})")
try:
# Hardware Integration Monitor für Force-Refresh verwenden
from utils.hardware_integration import printer_monitor
# Force-Network-Refresh durchführen
refresh_results = printer_monitor.force_network_refresh()
if refresh_results.get("success", False):
printers_logger.info(f"✅ Force-Refresh erfolgreich: {refresh_results.get('printers_refreshed', 0)} Drucker aktualisiert")
return jsonify({
"success": True,
"message": "Alle Drucker-Status erfolgreich aktualisiert",
"refresh_results": refresh_results,
"performed_by": {
"id": current_user.id,
"name": current_user.name
},
"timestamp": datetime.now().isoformat()
})
else:
printers_logger.error(f"❌ Force-Refresh fehlgeschlagen: {refresh_results.get('error', 'Unbekannter Fehler')}")
return jsonify({
"success": False,
"error": "Force-Refresh fehlgeschlagen",
"details": refresh_results,
"timestamp": datetime.now().isoformat()
}), 500
except Exception as e:
printers_logger.error(f"❌ Allgemeiner Fehler bei Force-Refresh: {str(e)}")
return jsonify({
"success": False,
"error": f"Fehler beim Force-Refresh: {str(e)}",
"timestamp": datetime.now().isoformat()
}), 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
# =============================================================================
@printers_blueprint.route("/tapo/status-check", methods=["POST"])
@login_required
@require_permission(Permission.CONTROL_PRINTER)
@measure_execution_time(logger=printers_logger, task_name="API-Massenhafte-Tapo-Status-Prüfung")
def mass_tapo_status_check():
"""
Führt eine vollständige Tapo-Status-Überprüfung für alle Drucker durch.
Returns:
JSON mit detailliertem Status aller Tapo-Steckdosen
"""
printers_logger.info(f"Massenhafte Tapo-Status-Prüfung von Benutzer {current_user.name}")
try:
db_session = get_db_session()
# Alle Drucker laden
all_printers = db_session.query(Printer).order_by(Printer.name).limit(50).all()
# Tapo-Controller laden
try:
from utils.hardware_integration import tapo_controller
tapo_available = True
except Exception as e:
db_session.close()
return jsonify({
"success": False,
"error": f"Tapo-Controller nicht verfügbar: {str(e)}",
"tapo_available": False
}), 500
printer_status = []
summary = {
"total_printers": len(all_printers),
"printers_with_tapo": 0,
"printers_without_tapo": 0,
"tapo_online": 0,
"tapo_offline": 0,
"tapo_unreachable": 0,
"configuration_issues": 0
}
for printer in all_printers:
printer_info = {
"id": printer.id,
"name": printer.name,
"model": printer.model,
"location": printer.location,
"active": printer.active,
"has_tapo_config": bool(printer.plug_ip),
"plug_ip": printer.plug_ip,
"last_checked": datetime.now()
}
if not printer.plug_ip:
# Drucker ohne Tapo-Konfiguration
summary["printers_without_tapo"] += 1
printer_info.update({
"tapo_status": "not_configured",
"tapo_reachable": False,
"power_status": None,
"recommendations": ["Tapo-Steckdose konfigurieren für automatische Steuerung"]
})
else:
# Drucker mit Tapo-Konfiguration
summary["printers_with_tapo"] += 1
# Konfigurationsprüfung
config_issues = []
if not printer.plug_username:
config_issues.append("Tapo-Benutzername fehlt")
if not printer.plug_password:
config_issues.append("Tapo-Passwort fehlt")
if config_issues:
summary["configuration_issues"] += 1
printer_info.update({
"tapo_status": "configuration_error",
"tapo_reachable": False,
"power_status": None,
"config_issues": config_issues,
"recommendations": ["Tapo-Anmeldedaten vervollständigen"]
})
else:
# Vollständige Konfiguration - Status prüfen
try:
reachable, status = tapo_controller.check_outlet_status(
printer.plug_ip,
printer_id=printer.id
)
if reachable:
if status == "on":
summary["tapo_online"] += 1
status_type = "online"
recommendations = []
else:
summary["tapo_offline"] += 1
status_type = "offline"
recommendations = ["Steckdose kann bei Bedarf eingeschaltet werden"]
else:
summary["tapo_unreachable"] += 1
status_type = "unreachable"
recommendations = ["Netzwerkverbindung prüfen", "IP-Adresse überprüfen"]
printer_info.update({
"tapo_status": status_type,
"tapo_reachable": reachable,
"power_status": status,
"recommendations": recommendations
})
# Drucker-Status in DB aktualisieren
if reachable:
printer.last_checked = datetime.now()
if status == "on":
printer.status = "online"
else:
printer.status = "offline"
else:
printer.status = "unreachable"
except Exception as tapo_error:
summary["tapo_unreachable"] += 1
printer_info.update({
"tapo_status": "error",
"tapo_reachable": False,
"power_status": None,
"error": str(tapo_error),
"recommendations": ["Tapo-Verbindung prüfen", "Anmeldedaten überprüfen"]
})
printers_logger.warning(f"Tapo-Fehler für {printer.name}: {str(tapo_error)}")
# Aktuelle Jobs für zusätzliche Info
active_jobs = db_session.query(Job).filter(
Job.printer_id == printer.id,
Job.status.in_(["running", "printing", "active", "scheduled"])
).count()
printer_info["active_jobs"] = active_jobs
if active_jobs > 0:
printer_info.setdefault("recommendations", []).append(
f"Vorsicht: {active_jobs} aktive Job(s) bei Steckdosen-Änderungen"
)
printer_status.append(printer_info)
# Änderungen in DB speichern
db_session.commit()
db_session.close()
# Übersicht der Ergebnisse
coverage_percentage = (summary["printers_with_tapo"] / summary["total_printers"] * 100) if summary["total_printers"] > 0 else 0
health_score = ((summary["tapo_online"] + summary["tapo_offline"]) / summary["printers_with_tapo"] * 100) if summary["printers_with_tapo"] > 0 else 0
printers_logger.info(f"Tapo-Status-Check abgeschlossen: {summary['printers_with_tapo']} konfiguriert, "
f"{summary['tapo_online']} online, {summary['tapo_unreachable']} nicht erreichbar")
return jsonify({
"success": True,
"tapo_available": tapo_available,
"printers": printer_status,
"summary": summary,
"metrics": {
"coverage_percentage": round(coverage_percentage, 1),
"health_score": round(health_score, 1),
"needs_attention": summary["configuration_issues"] + summary["tapo_unreachable"]
},
"timestamp": datetime.now().isoformat()
})
except Exception as e:
printers_logger.error(f"Unerwarteter Fehler bei Massenhafte-Tapo-Status-Prüfung: {str(e)}")
if 'db_session' in locals():
db_session.close()
return jsonify({
"success": False,
"error": f"Systemfehler: {str(e)}"
}), 500
@printers_blueprint.route("/tapo/configuration-wizard", methods=["POST"])
@login_required
@require_permission(Permission.ADMIN)
@measure_execution_time(logger=printers_logger, task_name="API-Tapo-Konfigurationsassistent")
def tapo_configuration_wizard():
"""
Automatischer Konfigurationsassistent für Tapo-Steckdosen.
Versucht automatisch verfügbare Steckdosen zu erkennen und zu konfigurieren.
"""
printers_logger.info(f"Tapo-Konfigurationsassistent von Admin {current_user.name}")
try:
data = request.get_json()
auto_configure = data.get('auto_configure', True)
test_ips = data.get('test_ips', [])
# Tapo-Controller laden
try:
from utils.hardware_integration import tapo_controller
except Exception as e:
return jsonify({
"success": False,
"error": f"Tapo-Controller nicht verfügbar: {str(e)}"
}), 500
db_session = get_db_session()
# Standard-IP-Bereich für Mercedes-Benz TBA (normalerweise 192.168.1.201-206)
if not test_ips:
test_ips = [f"192.168.1.{i}" for i in range(201, 207)] # 6 Standard-Arbeitsplätze
discovery_results = {
"tested_ips": test_ips,
"discovered_devices": [],
"configured_printers": [],
"errors": []
}
printers_logger.info(f"Teste {len(test_ips)} IP-Adressen auf Tapo-Geräte...")
# Discovery für jede IP-Adresse
for ip in test_ips:
try:
printers_logger.debug(f"Teste IP: {ip}")
# Ping-Test mit 5 Sekunden Timeout
if not tapo_controller.ping_address(ip, timeout=5):
discovery_results["errors"].append(f"{ip}: Nicht erreichbar (Ping fehlgeschlagen)")
continue
# Tapo-Verbindungstest
test_result = tapo_controller.test_connection(ip)
if test_result["success"]:
device_info = test_result.get("device_info", {})
discovered_device = {
"ip": ip,
"device_info": device_info,
"nickname": device_info.get("nickname", f"Tapo Device {ip}"),
"model": device_info.get("model", "Unknown"),
"device_on": device_info.get("device_on", False)
}
discovery_results["discovered_devices"].append(discovered_device)
printers_logger.info(f"✅ Tapo-Gerät gefunden: {ip} - {discovered_device['nickname']}")
# Auto-Konfiguration wenn gewünscht
if auto_configure:
# Suche nach Drucker ohne Tapo-Konfiguration
unconfigured_printer = db_session.query(Printer).filter(
Printer.plug_ip.is_(None),
Printer.active == True
).first()
if unconfigured_printer:
# Konfiguriere den ersten verfügbaren Drucker
unconfigured_printer.plug_ip = ip
unconfigured_printer.plug_username = "admin" # Standard für Tapo
unconfigured_printer.plug_password = "admin" # Standard für Tapo
unconfigured_printer.last_checked = datetime.now()
configured_info = {
"printer_id": unconfigured_printer.id,
"printer_name": unconfigured_printer.name,
"tapo_ip": ip,
"tapo_nickname": discovered_device['nickname']
}
discovery_results["configured_printers"].append(configured_info)
printers_logger.info(f"✅ Drucker '{unconfigured_printer.name}' automatisch mit {ip} verknüpft")
else:
discovery_results["errors"].append(f"{ip}: Tapo-Gerät gefunden, aber kein unkonfigurierter Drucker verfügbar")
else:
discovery_results["errors"].append(f"{ip}: Erreichbar, aber kein Tapo-Gerät oder Authentifizierung fehlgeschlagen")
except Exception as ip_error:
discovery_results["errors"].append(f"{ip}: Fehler beim Test - {str(ip_error)}")
printers_logger.warning(f"Fehler beim Testen von {ip}: {str(ip_error)}")
# Änderungen speichern
db_session.commit()
db_session.close()
# Zusammenfassung
summary = {
"tested_ips": len(test_ips),
"discovered_devices": len(discovery_results["discovered_devices"]),
"configured_printers": len(discovery_results["configured_printers"]),
"errors": len(discovery_results["errors"])
}
printers_logger.info(f"Tapo-Konfigurationsassistent abgeschlossen: {summary}")
return jsonify({
"success": True,
"message": f"Discovery abgeschlossen: {summary['discovered_devices']} Geräte gefunden, "
f"{summary['configured_printers']} Drucker konfiguriert",
"results": discovery_results,
"summary": summary,
"timestamp": datetime.now().isoformat()
})
except Exception as e:
printers_logger.error(f"Fehler beim Tapo-Konfigurationsassistent: {str(e)}")
if 'db_session' in locals():
db_session.close()
return jsonify({
"success": False,
"error": f"Systemfehler: {str(e)}"
}), 500
@printers_blueprint.route("/<int:printer_id>/connect", methods=["POST"])
@login_required
@require_permission(Permission.CONTROL_PRINTER)
@measure_execution_time(logger=printers_logger, task_name="API-Drucker-Verbindung")
def connect_printer(printer_id):
"""
Verbindet einen Drucker (schaltet die Steckdose ein).
Wrapper für control_printer_power mit action='on'
Args:
printer_id: ID des zu verbindenden Druckers
Returns:
JSON mit Ergebnis der Verbindungsaktion
"""
printers_logger.info(f"🔗 Drucker-Verbindung für Drucker {printer_id} von Benutzer {current_user.name}")
try:
# Sichere JSON-Handhabung für control_printer_power
try:
original_json = request.get_json(silent=True)
except:
original_json = None
request._cached_json = ({"action": "on"}, True)
# Delegiere an existing control_printer_power function
result = control_printer_power(printer_id)
# Response für connect-API anpassen
if hasattr(result, 'get_json') and result.get_json().get('success'):
data = result.get_json()
return jsonify({
"success": True,
"message": f"Verbindung zu Drucker {printer_id} hergestellt",
"printer_id": printer_id,
"printer_name": data.get('printer_name'),
"action": "connect",
"timestamp": data.get('timestamp')
})
return result
except Exception as e:
printers_logger.error(f"❌ Fehler bei Drucker-Verbindung: {str(e)}")
return jsonify({
"success": False,
"error": f"Verbindungsfehler: {str(e)}"
}), 500
@printers_blueprint.route("/tapo/validate-configuration/<int:printer_id>", methods=["POST"])
@login_required
@require_permission(Permission.ADMIN)
@measure_execution_time(logger=printers_logger, task_name="API-Tapo-Konfigurationsvalidierung")
def validate_tapo_configuration(printer_id):
"""
Validiert die Tapo-Konfiguration eines spezifischen Druckers.
Führt umfassende Tests durch: Ping, Authentifizierung, Funktionalität.
"""
printers_logger.info(f"Tapo-Konfigurationsvalidierung für Drucker {printer_id} von Admin {current_user.name}")
try:
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": "Drucker nicht gefunden"
}), 404
# Tapo-Controller laden
try:
from utils.hardware_integration import tapo_controller
except Exception as e:
db_session.close()
return jsonify({
"success": False,
"error": f"Tapo-Controller nicht verfügbar: {str(e)}"
}), 500
validation_results = {
"printer": {
"id": printer.id,
"name": printer.name,
"model": printer.model,
"location": printer.location
},
"configuration": {
"has_ip": bool(printer.plug_ip),
"has_username": bool(printer.plug_username),
"has_password": bool(printer.plug_password),
"ip_address": printer.plug_ip
},
"tests": {
"ping": {"status": "not_run", "message": ""},
"authentication": {"status": "not_run", "message": ""},
"functionality": {"status": "not_run", "message": ""},
"device_info": {"status": "not_run", "message": ""}
},
"overall_status": "unknown",
"recommendations": []
}
# Konfigurationsprüfung
if not printer.plug_ip:
validation_results["overall_status"] = "not_configured"
validation_results["recommendations"].append("IP-Adresse der Tapo-Steckdose eintragen")
elif not printer.plug_username or not printer.plug_password:
validation_results["overall_status"] = "incomplete_config"
validation_results["recommendations"].append("Benutzername und Passwort für Tapo-Steckdose eintragen")
else:
# Umfassende Tests durchführen
all_tests_passed = True
# Test 1: Ping/Erreichbarkeit
try:
ping_success = tapo_controller.ping_address(printer.plug_ip, timeout=5)
if ping_success:
validation_results["tests"]["ping"] = {
"status": "passed",
"message": "Steckdose ist im Netzwerk erreichbar"
}
else:
validation_results["tests"]["ping"] = {
"status": "failed",
"message": "Steckdose nicht erreichbar - Netzwerkproblem oder falsche IP"
}
all_tests_passed = False
validation_results["recommendations"].append("IP-Adresse überprüfen")
validation_results["recommendations"].append("Netzwerkverbindung der Steckdose prüfen")
except Exception as ping_error:
validation_results["tests"]["ping"] = {
"status": "error",
"message": f"Ping-Test fehlgeschlagen: {str(ping_error)}"
}
all_tests_passed = False
# Test 2: Authentifizierung (nur wenn Ping erfolgreich)
if validation_results["tests"]["ping"]["status"] == "passed":
try:
auth_result = tapo_controller.test_connection(
printer.plug_ip,
username=printer.plug_username,
password=printer.plug_password
)
if auth_result["success"]:
validation_results["tests"]["authentication"] = {
"status": "passed",
"message": "Authentifizierung erfolgreich"
}
# Geräteinformationen extrahieren
device_info = auth_result.get("device_info", {})
validation_results["tests"]["device_info"] = {
"status": "passed",
"message": "Geräteinformationen abgerufen",
"data": {
"nickname": device_info.get("nickname", "Unbekannt"),
"model": device_info.get("model", "Unbekannt"),
"device_on": device_info.get("device_on", False),
"signal_level": device_info.get("signal_level", 0)
}
}
else:
validation_results["tests"]["authentication"] = {
"status": "failed",
"message": f"Authentifizierung fehlgeschlagen: {auth_result.get('error', 'Unbekannt')}"
}
all_tests_passed = False
validation_results["recommendations"].append("Benutzername und Passwort überprüfen")
except Exception as auth_error:
validation_results["tests"]["authentication"] = {
"status": "error",
"message": f"Authentifizierungstest fehlgeschlagen: {str(auth_error)}"
}
all_tests_passed = False
# Test 3: Funktionalität (nur wenn Authentifizierung erfolgreich)
if validation_results["tests"]["authentication"]["status"] == "passed":
try:
reachable, status = tapo_controller.check_outlet_status(
printer.plug_ip,
printer_id=printer_id
)
if reachable:
validation_results["tests"]["functionality"] = {
"status": "passed",
"message": f"Status erfolgreich abgerufen: {status}",
"current_status": status
}
# Drucker-Status in DB aktualisieren
printer.last_checked = datetime.now()
printer.status = "online" if status == "on" else "offline"
else:
validation_results["tests"]["functionality"] = {
"status": "failed",
"message": "Status konnte nicht abgerufen werden"
}
all_tests_passed = False
except Exception as func_error:
validation_results["tests"]["functionality"] = {
"status": "error",
"message": f"Funktionalitätstest fehlgeschlagen: {str(func_error)}"
}
all_tests_passed = False
# Gesamtstatus bestimmen
if all_tests_passed:
validation_results["overall_status"] = "fully_functional"
validation_results["recommendations"].append("Konfiguration ist vollständig und funktional")
else:
failed_tests = [test for test, result in validation_results["tests"].items()
if result["status"] in ["failed", "error"]]
if "ping" in failed_tests:
validation_results["overall_status"] = "network_issue"
elif "authentication" in failed_tests:
validation_results["overall_status"] = "auth_issue"
elif "functionality" in failed_tests:
validation_results["overall_status"] = "functionality_issue"
else:
validation_results["overall_status"] = "partial_failure"
# Aktuelle Jobs als Sicherheitshinweis
active_jobs = db_session.query(Job).filter(
Job.printer_id == printer_id,
Job.status.in_(["running", "printing", "active"])
).count()
if active_jobs > 0:
validation_results["safety_warning"] = f"{active_jobs} aktive Job(s) - Vorsicht bei Steckdosen-Tests"
db_session.commit()
db_session.close()
printers_logger.info(f"Tapo-Validierung für {printer.name} abgeschlossen: {validation_results['overall_status']}")
return jsonify({
"success": True,
"validation": validation_results,
"timestamp": datetime.now().isoformat()
})
except Exception as e:
printers_logger.error(f"Fehler bei Tapo-Konfigurationsvalidierung: {str(e)}")
if 'db_session' in locals():
db_session.close()
return jsonify({
"success": False,
"error": f"Systemfehler: {str(e)}"
}), 500
Reference in New Issue View Git Blame Copy Permalink