updated frorntend to backend

backend/src/workers/scheduler-worker.ts

@@ -0,0 +1,345 @@
+// backend/src/workers/scheduler-worker.ts
+import { parentPort, workerData } from 'worker_threads';
+import { CPModel, CPSolver } from './cp-sat-wrapper.js';
+import { ShiftPlan, Shift } from '../models/ShiftPlan.js';
+import { Employee, EmployeeAvailability } from '../models/Employee.js';
+import { Availability, Constraint, Violation, SolverOptions, Solution, Assignment } from '../models/scheduling.js';
+
+interface WorkerData {
+  shiftPlan: ShiftPlan;
+  employees: Employee[];
+  availabilities: Availability[];
+  constraints: Constraint[];
+  shifts: Shift[];
+}
+
+
+function buildSchedulingModel(model: CPModel, data: WorkerData): void {
+  const { employees, shifts, availabilities, constraints } = data;
+  
+  // 1. Entscheidungsvariablen erstellen
+  employees.forEach((employee: any) => {
+    shifts.forEach((shift: any) => {
+      const varName = `assign_${employee.id}_${shift.id}`;
+      model.addVariable(varName, 'bool');
+    });
+  });
+  
+  // 2. Verfügbarkeits-Constraints
+  employees.forEach((employee: any) => {
+    shifts.forEach((shift: any) => {
+      const availability = availabilities.find(
+        (a: any) => a.employeeId === employee.id && a.shiftId === shift.id
+      );
+      
+      if (availability?.preferenceLevel === 3) {
+        const varName = `assign_${employee.id}_${shift.id}`;
+        model.addConstraint(`${varName} == 0`, `Availability constraint for ${employee.name}`);
+      }
+    });
+  });
+  
+  // 3. Schicht-Besetzungs-Constraints
+  shifts.forEach((shift: any) => {
+    const assignmentVars = employees.map(
+      (emp: any) => `assign_${emp.id}_${shift.id}`
+    );
+    
+    if (assignmentVars.length > 0) {
+      model.addConstraint(
+        `${assignmentVars.join(' + ')} >= ${shift.minWorkers || 1}`,
+        `Min workers for shift ${shift.id}`
+      );
+      
+      model.addConstraint(
+        `${assignmentVars.join(' + ')} <= ${shift.maxWorkers || 3}`,
+        `Max workers for shift ${shift.id}`
+      );
+    }
+  });
+  
+  // 4. Keine zwei Schichten pro Tag pro Employee
+  employees.forEach((employee: any) => {
+    const shiftsByDate = groupShiftsByDate(shifts);
+    
+    Object.entries(shiftsByDate).forEach(([date, dayShifts]) => {
+      const dayAssignmentVars = (dayShifts as any[]).map(
+        (shift: any) => `assign_${employee.id}_${shift.id}`
+      );
+      
+      if (dayAssignmentVars.length > 0) {
+        model.addConstraint(
+          `${dayAssignmentVars.join(' + ')} <= 1`,
+          `Max one shift per day for ${employee.name} on ${date}`
+        );
+      }
+    });
+  });
+  
+  // 5. Trainee-Überwachungs-Constraints
+  const trainees = employees.filter((emp: any) => emp.employeeType === 'trainee');
+  const experienced = employees.filter((emp: any) => emp.employeeType === 'experienced');
+  
+  trainees.forEach((trainee: any) => {
+    shifts.forEach((shift: any) => {
+      const traineeVar = `assign_${trainee.id}_${shift.id}`;
+      const experiencedVars = experienced.map((exp: any) => `assign_${exp.id}_${shift.id}`);
+      
+      if (experiencedVars.length > 0) {
+        model.addConstraint(
+          `${traineeVar} <= ${experiencedVars.join(' + ')}`,
+          `Trainee ${trainee.name} requires supervision in shift ${shift.id}`
+        );
+      }
+    });
+  });
+  
+  // 6. Employee cant workalone  
+  employees.forEach((employee: any) => {
+    if (employee.employeeType === 'experienced' && employee.canWorkAlone) {
+      shifts.forEach((shift: any) => {
+        const varName = `assign_${employee.id}_${shift.id}`;
+        // Allow this employee to work alone (no additional constraint needed)
+        // This is more about not preventing single assignments
+      });
+    }
+  });
+
+  // 7. Contract Type Shifts Constraint
+  employees.forEach((employee: any) => {
+    const exactShiftsPerWeek = employee.contractType === 'small' ? 5 : 10; // Example: exactly 5 shifts for small, 10 for large
+    const shiftVars: string[] = [];
+    
+    shifts.forEach((shift: any) => {
+      const varName = `assign_${employee.id}_${shift.id}`;
+      shiftVars.push(varName);
+    });
+    
+    if (shiftVars.length > 0) {
+      model.addConstraint(
+        `${shiftVars.join(' + ')} == ${exactShiftsPerWeek}`,
+        `Exact shifts per week for ${employee.name} (${employee.contractType} contract)`
+      );
+    }
+  });
+  
+  // 8. Ziel: Verfügbarkeits-Score maximieren
+  let objectiveExpression = '';
+  employees.forEach((employee: any) => {
+    shifts.forEach((shift: any) => {
+      const availability = availabilities.find(
+        (a: any) => a.employeeId === employee.id && a.shiftId === shift.id
+      );
+      
+      if (availability) {
+        const score = availability.preferenceLevel === 1 ? 10 : 
+                     availability.preferenceLevel === 2 ? 5 : 
+                     -1000; // Heavy penalty for assigning unavailable shifts
+        
+        const varName = `assign_${employee.id}_${shift.id}`;
+        if (objectiveExpression) {
+          objectiveExpression += ` + ${score} * ${varName}`;
+        } else {
+          objectiveExpression = `${score} * ${varName}`;
+        }
+      }
+    });
+  });
+  
+  if (objectiveExpression) {
+    model.maximize(objectiveExpression);
+  }
+}
+
+function groupShiftsByDate(shifts: any[]): Record<string, any[]> {
+  return shifts.reduce((groups: Record<string, any[]>, shift: any) => {
+    const date = shift.date?.split('T')[0] || 'unknown';
+    if (!groups[date]) groups[date] = [];
+    groups[date].push(shift);
+    return groups;
+  }, {});
+}
+
+function extractAssignmentsFromSolution(solution: any, employees: any[], shifts: any[]): any {
+  const assignments: any = {};
+  
+  // Initialize assignments object with shift IDs
+  shifts.forEach((shift: any) => {
+    assignments[shift.id] = [];
+  });
+  
+  // Extract assignments from solution variables
+  employees.forEach((employee: any) => {
+    shifts.forEach((shift: any) => {
+      const varName = `assign_${employee.id}_${shift.id}`;
+      const isAssigned = solution.variables?.[varName] === 1;
+      
+      if (isAssigned) {
+        if (!assignments[shift.id]) {
+          assignments[shift.id] = [];
+        }
+        assignments[shift.id].push(employee.id);
+      }
+    });
+  });
+  
+  return assignments;
+}
+
+function detectViolations(assignments: any, employees: any[], shifts: any[]): string[] {
+  const violations: string[] = [];
+  const employeeMap = new Map(employees.map((emp: any) => [emp.id, emp]));
+  
+  // Check for understaffed shifts
+  shifts.forEach((shift: any) => {
+    const assignedCount = assignments[shift.id]?.length || 0;
+    const minRequired = shift.minWorkers || 1;
+    
+    if (assignedCount < minRequired) {
+      violations.push(`UNDERSTAFFED: Shift ${shift.id} has ${assignedCount} employees but requires ${minRequired}`);
+    }
+  });
+  
+  // Check for trainee supervision
+  shifts.forEach((shift: any) => {
+    const assignedEmployees = assignments[shift.id] || [];
+    const hasTrainee = assignedEmployees.some((empId: string) => {
+      const emp = employeeMap.get(empId);
+      return emp?.employeeType === 'trainee';
+    });
+    
+    const hasExperienced = assignedEmployees.some((empId: string) => {
+      const emp = employeeMap.get(empId);
+      return emp?.employeeType === 'experienced';
+    });
+    
+    if (hasTrainee && !hasExperienced) {
+      violations.push(`TRAINEE_UNSUPERVISED: Shift ${shift.id} has trainee but no experienced employee`);
+    }
+  });
+  
+  // Check for multiple shifts per day per employee
+  const shiftsByDate = groupShiftsByDate(shifts);
+  employees.forEach((employee: any) => {
+    Object.entries(shiftsByDate).forEach(([date, dayShifts]) => {
+      let shiftsAssigned = 0;
+      dayShifts.forEach((shift: any) => {
+        if (assignments[shift.id]?.includes(employee.id)) {
+          shiftsAssigned++;
+        }
+      });
+      
+      if (shiftsAssigned > 1) {
+        violations.push(`MULTIPLE_SHIFTS: ${employee.name} has ${shiftsAssigned} shifts on ${date}`);
+      }
+    });
+  });
+  
+  return violations;
+}
+
+async function runScheduling() {
+  const data: WorkerData = workerData;
+  const startTime = Date.now();
+  try {
+    console.log('Starting scheduling optimization...');
+    
+    
+    // Validate input data
+    if (!data.shifts || data.shifts.length === 0) {
+      throw new Error('No shifts provided for scheduling');
+    }
+    
+    if (!data.employees || data.employees.length === 0) {
+      throw new Error('No employees provided for scheduling');
+    }
+    
+    console.log(`Optimizing ${data.shifts.length} shifts for ${data.employees.length} employees`);
+    
+    const model = new CPModel();
+    buildSchedulingModel(model, data);
+    
+    const solver = new CPSolver({
+      maxTimeInSeconds: 105,
+      numSearchWorkers: 8,
+      logSearchProgress: true
+    });
+    
+    const solution = await solver.solve(model);
+    const processingTime = Date.now() - startTime;
+    
+    console.log(`Scheduling completed in ${processingTime}ms`);
+    console.log(`Solution success: ${solution.success}`);
+    
+    let assignments = {};
+    let violations: string[] = [];
+    let resolutionReport: string[] = [
+      `Solved in ${processingTime}ms`,
+      `Variables: ${solution.metadata?.variablesCreated || 'unknown'}`,
+      `Constraints: ${solution.metadata?.constraintsAdded || 'unknown'}`,
+      `Optimal: ${solution.metadata?.optimal || false}`,
+      `Status: ${solution.success ? 'SUCCESS' : 'FAILED'}`
+    ];
+    
+    if (solution.success) {
+      // Extract assignments from solution
+      assignments = extractAssignmentsFromSolution(solution, data.employees, data.shifts);
+      
+      // Detect violations
+      violations = detectViolations(assignments, data.employees, data.shifts);
+      
+      if (violations.length === 0) {
+        resolutionReport.push('✅ No constraint violations detected');
+      } else {
+        resolutionReport.push(`⚠️ Found ${violations.length} violations:`);
+        violations.forEach(violation => {
+          resolutionReport.push(`   - ${violation}`);
+        });
+      }
+      
+      // Add assignment statistics
+      const totalAssignments = Object.values(assignments).reduce((sum: number, shiftAssignments: any) => 
+        sum + shiftAssignments.length, 0
+      );
+      resolutionReport.push(`📊 Total assignments: ${totalAssignments}`);
+      
+    } else {
+      violations.push('SCHEDULING_FAILED: No feasible solution found');
+      resolutionReport.push('❌ No feasible solution could be found');
+    }
+    
+    parentPort?.postMessage({
+      assignments,
+      violations,
+      success: solution.success && violations.length === 0,
+      resolutionReport,
+      processingTime
+    });
+    
+  } catch (error) {
+    console.error('Scheduling worker error:', error);
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+    
+    parentPort?.postMessage({
+      error: errorMessage,
+      success: false,
+      assignments: {},
+      violations: [`ERROR: ${errorMessage}`],
+      resolutionReport: [`Error: ${errorMessage}`],
+      processingTime: Date.now() - startTime
+    });
+  }
+}
+
+// Handle graceful shutdown
+process.on('SIGTERM', () => {
+  console.log('Scheduling worker received SIGTERM, shutting down...');
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  console.log('Scheduling worker received SIGINT, shutting down...');
+  process.exit(0);
+});
+
+runScheduling();