S9 OR Tools basic scheduling

agiledancers-be/src/main/java/nl/agilecc/agiledancers/model/DayPart.java

@@ -4,6 +4,7 @@ import lombok.*;
 import nl.agilecc.agiledancers.model.specifications.DayPartType;
 
 import java.util.List;
+import java.time.LocalDate;
 
 @Getter
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
@@ -12,7 +13,9 @@ import java.util.List;
 public class DayPart extends AbstractEntity {
     @ToString.Include
     private final DayPartType type;
+    private final LocalDate date;
     @ToString.Include
+    @Setter
     private List<DanceGroup> danceGroups;
 
     public void removeDanceGroup(DanceGroup group) {

agiledancers-be/src/main/java/nl/agilecc/agiledancers/model/Show.java

@@ -3,7 +3,8 @@ package nl.agilecc.agiledancers.model;
 import lombok.*;
 
 import java.util.List;
-import java.time.LocalDate;
+import java.util.Map;
+import nl.agilecc.agiledancers.model.specifications.DanceGroupType;
 
 @Getter
 @AllArgsConstructor(access = AccessLevel.PRIVATE)
@@ -13,7 +14,8 @@ public class Show extends AbstractEntity {
     @Setter
     private String name;
     @Setter
-    private LocalDate date;
+    private Map<DanceGroupType, Integer> appearances;
     @ToString.Include
-    private final List<DayPart> dayParts;
+    @Setter
+    private List<DayPart> dayParts;
 }

agiledancers-be/src/main/java/nl/agilecc/agiledancers/model/specifications/DanceGroupType.java

@@ -1,18 +1,5 @@
 package nl.agilecc.agiledancers.model.specifications;
 
-import lombok.Getter;
-
 public enum DanceGroupType {
-    SHOW_CASE(3),
-    PRE_EDUCATION(1), // TODO check if this is one group mentioned with different docent each time, or three different groups - and thus if they are required 1 day or 3
-    SELECTION(2),
-    REGULAR(2),
-    PRE_SCHOOLER(1);
-
-    @Getter
-    private int dayPartsRequired;
-
-    DanceGroupType(int dayPartsRequired) {
-        this.dayPartsRequired = dayPartsRequired;
-    }
+    SHOW_CASE, PRE_EDUCATION, SELECTION, REGULAR, PRE_SCHOOLER
 }

agiledancers-be/src/main/java/nl/agilecc/agiledancers/rest/JacksonConfiguration.java

@@ -0,0 +1,14 @@
+package nl.agilecc.agiledancers.rest;
+
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.jackson.ObjectMapperCustomizer;
+import jakarta.inject.Singleton;
+
+@Singleton
+public class JacksonConfiguration implements ObjectMapperCustomizer {
+    @Override
+    public void customize(ObjectMapper mapper) {
+        mapper.disable(DeserializationFeature.ACCEPT_FLOAT_AS_INT);
+    }
+}

agiledancers-be/src/main/java/nl/agilecc/agiledancers/rest/ManagementExceptionMapper.java

@@ -14,6 +14,7 @@ public class ManagementExceptionMapper implements ExceptionMapper<ManagementExce
         int status = switch (exception.getKind()) {
             case NOT_FOUND -> 404;
             case INVALID_INPUT -> 400;
+            case CONFLICT -> 409;
         };
         return Response.status(status).type(MediaType.APPLICATION_JSON_TYPE)
                 .entity(new ErrorView(exception.getMessage())).build();

agiledancers-be/src/main/java/nl/agilecc/agiledancers/rest/ShowResource.java

@@ -6,6 +6,9 @@ import jakarta.validation.constraints.NotNull;
 import jakarta.ws.rs.*;
 import jakarta.ws.rs.core.*;
 import nl.agilecc.agiledancers.service.SchoolManagementService;
+import nl.agilecc.agiledancers.service.SchedulingService;
+import nl.agilecc.agiledancers.model.DayPart;
+import nl.agilecc.agiledancers.rest.apimodel.SchedulingView;
 
 import java.util.List;
 
@@ -19,6 +22,9 @@ public class ShowResource {
     @Inject
     SchoolManagementService service;
 
+    @Inject
+    SchedulingService scheduling;
+
     @PathParam("schoolId")
     long schoolId;
 
@@ -35,7 +41,7 @@ public class ShowResource {
 
     @POST
     public Response create(@NotNull @Valid ShowRequest request, @Context UriInfo uriInfo) {
-        var entity = service.createShow(schoolId, request.name(), request.date());
+        var entity = service.createShow(schoolId, request.name(), parts(request), request.appearances());
         return Response.created(uriInfo.getAbsolutePathBuilder().path(entity.getId().toString()).build())
                 .entity(ShowView.of(entity)).build();
     }
@@ -43,7 +49,21 @@ public class ShowResource {
     @PUT
     @Path("/{id}")
     public ShowView update(@PathParam("id") long id, @NotNull @Valid ShowRequest request) {
-        return ShowView.of(service.updateShow(schoolId, id, request.name(), request.date()));
+        return ShowView.of(service.updateShow(schoolId, id, request.name(), parts(request), request.appearances()));
+    }
+
+    private static List<DayPart> parts(ShowRequest request) {
+        return request.dayParts().stream().map(p -> DayPart.builder()
+                .date(p.date()).type(p.type()).danceGroups(List.of()).build()).toList();
+    }
+
+    @POST
+    @Path("/{id}/schedule")
+    @Consumes(MediaType.WILDCARD)
+    public SchedulingView schedule(@PathParam("id") long id) {
+        var result = scheduling.schedule(schoolId, id);
+        return new SchedulingView(result.optimal(), result.optimal()
+                ? "Optimal balance" : "Valid result; optimal balance not proven");
     }
 
     @DELETE

agiledancers-be/src/main/java/nl/agilecc/agiledancers/rest/apimodel/DayPartRequest.java

@@ -0,0 +1,5 @@
+package nl.agilecc.agiledancers.rest.apimodel;
+import java.time.LocalDate;
+import jakarta.validation.constraints.NotNull;
+import nl.agilecc.agiledancers.model.specifications.DayPartType;
+public record DayPartRequest(@NotNull LocalDate date, @NotNull DayPartType type) {}

agiledancers-be/src/main/java/nl/agilecc/agiledancers/rest/apimodel/DayPartView.java

@@ -1,6 +1,5 @@
 package nl.agilecc.agiledancers.rest.apimodel;
-
 import nl.agilecc.agiledancers.model.specifications.DayPartType;
 import java.util.List;
-
-public record DayPartView(DayPartType type, List<Long> danceGroupIds) {}
+import java.time.LocalDate;
+public record DayPartView(LocalDate date, DayPartType type, List<Long> danceGroupIds) {}

agiledancers-be/src/main/java/nl/agilecc/agiledancers/rest/apimodel/SchedulingView.java

@@ -0,0 +1,2 @@
+package nl.agilecc.agiledancers.rest.apimodel;
+public record SchedulingView(boolean optimal, String message) {}

agiledancers-be/src/main/java/nl/agilecc/agiledancers/rest/apimodel/ShowRequest.java

@@ -1,7 +1,7 @@
 package nl.agilecc.agiledancers.rest.apimodel;
-
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import java.time.LocalDate;
-
-public record ShowRequest(@NotBlank String name, @NotNull LocalDate date) {}
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.*;
+import java.util.*;
+import nl.agilecc.agiledancers.model.specifications.DanceGroupType;
+public record ShowRequest(@NotBlank String name, @NotNull List<@NotNull @Valid DayPartRequest> dayParts,
+                          Map<DanceGroupType, Integer> appearances) {}

agiledancers-be/src/main/java/nl/agilecc/agiledancers/rest/apimodel/ShowView.java

@@ -1,14 +1,10 @@
 package nl.agilecc.agiledancers.rest.apimodel;
-
-import nl.agilecc.agiledancers.model.Show;
-import nl.agilecc.agiledancers.model.DanceGroup;
-import java.time.LocalDate;
-import java.util.List;
-
-public record ShowView(long id, String name, LocalDate date, List<DayPartView> dayParts) {
+import nl.agilecc.agiledancers.model.*;
+import nl.agilecc.agiledancers.model.specifications.DanceGroupType;
+import java.util.*;
+public record ShowView(long id, String name, List<DayPartView> dayParts, Map<DanceGroupType, Integer> appearances) {
     public static ShowView of(Show show) {
-        return new ShowView(show.getId(), show.getName(), show.getDate(), show.getDayParts().stream()
-                .map(dayPart -> new DayPartView(dayPart.getType(), dayPart.getDanceGroups().stream()
-                        .map(DanceGroup::getId).toList())).toList());
+        return new ShowView(show.getId(), show.getName(), show.getDayParts().stream()
+                .map(p -> new DayPartView(p.getDate(), p.getType(), p.getDanceGroups().stream().map(DanceGroup::getId).toList())).toList(), show.getAppearances());
     }
 }

agiledancers-be/src/main/java/nl/agilecc/agiledancers/service/ManagementException.java

@@ -1,7 +1,7 @@
 package nl.agilecc.agiledancers.service;
 
 public class ManagementException extends RuntimeException {
-    public enum Kind { NOT_FOUND, INVALID_INPUT }
+    public enum Kind { NOT_FOUND, INVALID_INPUT, CONFLICT }
 
     private final Kind kind;
 

agiledancers-be/src/main/java/nl/agilecc/agiledancers/service/SchedulingEngine.java

@@ -0,0 +1,4 @@
+package nl.agilecc.agiledancers.service;
+public interface SchedulingEngine {
+    SchoolManagementService.SchedulingResult solve(SchoolManagementService.SchedulingInput input);
+}

agiledancers-be/src/main/java/nl/agilecc/agiledancers/service/SchedulingService.java

@@ -0,0 +1,19 @@
+package nl.agilecc.agiledancers.service;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+@Singleton
+public class SchedulingService {
+    @Inject SchoolManagementService schools;
+    @Inject SchedulingEngine engine;
+    public SchoolManagementService.SchedulingResult schedule(long schoolId, long showId) {
+        var input = schools.beginScheduling(schoolId, showId);
+        try {
+            var result = engine.solve(input);
+            schools.finishScheduling(schoolId, input, result);
+            return result;
+        } catch (ManagementException e) { throw e; }
+        catch (RuntimeException | LinkageError e) {
+            throw new ManagementException(ManagementException.Kind.INVALID_INPUT, "Solver failed. Existing assignments were preserved. Please run scheduling again.");
+        } finally { schools.endScheduling(showId); }
+    }
+}

agiledancers-be/src/main/java/nl/agilecc/agiledancers/service/SchoolManagementService.java

@@ -18,6 +18,52 @@ public class SchoolManagementService {
     private final DanceGroupRepository groups = new DanceGroupRepository();
     private final ShowRepository shows = new ShowRepository();
 
+    private final Map<Long, Long> revisions = new HashMap<>();
+    private final Set<Long> running = new HashSet<>();
+    private void touch(Show show) { revisions.merge(show.getId(), 1L, Long::sum); }
+
+    public record SchedulingInput(long showId, long revision, int dayParts, List<Long> groupIds, List<Integer> required) {}
+    public record SchedulingResult(boolean optimal, List<List<Long>> assignments) {}
+    public synchronized SchedulingInput beginScheduling(long schoolId, long showId) {
+        Show show = show(schoolId, showId);
+        if (running.contains(showId)) throw new ManagementException(CONFLICT, "Scheduling is already running for this show.");
+        List<DanceGroup> current = groups(schoolId);
+        if (current.isEmpty() || show.getDayParts().isEmpty()) throw new ManagementException(INVALID_INPUT, "Scheduling requires at least one school group and one daypart.");
+        ShowConfiguration.validate(show.getDayParts(), show.getAppearances());
+        running.add(showId);
+        return new SchedulingInput(showId, revisions.getOrDefault(showId, 0L), show.getDayParts().size(),
+                current.stream().map(DanceGroup::getId).toList(), current.stream().map(g -> show.getAppearances().get(g.getType())).toList());
+    }
+    public synchronized void finishScheduling(long schoolId, SchedulingInput input, SchedulingResult result) {
+        Show show;
+        try { show = show(schoolId, input.showId()); }
+        catch (ManagementException e) { throw new ManagementException(CONFLICT, "Scheduling inputs changed. Run scheduling again."); }
+        if (revisions.getOrDefault(input.showId(), 0L) != input.revision())
+            throw new ManagementException(CONFLICT, "Scheduling inputs changed. Run scheduling again.");
+        // Validate the complete solver output before mutating any assignments.
+        if (result == null || result.assignments() == null || result.assignments().size() != input.dayParts())
+            throw new ManagementException(INVALID_INPUT, "Solver returned an invalid result. Existing assignments were preserved.");
+        Map<Long, DanceGroup> current = new HashMap<>();
+        groups(schoolId).forEach(g -> current.put(g.getId(), g));
+        for (var part : result.assignments()) {
+            if (part == null || new HashSet<>(part).size() != part.size() || !input.groupIds().containsAll(part))
+                throw new ManagementException(INVALID_INPUT, "Solver returned invalid group assignments.");
+        }
+        for (int g = 0; g < input.groupIds().size(); g++) {
+            long id = input.groupIds().get(g);
+            if (result.assignments().stream().filter(p -> p.contains(id)).count() != input.required().get(g))
+                throw new ManagementException(INVALID_INPUT, "Solver did not satisfy every required appearance.");
+        }
+        List<DayPart> replacement = new ArrayList<>();
+        for (int p = 0; p < input.dayParts(); p++) {
+            DayPart old = show.getDayParts().get(p);
+            replacement.add(DayPart.builder().date(old.getDate()).type(old.getType())
+                    .danceGroups(result.assignments().get(p).stream().map(current::get).toList()).build());
+        }
+        show.setDayParts(List.copyOf(replacement));
+    }
+    public synchronized void endScheduling(long showId) { running.remove(showId); }
+
     public synchronized List<DanceSchool> schools() {
         return schools.findAll();
     }
@@ -89,6 +135,7 @@ public class SchoolManagementService {
         DanceGroup group = groups.add(DanceGroup.builder().category(category).type(type)
                 .startAge(startAge).endAge(endAge).styles(new LinkedHashSet<>(styles)).build());
         school.addDanceGroup(group);
+        school.getShows().forEach(this::touch);
         return group;
     }
 
@@ -97,6 +144,7 @@ public class SchoolManagementService {
         DanceGroup group = group(schoolId, groupId);
         validateAgeRange(startAge, endAge);
         group.setCategory(category);
+        if (group.getType() != type) school(schoolId).getShows().forEach(this::touch);
         group.setType(type);
         group.setStartAge(startAge);
         group.setEndAge(endAge);
@@ -107,6 +155,7 @@ public class SchoolManagementService {
     public synchronized void deleteGroup(long schoolId, long groupId) {
         DanceGroup group = group(schoolId, groupId);
         school(schoolId).getShows().forEach(show -> show.getDayParts().forEach(part -> part.removeDanceGroup(group)));
+        school(schoolId).getShows().forEach(this::touch);
         school(schoolId).removeDanceGroup(group);
         groups.delete(groupId);
     }
@@ -129,22 +178,34 @@ public class SchoolManagementService {
         return member(school(schoolId).getShows(), showId, "Show");
     }
 
-    public synchronized Show createShow(long schoolId, String name, LocalDate date) {
+    public synchronized Show createShow(long schoolId, String name, List<DayPart> parts, Map<DanceGroupType, Integer> counts) {
         DanceSchool school = school(schoolId);
-        List<DayPart> dayParts = Arrays.stream(DayPartType.values())
-                .map(type -> DayPart.builder().type(type).danceGroups(List.of()).build()).toList();
-        Show show = shows.add(Show.builder().name(name).date(date).dayParts(dayParts).build());
+        if (counts == null) counts = ShowConfiguration.defaults(parts.size());
+        ShowConfiguration.validate(parts, counts);
+        Show show = shows.add(Show.builder().name(name).dayParts(List.copyOf(parts)).appearances(Map.copyOf(counts)).build());
         school.addShow(show);
         return show;
     }
 
-    public synchronized Show updateShow(long schoolId, long showId, String name, LocalDate date) {
+    public synchronized Show updateShow(long schoolId, long showId, String name, List<DayPart> parts, Map<DanceGroupType, Integer> counts) {
         Show show = show(schoolId, showId);
+        if (counts == null) counts = show.getAppearances().isEmpty() ? ShowConfiguration.defaults(parts.size()) : show.getAppearances();
+        ShowConfiguration.validate(parts, counts);
+        boolean changed = !counts.equals(show.getAppearances()) || !partKeys(parts).equals(partKeys(show.getDayParts()));
+        List<DayPart> retained = parts.stream().map(p -> DayPart.builder().date(p.getDate()).type(p.getType())
+                .danceGroups(show.getDayParts().stream().filter(old -> old.getDate().equals(p.getDate()) && old.getType() == p.getType())
+                        .findFirst().map(DayPart::getDanceGroups).orElse(List.of())).build()).toList();
         show.setName(name);
-        show.setDate(date);
+        show.setDayParts(retained);
+        show.setAppearances(Map.copyOf(counts));
+        if (changed) touch(show);
         return show;
     }
 
+    private static List<String> partKeys(List<DayPart> parts) {
+        return parts.stream().map(p -> p.getDate() + ":" + p.getType()).toList();
+    }
+
     public synchronized void deleteShow(long schoolId, long showId) {
         Show show = show(schoolId, showId);
         school(schoolId).removeShow(show);
@@ -191,8 +252,8 @@ public class SchoolManagementService {
         }
         List<Show> rebuiltShows = new ArrayList<>();
         for (Show show : importedShows) {
-            Show rebuilt = Show.builder().name(show.getName()).date(show.getDate()).dayParts(show.getDayParts().stream()
-                    .map(p -> DayPart.builder().type(p.getType()).danceGroups(p.getDanceGroups().stream().map(replacements::get).toList()).build()).toList()).build();
+            Show rebuilt = Show.builder().name(show.getName()).appearances(show.getAppearances()).dayParts(show.getDayParts().stream()
+                    .map(p -> DayPart.builder().date(p.getDate()).type(p.getType()).danceGroups(p.getDanceGroups().stream().map(replacements::get).toList()).build()).toList()).build();
             rebuilt.setId(shows.nextId()); rebuiltShows.add(rebuilt);
         }
         DanceSchool imported = DanceSchool.builder().key(staged.getKey()).name(staged.getName())

agiledancers-be/src/main/java/nl/agilecc/agiledancers/service/SchoolSnapshot.java

@@ -5,31 +5,31 @@ import nl.agilecc.agiledancers.model.specifications.*;
 import java.time.LocalDate;
 import java.util.*;
 
-/** Version 1 file format. IDs are local to the file, never server identifiers. */
+/** Version 2 file format. IDs are local to the file, never server identifiers. */
 public record SchoolSnapshot(Integer formatVersion, UUID key, String name, List<Person> dancers,
                              List<Trainer> coaches, List<Group> groups, List<Performance> shows) {
     public record Person(String id, String name, LocalDate birthDate) {}
     public record Trainer(String id, String name) {}
     public record Group(String id, String category, DanceGroupType type, Integer startAge, Integer endAge,
                         List<DanceGroupStyle> styles, List<String> dancerIds, String coachId) {}
-    public record Part(DayPartType type, List<String> groupIds) {}
-    public record Performance(String id, String name, LocalDate date, List<Part> dayParts) {}
+    public record Part(LocalDate date, DayPartType type, List<String> groupIds) {}
+    public record Performance(String id, String name, List<Part> dayParts, Map<DanceGroupType, Integer> appearances) {}
 
     public static SchoolSnapshot of(DanceSchool s) {
         Map<Dancer, String> dancers = ids(s.getDancers());
         Map<Coach, String> coaches = ids(s.getCoaches());
         Map<DanceGroup, String> groups = ids(s.getDanceGroups());
         Map<Show, String> shows = ids(s.getShows());
-        return new SchoolSnapshot(1, s.getKey(), s.getName(),
+        return new SchoolSnapshot(2, s.getKey(), s.getName(),
                 s.getDancers().stream().map(d -> new Person(dancers.get(d), d.getName(), d.getBirthDate())).toList(),
                 s.getCoaches().stream().map(c -> new Trainer(coaches.get(c), c.getName())).toList(),
                 s.getDanceGroups().stream().map(g -> new Group(groups.get(g), g.getCategory(), g.getType(),
                         g.getStartAge(), g.getEndAge(), List.copyOf(g.getStyles()),
                         g.getDancers().stream().map(dancers::get).toList(),
                         g.getCoach() == null ? null : coaches.get(g.getCoach()))).toList(),
-                s.getShows().stream().map(show -> new Performance(shows.get(show), show.getName(), show.getDate(),
-                        show.getDayParts().stream().map(p -> new Part(p.getType(),
-                                p.getDanceGroups().stream().map(groups::get).toList())).toList())).toList());
+                s.getShows().stream().map(show -> new Performance(shows.get(show), show.getName(),
+                        show.getDayParts().stream().map(p -> new Part(p.getDate(), p.getType(),
+                                p.getDanceGroups().stream().map(groups::get).toList())).toList(), show.getAppearances())).toList());
     }
 
     private static <T> Map<T, String> ids(Collection<T> values) {
@@ -39,7 +39,7 @@ public record SchoolSnapshot(Integer formatVersion, UUID key, String name, List<
     }
 
     public DanceSchool restore() {
-        check(Objects.equals(formatVersion, 1), "Niet-ondersteunde formatVersion: " + formatVersion);
+        check(Objects.equals(formatVersion, 2), "Niet-ondersteunde formatVersion: " + formatVersion);
         check(key != null, "key ontbreekt"); text(name, "schoolnaam");
         DanceSchool school = DanceSchool.builder().key(key).name(name).build();
         Map<String, Dancer> dancerMap = new LinkedHashMap<>();
@@ -73,14 +73,14 @@ public record SchoolSnapshot(Integer formatVersion, UUID key, String name, List<
         for (Performance show : list(shows, "shows")) {
             check(show != null, "Lege show"); text(show.id, "show-id");
             check(showIds.add(show.id), "Dubbele show-id " + show.id); text(show.name, "shownaam");
-            check(show.date != null, "Showdatum ontbreekt voor " + show.name);
-            List<DayPart> parts = new ArrayList<>(); Set<DayPartType> types = new HashSet<>();
+            List<DayPart> parts = new ArrayList<>(); Set<String> types = new HashSet<>();
             for (Part part : list(show.dayParts, "dayParts")) {
-                check(part != null && part.type != null && types.add(part.type), "Ongeldig of dubbel dagdeel voor " + show.name);
-                parts.add(DayPart.builder().type(part.type).danceGroups(unique(part.groupIds, "groupIds").stream()
+                check(part != null && part.type != null && part.date != null && types.add(part.date + ":" + part.type), "Ongeldig of dubbel dagdeel voor " + show.name);
+                parts.add(DayPart.builder().date(part.date).type(part.type).danceGroups(unique(part.groupIds, "groupIds").stream()
                         .map(id -> ref(groupMap, id, "Show " + show.name + " verwijst naar een onbekende groep")).toList()).build());
             }
-            Show entity = Show.builder().name(show.name).date(show.date).dayParts(parts).build();
+            ShowConfiguration.validate(parts, show.appearances);
+            Show entity = Show.builder().name(show.name).dayParts(parts).appearances(Map.copyOf(show.appearances)).build();
             entity.setId((long) showIds.size()); school.addShow(entity);
         }
         return school;

agiledancers-be/src/main/java/nl/agilecc/agiledancers/service/ShowConfiguration.java

@@ -0,0 +1,33 @@
+package nl.agilecc.agiledancers.service;
+
+import nl.agilecc.agiledancers.model.DayPart;
+import nl.agilecc.agiledancers.model.specifications.DanceGroupType;
+import java.util.*;
+
+public final class ShowConfiguration {
+    private ShowConfiguration() {}
+    public static Map<DanceGroupType, Integer> defaults(int n) {
+        Map<DanceGroupType, Integer> counts = new EnumMap<>(DanceGroupType.class);
+        if (n > 0) for (var type : DanceGroupType.values()) counts.put(type, switch (type) {
+            case PRE_SCHOOLER -> 1;
+            case SHOW_CASE, PRE_EDUCATION -> n;
+            default -> Math.min(2, n);
+        });
+        return counts;
+    }
+    public static void validate(List<DayPart> parts, Map<DanceGroupType, Integer> counts) {
+        if (parts == null || parts.size() > 6 || parts.stream().anyMatch(p -> p == null || p.getDate() == null || p.getType() == null)
+                || parts.stream().map(p -> p.getDate() + ":" + p.getType()).distinct().count() != parts.size())
+            throw new ManagementException(ManagementException.Kind.INVALID_INPUT, "Configure zero to six dayparts with unique date/type combinations.");
+        if (counts == null) invalidCounts();
+        if (parts.isEmpty() && counts.isEmpty()) return;
+        if (counts.size() != DanceGroupType.values().length
+                || Arrays.stream(DanceGroupType.values()).anyMatch(t -> counts.get(t) == null || counts.get(t) < 1
+                || (!parts.isEmpty() && counts.get(t) > parts.size()))) invalidCounts();
+    }
+
+    private static void invalidCounts() {
+        throw new ManagementException(ManagementException.Kind.INVALID_INPUT,
+                "Every type needs an integer appearance count between 1 and the number of dayparts. Saved counts are retained when dayparts are removed.");
+    }
+}

agiledancers-be/src/main/java/nl/agilecc/agiledancers/solver/OrToolsSchedulingEngine.java

@@ -0,0 +1,51 @@
+package nl.agilecc.agiledancers.solver;
+import com.google.ortools.Loader;
+import com.google.ortools.sat.*;
+import jakarta.inject.Singleton;
+import nl.agilecc.agiledancers.service.*;
+import java.util.*;
+@Singleton
+public class OrToolsSchedulingEngine implements SchedulingEngine {
+    @Override
+    public SchoolManagementService.SchedulingResult solve(SchoolManagementService.SchedulingInput input) {
+        Loader.loadNativeLibraries();
+        CpModel model = new CpModel();
+        int n = input.dayParts(), groups = input.groupIds().size();
+        BoolVar[][] assigned = new BoolVar[groups][n];
+        for (int g = 0; g < groups; g++) {
+            for (int p = 0; p < n; p++) assigned[g][p] = model.newBoolVar("g" + g + "p" + p);
+            model.addEquality(LinearExpr.sum(assigned[g]), input.required().get(g));
+        }
+        IntVar[] loads = new IntVar[n];
+        for (int p = 0; p < n; p++) {
+            BoolVar[] column = new BoolVar[groups];
+            for (int g = 0; g < groups; g++) column[g] = assigned[g][p];
+            loads[p] = model.newIntVar(0, groups, "load" + p);
+            model.addEquality(loads[p], LinearExpr.sum(column));
+        }
+        IntVar max = model.newIntVar(0, groups, "max"), min = model.newIntVar(0, groups, "min");
+        model.addMaxEquality(max, loads);
+        model.addMinEquality(min, loads);
+        model.minimize(LinearExpr.weightedSum(new IntVar[]{max, min}, new long[]{1, -1}));
+        CpSolver solver = new CpSolver();
+        solver.getParameters().setMaxTimeInSeconds(1800);
+        // Quarkus owns process shutdown; do not install a native SIGINT handler.
+        solver.getParameters().setCatchSigintSignal(false);
+        // Single-worker search with a fixed seed makes identical inputs repeatable.
+        solver.getParameters().setNumSearchWorkers(1).setRandomSeed(0);
+        CpSolverStatus status = solver.solve(model);
+        if (status != CpSolverStatus.OPTIMAL && status != CpSolverStatus.FEASIBLE)
+            throw new ManagementException(ManagementException.Kind.INVALID_INPUT, switch (status) {
+                case INFEASIBLE -> "Scheduling is infeasible. Existing assignments were preserved.";
+                case UNKNOWN -> "The 30-minute limit was reached without a valid result. Existing assignments were preserved.";
+                default -> "Solver failed (" + status + "). Existing assignments were preserved.";
+            });
+        List<List<Long>> parts = new ArrayList<>();
+        for (int p = 0; p < n; p++) {
+            List<Long> ids = new ArrayList<>();
+            for (int g = 0; g < groups; g++) if (solver.booleanValue(assigned[g][p])) ids.add(input.groupIds().get(g));
+            parts.add(List.copyOf(ids));
+        }
+        return new SchoolManagementService.SchedulingResult(status == CpSolverStatus.OPTIMAL, List.copyOf(parts));
+    }
+}