"Refactor calendar blueprint and test printer creation"

backend/app/blueprints/calendar.py

@@ -2,7 +2,7 @@ import json
 from datetime import datetime, timedelta
 from flask import Blueprint, render_template, request, jsonify, redirect, url_for, abort
 from flask_login import current_user, login_required
-from sqlalchemy import and_, or_
+from sqlalchemy import and_, or_, func
 
 from models import Job, Printer, User, UserPermission, get_cached_session
 from utils.logging_config import get_logger
@@ -21,6 +21,125 @@ def can_edit_events(user):
             return False
         return permission.can_approve_jobs
 
+def get_smart_printer_assignment(start_date, end_date, priority="normal", db_session=None):
+    """
+    Intelligente Druckerzuweisung basierend auf verschiedenen Faktoren.
+    
+    Args:
+        start_date: Startzeit des Jobs
+        end_date: Endzeit des Jobs  
+        priority: Prioritätsstufe ('urgent', 'high', 'normal', 'low')
+        db_session: Datenbankverbindung
+        
+    Returns:
+        printer_id: ID des empfohlenen Druckers oder None
+    """
+    if not db_session:
+        return None
+        
+    try:
+        # Verfügbare Drucker ermitteln
+        available_printers = db_session.query(Printer).filter(
+            Printer.active == True
+        ).all()
+        
+        if not available_printers:
+            logger.warning("Keine aktiven Drucker für automatische Zuweisung gefunden")
+            return None
+        
+        printer_scores = []
+        
+        for printer in available_printers:
+            score = 0
+            
+            # 1. Verfügbarkeit prüfen - Jobs im gleichen Zeitraum
+            conflicting_jobs = db_session.query(Job).filter(
+                Job.printer_id == printer.id,
+                Job.status.in_(["scheduled", "running"]),
+                or_(
+                    and_(Job.start_at >= start_date, Job.start_at < end_date),
+                    and_(Job.end_at > start_date, Job.end_at <= end_date),
+                    and_(Job.start_at <= start_date, Job.end_at >= end_date)
+                )
+            ).count()
+            
+            if conflicting_jobs > 0:
+                continue  # Drucker ist nicht verfügbar
+            
+            score += 100  # Grundpunkte für Verfügbarkeit
+            
+            # 2. Auslastung in den letzten 24 Stunden bewerten
+            last_24h = datetime.now() - timedelta(hours=24)
+            recent_jobs = db_session.query(Job).filter(
+                Job.printer_id == printer.id,
+                Job.start_at >= last_24h,
+                Job.status.in_(["scheduled", "running", "finished"])
+            ).count()
+            
+            # Weniger Auslastung = höhere Punktzahl
+            score += max(0, 50 - (recent_jobs * 10))
+            
+            # 3. Prioritätsbasierte Zuweisung
+            if priority == "urgent":
+                # Für dringende Jobs: Express-Drucker bevorzugen
+                if "express" in printer.name.lower() or "schnell" in printer.name.lower():
+                    score += 30
+            elif priority == "high":
+                # Für hohe Priorität: Weniger belastete Drucker
+                if recent_jobs <= 2:
+                    score += 20
+            
+            # 4. Zeitfenster-basierte Zuweisung
+            start_hour = start_date.hour
+            if start_hour >= 18 or start_hour <= 6:  # Nachtschicht
+                if "nacht" in printer.name.lower() or printer.location and "c" in printer.location.lower():
+                    score += 25
+            elif start_hour >= 8 and start_hour <= 17:  # Tagschicht
+                if "tag" in printer.name.lower() or printer.location and "a" in printer.location.lower():
+                    score += 15
+            
+            # 5. Standort-basierte Bewertung (Round-Robin ähnlich)
+            if printer.location:
+                location_penalty = hash(printer.location) % 10  # Verteilung basierend auf Standort
+                score += location_penalty
+            
+            # 6. Druckerdauer-Eignung
+            job_duration_hours = (end_date - start_date).total_seconds() / 3600
+            if job_duration_hours > 8:  # Lange Jobs
+                if "langzeit" in printer.name.lower() or "marathon" in printer.name.lower():
+                    score += 20
+            elif job_duration_hours <= 2:  # Kurze Jobs
+                if "express" in printer.name.lower() or "schnell" in printer.name.lower():
+                    score += 15
+            
+            # 7. Wartungszyklen berücksichtigen
+            # Neuere Drucker (falls last_maintenance_date verfügbar) bevorzugen
+            # TODO: Implementierung abhängig von Printer-Model-Erweiterungen
+            
+            printer_scores.append({
+                'printer': printer,
+                'score': score,
+                'conflicts': conflicting_jobs,
+                'recent_load': recent_jobs
+            })
+        
+        # Nach Punktzahl sortieren und besten Drucker auswählen
+        if not printer_scores:
+            logger.warning("Keine verfügbaren Drucker für den gewünschten Zeitraum gefunden")
+            return None
+        
+        printer_scores.sort(key=lambda x: x['score'], reverse=True)
+        best_printer = printer_scores[0]
+        
+        logger.info(f"Automatische Druckerzuweisung: {best_printer['printer'].name} "
+                   f"(Score: {best_printer['score']}, Load: {best_printer['recent_load']})")
+        
+        return best_printer['printer'].id
+        
+    except Exception as e:
+        logger.error(f"Fehler bei automatischer Druckerzuweisung: {str(e)}")
+        return None
+
 @calendar_blueprint.route('/calendar', methods=['GET'])
 @login_required
 def calendar_view():
@@ -137,10 +256,11 @@ def api_create_calendar_event():
         title = data.get('title')
         start = data.get('start')
         end = data.get('end')
-        printer_id = data.get('printerId')
+        printer_id = data.get('printerId')  # Jetzt optional
+        priority = data.get('priority', 'normal')
         
-        if not all([title, start, end, printer_id]):
-            return jsonify({"error": "Titel, Start, Ende und Drucker sind erforderlich"}), 400
+        if not all([title, start, end]):
+            return jsonify({"error": "Titel, Start und Ende sind erforderlich"}), 400
         
         # Datumsfelder konvertieren
         try:
@@ -153,11 +273,48 @@ def api_create_calendar_event():
         duration_minutes = int((end_date - start_date).total_seconds() / 60)
         
         with get_cached_session() as db_session:
-            # Drucker prüfen
+            # Intelligente Druckerzuweisung falls kein Drucker angegeben
+            if not printer_id:
+                logger.info(f"Automatische Druckerzuweisung wird verwendet für Job '{title}'")
+                printer_id = get_smart_printer_assignment(
+                    start_date=start_date,
+                    end_date=end_date,
+                    priority=priority,
+                    db_session=db_session
+                )
+                
+                if not printer_id:
+                    return jsonify({
+                        "error": "Keine verfügbaren Drucker für den gewünschten Zeitraum gefunden. "
+                               "Bitte wählen Sie einen spezifischen Drucker oder einen anderen Zeitraum."
+                    }), 409
+            
+            # Drucker prüfen/validieren
             printer = db_session.query(Printer).filter_by(id=printer_id).first()
             if not printer:
                 return jsonify({"error": "Drucker nicht gefunden"}), 404
             
+            if not printer.active:
+                return jsonify({"error": f"Drucker '{printer.name}' ist nicht aktiv"}), 400
+            
+            # Nochmals Verfügbarkeit prüfen bei automatischer Zuweisung
+            if not data.get('printerId'):  # War automatische Zuweisung
+                conflicting_jobs = db_session.query(Job).filter(
+                    Job.printer_id == printer_id,
+                    Job.status.in_(["scheduled", "running"]),
+                    or_(
+                        and_(Job.start_at >= start_date, Job.start_at < end_date),
+                        and_(Job.end_at > start_date, Job.end_at <= end_date),
+                        and_(Job.start_at <= start_date, Job.end_at >= end_date)
+                    )
+                ).first()
+                
+                if conflicting_jobs:
+                    return jsonify({
+                        "error": f"Automatisch zugewiesener Drucker '{printer.name}' ist nicht mehr verfügbar. "
+                               "Bitte wählen Sie einen anderen Zeitraum oder spezifischen Drucker."
+                    }), 409
+            
             # Neuen Job erstellen
             job = Job(
                 name=title,
@@ -174,7 +331,9 @@ def api_create_calendar_event():
             db_session.add(job)
             db_session.commit()
             
-            logger.info(f"Neuer Kalendereintrag erstellt: ID {job.id}, Name: {title}")
+            assignment_type = "automatisch" if not data.get('printerId') else "manuell"
+            logger.info(f"Neuer Kalendereintrag erstellt: ID {job.id}, Name: {title}, "
+                       f"Drucker: {printer.name} ({assignment_type} zugewiesen)")
             
             return jsonify({
                 "success": True,
@@ -182,7 +341,14 @@ def api_create_calendar_event():
                 "title": job.name,
                 "start": job.start_at.isoformat(),
                 "end": job.end_at.isoformat(),
-                "status": job.status
+                "status": job.status,
+                "printer": {
+                    "id": printer.id,
+                    "name": printer.name,
+                    "location": printer.location,
+                    "assignment_type": assignment_type
+                },
+                "message": f"Auftrag erfolgreich erstellt und {assignment_type} dem Drucker '{printer.name}' zugewiesen."
             })
             
     except Exception as e:
@@ -277,4 +443,108 @@ def api_delete_calendar_event(event_id):
             
     except Exception as e:
         logger.error(f"Fehler beim Löschen des Kalendereintrags: {str(e)}")
+        return jsonify({"error": "Fehler beim Verarbeiten der Anfrage"}), 500
+
+@calendar_blueprint.route('/api/calendar/smart-recommendation', methods=['POST'])
+@login_required
+def api_get_smart_recommendation():
+    """Intelligente Druckerempfehlung für gegebenes Zeitfenster abrufen."""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "Keine Daten erhalten"}), 400
+        
+        start = data.get('start')
+        end = data.get('end')
+        priority = data.get('priority', 'normal')
+        
+        if not all([start, end]):
+            return jsonify({"error": "Start und Ende sind erforderlich"}), 400
+        
+        # Datumsfelder konvertieren
+        try:
+            start_date = datetime.fromisoformat(start)
+            end_date = datetime.fromisoformat(end)
+        except ValueError:
+            return jsonify({"error": "Ungültiges Datumsformat"}), 400
+        
+        with get_cached_session() as db_session:
+            # Empfohlenen Drucker ermitteln
+            recommended_printer_id = get_smart_printer_assignment(
+                start_date=start_date,
+                end_date=end_date,
+                priority=priority,
+                db_session=db_session
+            )
+            
+            if not recommended_printer_id:
+                return jsonify({
+                    "success": False,
+                    "message": "Keine verfügbaren Drucker für den gewünschten Zeitraum gefunden."
+                })
+            
+            # Drucker-Details abrufen
+            printer = db_session.query(Printer).filter_by(id=recommended_printer_id).first()
+            if not printer:
+                return jsonify({
+                    "success": False,
+                    "message": "Empfohlener Drucker nicht mehr verfügbar."
+                })
+            
+            # Zusätzliche Statistiken für die Empfehlung berechnen
+            last_24h = datetime.now() - timedelta(hours=24)
+            recent_jobs_count = db_session.query(Job).filter(
+                Job.printer_id == printer.id,
+                Job.start_at >= last_24h,
+                Job.status.in_(["scheduled", "running", "finished"])
+            ).count()
+            
+            # Verfügbarkeit als Prozentsatz berechnen
+            total_time_slots = 24  # Stunden pro Tag
+            availability_percent = max(0, 100 - (recent_jobs_count * 4))  # Grobe Schätzung
+            
+            # Auslastung berechnen
+            utilization_percent = min(100, recent_jobs_count * 8)  # Grobe Schätzung
+            
+            # Eignung basierend auf Priorität und Zeitfenster bestimmen
+            suitability = "Gut"
+            if priority == "urgent" and ("express" in printer.name.lower() or "schnell" in printer.name.lower()):
+                suitability = "Perfekt"
+            elif priority == "high" and recent_jobs_count <= 2:
+                suitability = "Ausgezeichnet"
+            elif recent_jobs_count == 0:
+                suitability = "Optimal"
+            
+            # Begründung generieren
+            reason = f"Optimale Verfügbarkeit und geringe Auslastung im gewählten Zeitraum"
+            
+            job_duration_hours = (end_date - start_date).total_seconds() / 3600
+            start_hour = start_date.hour
+            
+            if priority == "urgent":
+                reason = "Schnellster verfügbarer Drucker für dringende Aufträge"
+            elif start_hour >= 18 or start_hour <= 6:
+                reason = "Speziell für Nachtschichten optimiert"
+            elif job_duration_hours > 8:
+                reason = "Zuverlässig für lange Druckaufträge"
+            elif job_duration_hours <= 2:
+                reason = "Optimal für schnelle Druckaufträge"
+            
+            return jsonify({
+                "success": True,
+                "recommendation": {
+                    "printer_id": printer.id,
+                    "printer_name": f"{printer.name}",
+                    "location": printer.location or "Haupthalle",
+                    "reason": reason,
+                    "availability": f"{availability_percent}%",
+                    "utilization": f"{utilization_percent}%",
+                    "suitability": suitability,
+                    "recent_jobs": recent_jobs_count,
+                    "priority_optimized": priority in ["urgent", "high"] and suitability in ["Perfekt", "Ausgezeichnet"]
+                }
+            })
+            
+    except Exception as e:
+        logger.error(f"Fehler beim Abrufen der intelligenten Empfehlung: {str(e)}")
         return jsonify({"error": "Fehler beim Verarbeiten der Anfrage"}), 500