Help with timefold constraint stream type mismatches in employee scheduling

[golang982]

I'm working on an employee scheduling system (repo here) using Timefold, and I'm running into type mismatch issues with my constraint streams. Specifically, I'm trying to implement a work percentage constraint that ensures employees are scheduled according to their preferred work percentage.

Here's my current implementation:

public Constraint workPercentage(ConstraintFactory constraintFactory) {
    return constraintFactory.forEach(Employee.class)
            .join(Shift.class, equal(Employee::getName, Shift::getEmployee))
            .groupBy(Employee::getName, 
                    ConstraintCollectors.sum(shift -> 
                        Duration.between(shift.getStart(), shift.getEnd()).toHours()))
            .filter((employeeId, totalWorkedHours) -> {
                double fullTimeHours = 40.0;
                double desiredHours = employeeId.getWorkPercentage() * fullTimeHours;
                return totalWorkedHours != desiredHours;
            })
            .penalize(HardSoftBigDecimalScore.ONE_SOFT)
            .asConstraint("Employee work percentage not matched");
}

I'm getting several type mismatch errors:

1. The groupBy method is expecting BiConstraintCollector<Employee,Shift,ResultContainerA_,ResultA_> but getting UniConstraintCollector<Object,?,Integer>
2. The lambda in the sum collector can't resolve getStart() and getEnd() methods because it's seeing the parameter as Object instead of Shift
3. The functional interface type mismatch for Employee::getName

My domain classes are structured as follows:

@PlanningSolution
public class EmployeeSchedule {
    @ProblemFactCollectionProperty
    @ValueRangeProvider
    private List<Employee> employees;

    @PlanningEntityCollectionProperty
    private List<Shift> shifts;

    @PlanningScore
    private HardSoftBigDecimalScore score;
    // ... getters and setters
}

public class Employee {
    @PlanningId
    private String name;
    private Set<String> skills;
    private ShiftPreference shiftPreference;
    private int workPercentage; // Percentage of full-time hours
    // ... getters and setters
}

@PlanningEntity
public class Shift {
    @PlanningId
    private String id;
    private LocalDateTime start;
    private LocalDateTime end;
    private String location;
    private String requiredSkill;
    
    @PlanningVariable
    private Employee employee;
    // ... getters and setters
}

For context, other constraints in my system work fine. For example, this similar constraint for shift preferences works without type issues:

public Constraint shiftPreference(ConstraintFactory constraintFactory) {
    return constraintFactory.forEach(Shift.class)
            .join(Employee.class, equal(Shift::getEmployee, Function.identity()))
            .filter((shift, employee) -> !shift.getShiftType().equals(employee.getShiftPreference().name()))
            .penalize(HardSoftBigDecimalScore.ONE_SOFT)
            .asConstraint("Shift preference not matched");
}

I'm using Timefold 1.19.0 with Quarkus, and my solver configuration is standard:

<solver>
    <solutionClass>com.example.domain.Schedule</solutionClass>
    <entityClass>com.example.domain.ShiftAssignment</entityClass>
    <scoreDirectorFactory>
        <constraintProviderClass>com.example.solver.EmployeeSchedulingConstraintProvider</constraintProviderClass>
    </scoreDirectorFactory>
    <termination>
        <secondsSpentLimit>10</secondsSpentLimit>
    </termination>
</solver>

Has anyone encountered similar issues with constraint streams and grouping operations? What's the correct way to handle these type parameters?

Any help would be greatly appreciated!

[golang982]

After getting some help, I changed my implementation from:

return constraintFactory.forEach(Employee.class)
        .join(Shift.class, equal(Employee::getName, Shift::getEmployee))
        .groupBy(Employee::getName, 
                ConstraintCollectors.sum(shift -> 
                    Duration.between(shift.getStart(), shift.getEnd()).toHours()))

to:

return constraintFactory.forEach(Employee.class)
        .join(Shift.class, equal(Employee::getName, Shift::getEmployee))
        .groupBy(
                (employee, shift) -> employee,  // Changed to BiFunction
                ConstraintCollectors.sum((employee, shift) -> 
                    (int) Duration.between(shift.getStart(), shift.getEnd()).toHours())
            )

The key changes were:

1. Changed Employee::getName to (employee, shift) -> employee to properly handle the BiFunction type
2. Modified the sum collector to use both parameters (employee, shift) instead of just shift
3. Added an (int) cast to handle the long return type from Duration.toHours()

This resolved all the type mismatch errors, but I have two questions:

1. Since my Employee class has @PlanningId on the name field:

public class Employee {
    @PlanningId
    private String name;
    private int workPercentage;
    // ...
}

Should I be grouping by the entire employee object, or would it be better to use (employee, shift) -> employee.getName()?

2. Is casting the Duration.toHours() result to int the right approach? I'm using it because my workPercentage is an integer percentage (0-100).

The constraint works now, but I want to make sure I'm following best practices. Any insights would be appreciated!

[TomCools]

Should I be grouping by the entire employee object, or would it be better to use (employee, shift) -> employee.getName()?

I don't think it matters all that much as you are basically passing a pointer to a Java object.

Is casting the Duration.toHours() result to int the right approach? I'm using it because my workPercentage is an integer percentage (0-100).

I do not know the the performance impact of Duration.toHours() and having it evaluate every time together with the constraint. I would assume you'll be fine here. You might opt to make the desiredHours a problem fact instead of calculating it each time.

[Christopher-Chianelli]

There is also a ConstraintCollectors.sumDuration method, which will be more accurate if shifts are not exact multiples of hours (ex: 30min shift, 1:30min shift, etc.)

[triceo]

My colleagues have already said most of what needs to be said. I'll only suggest that you ask yourself what should happen to employees with no shifts.

Are you intentionally excluding them from the calculation? If so, don't change anything.
If they should count as 0 hours instead, you should use .complement(...) after your .groupBy(...) to make sure these employees are included. Otherwise they won't be, as the join is an inner join - it only includes Employees which have some Shifts.