✨ feat(backend): improve seat allocation algorithm and get configurations from environment variables.

Author: ge85riz

backend/algo(table).py

@@ -4,7 +4,7 @@
 import math
 import sys
 
-def assign_tables(employees_data, tables_data, constraints_config, time_limit_sec=30.0):
+def assign_tables(search_workers_count, employees_data, tables_data, constraints_config, time_limit_sec=30.0):
     """
     Assigns employee groups to tables to maximize diversity using Google OR-Tools.
     Handles groups of people represented by a single employee record with an "Anzahl" > 1.
@@ -39,7 +39,14 @@ def assign_tables(employees_data, tables_data, constraints_config, time_limit_se
 
     if total_seats_required > total_capacity:
         print(f"Error: Not enough capacity ({total_capacity}) for all people ({total_seats_required}).")
-        return employees_data
+        sys.exit(2)
+
+    # Check for feasibility issues
+    max_group_size = df_employees['Anzahl'].max()
+    max_table_capacity = df_tables['Capacity'].max()
+    if max_group_size > max_table_capacity:
+        print(f"Error: Largest group ({max_group_size}) exceeds largest table capacity ({max_table_capacity}).")
+        sys.exit(3)
 
     # --- 2. Create the CP-SAT Model ---
     model = cp_model.CpModel()
@@ -50,9 +57,11 @@ def assign_tables(employees_data, tables_data, constraints_config, time_limit_se
             assignment[(g_idx, t_idx)] = model.NewBoolVar(f'assign_g{g_idx}_t{t_idx}')
 
     # --- 3. Add Core Constraints ---
+    # Each group assigned to exactly one table
     for g_idx in range(num_groups):
         model.AddExactlyOne([assignment[(g_idx, t_idx)] for t_idx in range(num_tables)])
 
+    # Table capacity constraints
     for t_idx in range(num_tables):
         table_capacity = df_tables.loc[t_idx, 'Capacity']
         groups_at_table = [df_employees.loc[g_idx, 'Anzahl'] * assignment[(g_idx, t_idx)] for g_idx in range(num_groups)]
@@ -63,10 +72,16 @@ def assign_tables(employees_data, tables_data, constraints_config, time_limit_se
 
     # Add a penalty for each table used to encourage filling tables
     for t_idx in range(num_tables):
+        table_capacity = df_tables.loc[t_idx, 'Capacity']
+
+        # Calculate actual occupancy
+        groups_at_table = [df_employees.loc[g_idx, 'Anzahl'] * assignment[(g_idx, t_idx)] for g_idx in range(num_groups)]
+        total_seated_at_table = cp_model.LinearExpr.Sum(groups_at_table)
+
+        # Encourage table usage with diminishing returns
         is_table_used = model.NewBoolVar(f'table_used_{t_idx}')
         assignments_to_table = [assignment[(g_idx, t_idx)] for g_idx in range(num_groups)]
         model.AddMaxEquality(is_table_used, assignments_to_table)
-        objective_terms.append(-1 * is_table_used)
 
         # Add a penalty for each empty seat to encourage fuller tables
         groups_at_table = [df_employees.loc[g_idx, 'Anzahl'] * assignment[(g_idx, t_idx)] for g_idx in range(num_groups)]
@@ -76,10 +91,9 @@ def assign_tables(employees_data, tables_data, constraints_config, time_limit_se
 
         objective_terms.append(-0.1 * wasted_space)
 
-
     for attr, weight in constraints_config.items():
         if weight == 0:
-            continue 
+            continue
 
         if attr == 'last neighborhood':
             if 'last neighborhood' not in df_employees.columns or 'ProfileID' not in df_employees.columns:
@@ -105,70 +119,165 @@ def assign_tables(employees_data, tables_data, constraints_config, time_limit_se
                         continue
                     processed_pairs.add(pair)
 
+                    # IMPROVED: Softer constraint implementation
                     for t_idx in range(num_tables):
                         seated_together = model.NewBoolVar(f'seated_together_g{g_idx}_n{neighbor_g_idx}_t{t_idx}')
                         model.Add(seated_together <= assignment[(g_idx, t_idx)])
                         model.Add(seated_together <= assignment[(neighbor_g_idx, t_idx)])
                         model.Add(seated_together >= assignment[(g_idx, t_idx)] + assignment[(neighbor_g_idx, t_idx)] - 1)
-                        objective_terms.append(-weight * seated_together)
-        
+
+                        # Use absolute weight value to ensure proper direction
+                        objective_terms.append(-abs(weight) * seated_together)
+
         else:
+            # IMPROVED: Diversity constraints with better handling
             if attr not in df_employees.columns:
                 print(f"Warning: Diversity attribute '{attr}' not found. Skipping.")
                 continue
-            
+
+            # Skip if all values are the same (no diversity possible)
+            unique_values = df_employees[attr].dropna().unique()
+            if len(unique_values) <= 1:
+                print(f"Warning: Attribute '{attr}' has no diversity (only {len(unique_values)} unique values). Skipping.")
+                continue
+
             print(f"Applying '{attr}' diversity constraint with weight: {weight}")
+
             for t_idx in range(num_tables):
                 table_id = df_tables.loc[t_idx, 'TableNr']
+
+                # IMPROVED: Only consider non-null values for diversity
                 for value in df_employees[attr].unique():
-                    is_value_present_at_table = model.NewBoolVar(f'attr_{attr}_val_{str(value)}_table_{table_id}')
+                    is_value_present_at_table = model.NewBoolVar(f'attr_{attr}_val_{str(value).replace(" ", "_")}_table_{table_id}')
                     groups_with_value_indices = df_employees[df_employees[attr] == value].index.tolist()
                     assignments_for_value_at_table = [assignment[(g_idx, t_idx)] for g_idx in groups_with_value_indices]
-                    
+
                     if assignments_for_value_at_table:
                         model.AddMaxEquality(is_value_present_at_table, assignments_for_value_at_table)
+                        objective_terms.append(abs(weight) * is_value_present_at_table)
                     else:
                         model.Add(is_value_present_at_table == 0)
-                    
-                    objective_terms.append(weight * is_value_present_at_table)
 
     # --- 5. Set the Combined Objective ---
     if objective_terms:
         model.Maximize(cp_model.LinearExpr.Sum(objective_terms))
+        print(f"Created {len(objective_terms)} objective terms")
     else:
-        print("Warning: No objective terms were created.")
+        print("Warning: No objective terms were created. Using basic feasibility.")
 
-    # --- 6. Solve the Model ---
+    # --- 6. IMPROVED: Solve with better parameters ---
     solver = cp_model.CpSolver()
     solver.parameters.max_time_in_seconds = float(time_limit_sec)
+    solver.parameters.num_search_workers = search_workers_count  # We can use multiple cores
+    solver.parameters.log_search_progress = True
+    solver.parameters.cp_model_presolve = True
+
+    print("Starting solver...")
     status = solver.Solve(model)
 
-    # --- 7. Process the Results ---
+    # --- 7. IMPROVED: Better result processing and debugging ---
+    print(f"Solver finished with status: {solver.StatusName(status)}")
+    print(f"Solver statistics:")
+    print(f"  - Conflicts: {solver.NumConflicts()}")
+    print(f"  - Branches: {solver.NumBranches()}")
+    print(f"  - Wall time: {solver.WallTime():.2f}s")
+
     if status == cp_model.OPTIMAL or status == cp_model.FEASIBLE:
         status_name = 'OPTIMAL' if status == cp_model.OPTIMAL else 'FEASIBLE'
         print(f"\nSolution found with status: {status_name}")
         if objective_terms:
             print(f"Total objective score achieved: {solver.ObjectiveValue()}")
 
+        # Assign tables to groups
         for g_idx in range(num_groups):
             for t_idx in range(num_tables):
                 if solver.Value(assignment[(g_idx, t_idx)]) == 1:
                     assigned_table_id = df_tables.loc[t_idx, 'TableNr']
                     group_size = df_employees.loc[g_idx, 'Anzahl']
-                    
+
                     current_event_assignment = [str(assigned_table_id)] * group_size
                     employees_data[g_idx]['TableNr'] = current_event_assignment
                     break
+
+        # IMPROVED: Validation of solution
+        print("\n--- Solution Validation ---")
+        table_occupancy = {}
+        for g_idx in range(num_groups):
+            for t_idx in range(num_tables):
+                if solver.Value(assignment[(g_idx, t_idx)]) == 1:
+                    table_id = df_tables.loc[t_idx, 'TableNr']
+                    if table_id not in table_occupancy:
+                        table_occupancy[table_id] = 0
+                    table_occupancy[table_id] += df_employees.loc[g_idx, 'Anzahl']
+
+        for table_id, occupancy in table_occupancy.items():
+            table_capacity = df_tables[df_tables['TableNr'] == table_id]['Capacity'].iloc[0]
+            print(f"Table {table_id}: {occupancy}/{table_capacity} seats")
+            if occupancy > table_capacity:
+                print(f"ERROR: Table {table_id} is over capacity!")
+
+        return employees_data
+
+    elif status == cp_model.INFEASIBLE:
+        print(f"\nPROBLEM IS INFEASIBLE!")
+        print("Debugging information:")
+        print(f"Total people to seat: {total_seats_required}")
+        print(f"Total capacity: {total_capacity}")
+        print(f"Largest group: {max_group_size}")
+        print(f"Largest table: {max_table_capacity}")
+
+        # IMPROVED: Try to identify infeasibility source
+        print("\nTable capacities vs group sizes:")
+        for idx, row in df_tables.iterrows():
+            groups_that_fit = sum(1 for _, emp_row in df_employees.iterrows() if emp_row['Anzahl'] <= row['Capacity'])
+            print(f"Table {row['TableNr']} (capacity {row['Capacity']}): {groups_that_fit} groups can fit")
+
+        # Try a relaxed version to help debug
+        print("\nTrying relaxed model for debugging...")
+        relaxed_model = cp_model.CpModel()
+        relaxed_assignment = {}
+
+        for g_idx in range(num_groups):
+            for t_idx in range(num_tables):
+                relaxed_assignment[(g_idx, t_idx)] = relaxed_model.NewBoolVar(f'assign_g{g_idx}_t{t_idx}')
+
+        # Only add basic constraints
+        for g_idx in range(num_groups):
+            relaxed_model.AddExactlyOne([relaxed_assignment[(g_idx, t_idx)] for t_idx in range(num_tables)])
+
+        # Relaxed capacity constraints (allow slight overflow)
+        for t_idx in range(num_tables):
+            table_capacity = df_tables.loc[t_idx, 'Capacity']
+            groups_at_table = [df_employees.loc[g_idx, 'Anzahl'] * relaxed_assignment[(g_idx, t_idx)] for g_idx in range(num_groups)]
+            overflow = relaxed_model.NewIntVar(0, max_group_size, f'overflow_t{t_idx}')
+            relaxed_model.Add(cp_model.LinearExpr.Sum(groups_at_table) <= table_capacity + overflow)
+            relaxed_model.Minimize(overflow)  # Try to minimize overflow
+
+        relaxed_solver = cp_model.CpSolver()
+        relaxed_solver.parameters.max_time_in_seconds = 10.0
+        relaxed_status = relaxed_solver.Solve(relaxed_model)
+
+        if relaxed_status in [cp_model.OPTIMAL, cp_model.FEASIBLE]:
+            print("Relaxed model found solution - problem likely with soft constraints being too restrictive")
+        else:
+            print("Even relaxed model failed - fundamental capacity/assignment issue")
+
         return employees_data
     else:
         status_name = solver.StatusName(status)
-        print(f"\nNo solution found. Solver status: {status_name}")
-        sys.exit(-1)
+        print(f"\nSolver could not find solution. Status: {status_name}")
+        if status == cp_model.MODEL_INVALID:
+            print("Model is invalid - check constraint definitions")
+        elif status == cp_model.UNKNOWN:
+            print("Solver timed out or encountered other issues")
 
-# --- Main Execution Block ---
+        return employees_data
+
+# --- Main Execution Block (unchanged) ---
 if __name__ == "__main__":
-    if len(sys.argv) != 5:
-        print("Usage: python algo.py <input_json_path> <table_json_path> <config_json_path> <output_json_path>")
+    if len(sys.argv) != 7:
+        print("Usage: python algo.py <input_json_path> <table_json_path> <config_json_path> <output_json_path> <num_search_workers> <solver_time_limit>")
+        print(sys.argv)
         sys.exit(1)
 
     # --- Configuration ---
@@ -180,9 +289,8 @@ def assign_tables(employees_data, tables_data, constraints_config, time_limit_se
     TABLES_JSON_PATH = sys.argv[2]
     CONSTRAINTS_JSON_PATH = sys.argv[3]
     OUTPUT_JSON_PATH = sys.argv[4]
-
-    # Set a time limit for the solver
-    SOLVER_TIME_LIMIT = 300.0
+    num_search_workers = int(sys.argv[5])
+    SOLVER_TIME_LIMIT = int(sys.argv[6])
 
     print("--- Starting Table Assignment from File ---")
     try:
@@ -196,10 +304,11 @@ def assign_tables(employees_data, tables_data, constraints_config, time_limit_se
             constraints_config = json.load(f)
 
         assigned_employees = assign_tables(
+            num_search_workers,
             employees_data=employee_list,
             tables_data=table_list,
             constraints_config=constraints_config,
-            time_limit_sec=SOLVER_TIME_LIMIT
+            time_limit_sec=SOLVER_TIME_LIMIT,
         )
 
         if assigned_employees and all('TableNr' in r for r in assigned_employees):

backend/src/main/java/com/itestra/eep/aspect/GlobalExceptionHandler.java

@@ -78,6 +78,7 @@ public ResponseEntity<String> handleMaxSizeException(MaxUploadSizeExceededExcept
             PastEventUpdateException.class,
             EventCapacityExceededException.class,
             NotEnoughSeatForSeatAllocationException.class,
+            NoBigEnoughTableException.class,
             InfeasibleSeatAllocationException.class})
     public ResponseEntity<Object> handleCustomRuntimeException(RuntimeException exception) {
         return ResponseEntity

backend/src/main/java/com/itestra/eep/exceptions/NoBigEnoughTableException.java

@@ -0,0 +1,10 @@
+package com.itestra.eep.exceptions;
+
+import lombok.Getter;
+
+@Getter
+public class NoBigEnoughTableException extends RuntimeException {
+
+    private final String message = "Largest employee and visitor group exceeds the largest table's capacity.";
+
+}

backend/src/main/java/com/itestra/eep/exceptions/NotEnoughSeatForSeatAllocationException.java

@@ -5,9 +5,6 @@
 @Getter
 public class NotEnoughSeatForSeatAllocationException extends RuntimeException {
 
-    public NotEnoughSeatForSeatAllocationException(int requiredSeats, int totalAvailableSeats) {
-        super(String.format("There are not enough seats for every participant: required: %d, available: %d",
-                requiredSeats, totalAvailableSeats));
-    }
+    private final String message = "There are not enough seats for each participant";
 
 }

backend/src/main/java/com/itestra/eep/models/Chair.java

@@ -19,7 +19,7 @@ public class Chair {
     @Id
     private UUID id;
 
-    @ManyToOne(fetch = FetchType.LAZY)
+    @ManyToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
     @JoinColumn(name = "event_id")
     private Event event;
 

backend/src/main/java/com/itestra/eep/services/impl/SeatAllocationServiceImpl.java

@@ -9,6 +9,7 @@
 import com.itestra.eep.dtos.constraintSolver.StageMapDTO;
 import com.itestra.eep.exceptions.EventNotFoundException;
 import com.itestra.eep.exceptions.InfeasibleSeatAllocationException;
+import com.itestra.eep.exceptions.NoBigEnoughTableException;
 import com.itestra.eep.exceptions.NotEnoughSeatForSeatAllocationException;
 import com.itestra.eep.mappers.EmployeeParticipationMapper;
 import com.itestra.eep.models.*;
@@ -20,6 +21,7 @@
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Isolation;
 import org.springframework.transaction.annotation.Propagation;
@@ -41,6 +43,12 @@
 @Transactional(isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
 public class SeatAllocationServiceImpl implements SeatAllocationService {
 
+    @Value("${constraint-solver.num-search-workers}")
+    private String NUM_SEARCH_WORKERS;
+
+    @Value("${constraint-solver.solver-time-limit}")
+    private String SOLVER_TIME_LIMIT;
+
     private final EventRepository eventRepository;
     private final ChairRepository chairRepository;
     private final ObjectMapper objectMapper;
@@ -132,12 +140,6 @@ public void performTableBasedSeatAllocation(UUID eventId, StageMapDTO stageMap)
         Map<UUID, List<UUID>> tablesAndTheirSeats = stageMap.getSeatMap().entrySet().stream()
                 .collect(Collectors.toMap(Map.Entry::getKey, entry -> new ArrayList<>(entry.getValue().keySet())));
 
-        int totalAvailableSeat = tablesAndTheirSeats.values().stream().mapToInt(List::size).sum();
-
-        if (event.getParticipantCount() > totalAvailableSeat) {
-            throw new NotEnoughSeatForSeatAllocationException(event.getParticipantCount(), totalAvailableSeat);
-        }
-
         // we create input and output temp files
         try (TempFileManager tempFiles = new TempFileManager()) {
             writeInputFiles(tempFiles, formattedData, stageMap);
@@ -187,18 +189,20 @@ public void performTableBasedSeatAllocation(UUID eventId, StageMapDTO stageMap)
         }
     }
 
-    private static void runPythonScript(TempFileManager tempFiles) throws IOException, InterruptedException {
+    private void runPythonScript(TempFileManager tempFiles) throws IOException, InterruptedException {
         ProcessBuilder pb;
 
         if (Files.notExists(Path.of("../venv/bin/python"))) {
             pb = new ProcessBuilder(
                     "python3",
-                    "/algo(table).py", tempFiles.inputFile.toString(), tempFiles.tableFile.toString(), tempFiles.constraintsFile.toString(), tempFiles.outputFile.toString()
+                    "/algo(table).py", tempFiles.inputFile.toString(), tempFiles.tableFile.toString(), tempFiles.constraintsFile.toString(), tempFiles.outputFile.toString(),
+                    NUM_SEARCH_WORKERS, SOLVER_TIME_LIMIT
             );
         } else {
             pb = new ProcessBuilder(
                     "../venv/bin/python",
-                    "algo(table).py", tempFiles.inputFile.toString(), tempFiles.tableFile.toString(), tempFiles.constraintsFile.toString(), tempFiles.outputFile.toString()
+                    "algo(table).py", tempFiles.inputFile.toString(), tempFiles.tableFile.toString(), tempFiles.constraintsFile.toString(),
+                    tempFiles.outputFile.toString(), NUM_SEARCH_WORKERS, SOLVER_TIME_LIMIT
             );
         }
 
@@ -218,6 +222,8 @@ private static void runPythonScript(TempFileManager tempFiles) throws IOExceptio
         int exitCode = process.waitFor();
         log.info("Exited with code: {}", exitCode);
         if (exitCode == 255) throw new InfeasibleSeatAllocationException();
+        else if (exitCode == 2) throw new NotEnoughSeatForSeatAllocationException();
+        else if (exitCode == 3) throw new NoBigEnoughTableException();
     }
 
     private void persistNewChairAssignments(UUID eventId, List<Chair> chairsToPersist, Map<UUID, UUID> employeeParticipationToChairMap, Map<UUID, UUID> visitorParticipationToChairMap) {

backend/src/main/java/com/itestra/eep/sql/ddl.sql

@@ -70,7 +70,7 @@ CREATE TABLE organization.previous_matches
 CREATE TABLE organization.chair
 (
     id       UUID PRIMARY KEY,
-    event_id UUID REFERENCES organization.event (id)
+    event_id UUID REFERENCES organization.event (id) ON DELETE CASCADE
 );
 
 CREATE TABLE organization.employee_participation