chore: Remove real time planning classes and fields from employee scheduling

- Also, makes availability check for overlaps instead of same day

Author: Christopher-Chianelli

use-cases/employee-scheduling/src/main/java/org/acme/employeescheduling/domain/EmployeeSchedule.java

@@ -25,15 +25,12 @@ public class EmployeeSchedule {
     @PlanningScore
     private HardSoftScore score;
 
-    private ScheduleState scheduleState;
-
     private SolverStatus solverStatus;
 
     // No-arg constructor required for Timefold
     public EmployeeSchedule() {}
 
-    public EmployeeSchedule(ScheduleState scheduleState, List<Availability> availabilities, List<Employee> employees, List<Shift> shifts) {
-        this.scheduleState = scheduleState;
+    public EmployeeSchedule(List<Availability> availabilities, List<Employee> employees, List<Shift> shifts) {
         this.availabilities = availabilities;
         this.employees = employees;
         this.shifts = shifts;
@@ -44,14 +41,6 @@ public EmployeeSchedule(HardSoftScore score, SolverStatus solverStatus) {
         this.solverStatus = solverStatus;
     }
 
-    public ScheduleState getScheduleState() {
-        return scheduleState;
-    }
-
-    public void setScheduleState(ScheduleState scheduleState) {
-        this.scheduleState = scheduleState;
-    }
-
     public List<Availability> getAvailabilities() {
         return availabilities;
     }

use-cases/employee-scheduling/src/main/java/org/acme/employeescheduling/domain/ScheduleState.java

@@ -7,7 +7,7 @@
 import ai.timefold.solver.core.api.domain.lookup.PlanningId;
 import ai.timefold.solver.core.api.domain.variable.PlanningVariable;
 
-@PlanningEntity(pinningFilter = ShiftPinningFilter.class)
+@PlanningEntity
 public class Shift {
     @PlanningId
     private String id;

use-cases/employee-scheduling/src/main/java/org/acme/employeescheduling/domain/Shift.java

@@ -23,7 +23,6 @@
 import org.acme.employeescheduling.domain.AvailabilityType;
 import org.acme.employeescheduling.domain.Employee;
 import org.acme.employeescheduling.domain.EmployeeSchedule;
-import org.acme.employeescheduling.domain.ScheduleState;
 import org.acme.employeescheduling.domain.Shift;
 
 @ApplicationScoped
@@ -59,15 +58,6 @@ public EmployeeSchedule generateDemoData() {
         int initialRosterLengthInDays = 14;
         LocalDate startDate = LocalDate.now().with(TemporalAdjusters.nextOrSame(DayOfWeek.MONDAY));
 
-        ScheduleState scheduleState = new ScheduleState();
-        scheduleState.setFirstDraftDate(startDate);
-        scheduleState.setDraftLength(initialRosterLengthInDays);
-        scheduleState.setPublishLength(7);
-        scheduleState.setLastHistoricDate(startDate.minusDays(7));
-        scheduleState.setTenantId(EmployeeScheduleResource.SINGLETON_SCHEDULE_ID);
-
-        employeeSchedule.setScheduleState(scheduleState);
-
         Random random = new Random(0);
 
         int shiftTemplateIndex = 0;
@@ -143,37 +133,6 @@ private List<Shift> generateShiftForTimeslot(LocalDateTime timeslotStart, LocalD
         return shifts;
     }
 
-    public void addDraftShifts(EmployeeSchedule schedule) {
-        List<Employee> employees = schedule.getEmployees();
-        Random random = new Random(0);
-
-        List<Shift> shifts = new LinkedList<>();
-        List<Availability> availabilities = new LinkedList<>();
-        int countAvailability = schedule.getAvailabilities().stream()
-                .map(Availability::getId)
-                .mapToInt(Integer::parseInt)
-                .max()
-                .orElse(0);
-        AtomicInteger countShift = new AtomicInteger(schedule.getShifts().stream()
-                .map(Shift::getId)
-                .mapToInt(Integer::parseInt)
-                .max()
-                .orElse(0));
-        for (int i = 0; i < schedule.getScheduleState().getPublishLength(); i++) {
-            Set<Employee> employeesWithAvailabitiesOnDay = pickSubset(employees, random, 4, 3, 2, 1);
-            LocalDate date = schedule.getScheduleState().getFirstDraftDate()
-                    .plusDays(schedule.getScheduleState().getPublishLength() + i);
-            for (Employee employee : employeesWithAvailabitiesOnDay) {
-                AvailabilityType availabilityType = pickRandom(AvailabilityType.values(), random);
-                availabilities.add(new Availability(Integer.toString(++countAvailability), employee, date, availabilityType));
-            }
-            shifts.addAll(generateShiftsForDay(date, random));
-        }
-        schedule.getAvailabilities().addAll(availabilities);
-        shifts.forEach(s -> s.setId(Integer.toString(countShift.incrementAndGet())));
-        schedule.getShifts().addAll(shifts);
-    }
-
     private <T> T pickRandom(T[] source, Random random) {
         return source[random.nextInt(source.length)];
     }

use-cases/employee-scheduling/src/main/java/org/acme/employeescheduling/domain/ShiftPinningFilter.java

@@ -1,6 +1,5 @@
 package org.acme.employeescheduling.rest;
 
-import java.time.LocalDate;
 import java.util.Collection;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
@@ -27,7 +26,6 @@
 import ai.timefold.solver.core.api.solver.SolverStatus;
 
 import org.acme.employeescheduling.domain.EmployeeSchedule;
-import org.acme.employeescheduling.domain.ScheduleState;
 import org.acme.employeescheduling.rest.exception.EmployeeScheduleSolverException;
 import org.acme.employeescheduling.rest.exception.ErrorInfo;
 import org.eclipse.microprofile.openapi.annotations.Operation;
@@ -195,39 +193,6 @@ public EmployeeSchedule getStatus(
         return new EmployeeSchedule(schedule.getScore(), solverStatus);
     }
 
-    @Operation(
-            summary = "Publish a schedule.")
-    @APIResponses(value = {
-            @APIResponse(responseCode = "200", description = "The schedule updated.",
-                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
-                            schema = @Schema(implementation = EmployeeSchedule.class))),
-            @APIResponse(responseCode = "404", description = "No schedule found.",
-                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
-                            schema = @Schema(implementation = ErrorInfo.class))),
-            @APIResponse(responseCode = "500", description = "Exception while trying to publish the schedule.",
-                    content = @Content(mediaType = MediaType.APPLICATION_JSON,
-                            schema = @Schema(implementation = ErrorInfo.class)))
-    })
-    @POST
-    @Path("{jobId}/publish")
-    @Produces(MediaType.APPLICATION_JSON)
-    public void
-            publish(@Parameter(description = "The job ID returned by the POST method.") @PathParam("jobId") String jobId) {
-        if (!getStatus(jobId).getSolverStatus().equals(SolverStatus.NOT_SOLVING)) {
-            throw new IllegalStateException("Cannot publish a schedule while solving is in progress.");
-        }
-        EmployeeSchedule schedule = getEmployeeScheduleAndCheckForExceptions(jobId);
-        ScheduleState scheduleState = schedule.getScheduleState();
-        LocalDate newHistoricDate = scheduleState.getFirstDraftDate();
-        LocalDate newDraftDate = scheduleState.getFirstDraftDate().plusDays(scheduleState.getPublishLength());
-
-        scheduleState.setLastHistoricDate(newHistoricDate);
-        scheduleState.setFirstDraftDate(newDraftDate);
-
-        dataGenerator.addDraftShifts(schedule);
-        jobIdToJob.put(jobId, Job.ofSchedule(schedule));
-    }
-
     private record Job(EmployeeSchedule schedule, Throwable exception) {
 
         static Job ofSchedule(EmployeeSchedule schedule) {

use-cases/employee-scheduling/src/main/java/org/acme/employeescheduling/rest/DemoDataGenerator.java

@@ -81,8 +81,11 @@ Constraint oneShiftPerDay(ConstraintFactory constraintFactory) {
 
     Constraint unavailableEmployee(ConstraintFactory constraintFactory) {
         return constraintFactory.forEach(Shift.class)
-                .join(Availability.class, Joiners.equal((Shift shift) -> shift.getStart().toLocalDate(), Availability::getDate),
-                        Joiners.equal(Shift::getEmployee, Availability::getEmployee))
+                .join(Availability.class,
+                        Joiners.equal(Shift::getEmployee, Availability::getEmployee),
+                        Joiners.overlapping(Shift::getStart, Shift::getEnd,
+                                availability -> availability.getDate().atStartOfDay(),
+                                availability -> availability.getDate().plusDays(1).atStartOfDay()))
                 .filter((shift, availability) -> availability.getAvailabilityType() == AvailabilityType.UNAVAILABLE)
                 .penalize(HardSoftScore.ONE_HARD,
                         (shift, availability) -> getShiftDurationInMinutes(shift))
@@ -91,8 +94,11 @@ Constraint unavailableEmployee(ConstraintFactory constraintFactory) {
 
     Constraint desiredDayForEmployee(ConstraintFactory constraintFactory) {
         return constraintFactory.forEach(Shift.class)
-                .join(Availability.class, Joiners.equal((Shift shift) -> shift.getStart().toLocalDate(), Availability::getDate),
-                        Joiners.equal(Shift::getEmployee, Availability::getEmployee))
+                .join(Availability.class,
+                        Joiners.equal(Shift::getEmployee, Availability::getEmployee),
+                        Joiners.overlapping(Shift::getStart, Shift::getEnd,
+                                availability -> availability.getDate().atStartOfDay(),
+                                availability -> availability.getDate().plusDays(1).atStartOfDay()))
                 .filter((shift, availability) -> availability.getAvailabilityType() == AvailabilityType.DESIRED)
                 .reward(HardSoftScore.ONE_SOFT,
                         (shift, availability) -> getShiftDurationInMinutes(shift))
@@ -101,8 +107,12 @@ Constraint desiredDayForEmployee(ConstraintFactory constraintFactory) {
 
     Constraint undesiredDayForEmployee(ConstraintFactory constraintFactory) {
         return constraintFactory.forEach(Shift.class)
-                .join(Availability.class, Joiners.equal((Shift shift) -> shift.getStart().toLocalDate(), Availability::getDate),
-                        Joiners.equal(Shift::getEmployee, Availability::getEmployee))
+                .join(Availability.class,
+                        Joiners.equal(Shift::getEmployee, Availability::getEmployee),
+                        Joiners.overlapping(Shift::getStart, Shift::getEnd,
+                                availability -> availability.getDate().atStartOfDay(),
+                                availability -> availability.getDate().plusDays(1).atStartOfDay())
+                        )
                 .filter((shift, availability) -> availability.getAvailabilityType() == AvailabilityType.UNDESIRED)
                 .penalize(HardSoftScore.ONE_SOFT,
                         (shift, availability) -> getShiftDurationInMinutes(shift))