Assigning Lessons longer than Timeslot duration in Timefold/Optaplanner

Question

This is my problem description:

1. There is a list of Timeslot from Monday - Friday, starting from 8:00am to 4:00pm. Each timeslot is 1 hour
2. There is a list of Lesson that can be 1 hour or 2 hours long (in reality this can be anything, I'm trying to simplify the problem here)

What I'm trying to do is, for every Lesson with a duration longer than the Timeslot (1 hour), I need to assign consecutive Timeslots to the Lesson, or at least mark the other two as unusable.

What I want to achieve for example:

• Lesson("0", Physics, Lab, 3Hours) -> Monday(8am - 9am), Monday(9am - 10am), Monday(10am - 11am)

What I've Tried (was not successful)

1. Split the 3 hour Lesson into 1 hour chunks

• Lesson("0", Physics, Lab, 3Hours) becomes Lesson("0_0", Physics, Lab, 1Hour), Lesson("0_1", Physics, Lab, 1Hour), Lesson("0_2", Physics, Lab, 1Hour)
• Where each Lesson "chunk" has a pointer to the next "chunk" (like a linked list)
• Add a constraint to check whether each chunk's Timeslots are consecutive - this failed because sometimes Timeslot is null, I'm assuming this happens because I'm using Timefold the wrong way.

2. Use Joiners.overlapping

• In my ConstraintProvider implementation, I replaced Joiners.equal(Lesson::getTimeslot) with Joiners.overlapping but still got overlapping schedules and negative hard scores

Constraint roomConflict(ConstraintFactory constraintFactory) {
        // A room can accommodate at most one lesson at the same time.
        return constraintFactory
                // Select each pair of 2 different lessons ...
                .forEachUniquePair(Lesson.class,
                        Joiners.overlapping(
                                (a) -> a.getTimeslot().getStartTime(),
                                (a) -> a.getTimeslot().getEndTime(),
                                (b) -> b.getTimeslot().getStartTime(),
                                (b) -> b.getTimeslot().getEndTime()
                        ),
                        // originally, only check for "same timeslot" instead of overlapping time
                        //Joiners.equal(Lesson::getTimeslot),
                        // ... in the same room ...
                        Joiners.equal(Lesson::getRoom))
                // ... and penalize each pair with a hard weight.
                .penalize(HardSoftScore.ONE_HARD)
                .justifyWith((lesson1, lesson2, score) -> new RoomConflictJustification(lesson1.getRoom(), lesson1, lesson2))
                .asConstraint("Room conflict");
    }

My code (methods removed for brevity):

@PlanningSolution
public class Timetable {

    private String name;

    @ProblemFactCollectionProperty
    @ValueRangeProvider
    private List<Timeslot> timeslots;

    @ProblemFactCollectionProperty
    @ValueRangeProvider
    private List<Room> rooms;

    @PlanningEntityCollectionProperty
    private List<Lesson> lessons;

    @PlanningScore
    private HardSoftScore score;

    // Ignored by Timefold, used by the UI to display solve or stop solving button
    private SolverStatus solverStatus;
}

public class Timeslot {

    @PlanningId
    private String id;

    private DayOfWeek dayOfWeek;
    private LocalTime startTime;
    private Duration duration;
}

@Entity
public class Room {

    @PlanningId
    @GeneratedValue
    @Id
    private Long id;

    private String name;
}

@PlanningEntity
public class Lesson {

    @PlanningId
    private String id;

    private String subject;
    private String teacher;
    private String studentGroup;

    @JsonIdentityReference
    @PlanningVariable
    private Timeslot timeslot;

    @JsonIdentityReference
    @PlanningVariable
    private Room room;

    private String activity;
    private Duration duration = Duration.ofHours(1L);
}