Merge pull request #106 from Maurice2n97/Code-Quality-Refactoring

Code quality refactoring

Author: Maurice2n97

src/main/java/seedu/address/model/schedule/SchedulableUtil.java

@@ -0,0 +1,130 @@
+package seedu.address.model.schedule;
+
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A class to manipulate schedulables, like shifting a schedulable by a certain offset,
+ * or finding overlap between schedulable objects.
+ */
+public class SchedulableUtil {
+
+    /**
+     * Splits a schedulable into multiple schedulables on different days. For example if a schedulable is scheduled
+     * on friday 2pm  to Sunday 2pm, it should split into schedulables
+     * [fri 2pm- fri 11.59.99999pm, sat 12am - sat 11.59.999999 pm , sunday 12am - 2pm]
+     * @param schedulable
+     * @return
+     */
+
+    public static List<Schedulable> splitSchedulableByDay(Schedulable schedulable) {
+
+        LocalDateTime startDateTime = schedulable.getStartLocalDateTime();
+        LocalDateTime endDateTime = schedulable.getTerminateLocalDateTime();
+
+        //same day interval.
+        if (startDateTime.toLocalDate().isEqual(endDateTime.toLocalDate())) {
+            return List.of(schedulable);
+        }
+
+        ArrayList<Schedulable> listOfSchedulableUnits = new ArrayList<>();
+        String name = schedulable.getNameString();
+
+        Schedulable firstPeriod = new SimplePeriod(name, startDateTime, getEndOfTheDay(startDateTime));
+        listOfSchedulableUnits.add(firstPeriod);
+
+        //Check if case !endTime == 00:00
+        if (!endDateTime.isEqual(getStartOfTheDay(endDateTime))) {
+            Schedulable lastPeriod = new SimplePeriod(name, getStartOfTheDay(endDateTime), endDateTime);
+            listOfSchedulableUnits.add(lastPeriod);
+        }
+
+        startDateTime = getStartOfTheDay(startDateTime).plusDays(1);
+        endDateTime = getStartOfTheDay(endDateTime);
+
+        //iterate through each day slot in between
+        while(endDateTime.isAfter(startDateTime)) {
+            Schedulable toAdd = new SimplePeriod(name, startDateTime, getEndOfTheDay(startDateTime));
+            listOfSchedulableUnits.add(toAdd);
+            startDateTime = getStartOfTheDay(startDateTime).plusDays(1);
+        }
+
+        return listOfSchedulableUnits;
+    }
+
+
+
+    /**
+     * Applies a positive offset to a Schedulable object by adding a positive number of hours and minutes to its
+     * start and end times.
+     * @param schedulable
+     * @param hourOffset
+     * @param minuteOffset
+     * @return
+     */
+
+    public static Schedulable applyPositiveOffset(Schedulable schedulable, int hourOffset, int minuteOffset) {
+
+        return new SimplePeriod(schedulable.getNameString(),
+                applyPositiveOffset(schedulable.getStartLocalDateTime(), hourOffset, minuteOffset),
+                applyPositiveOffset(schedulable.getTerminateLocalDateTime(), hourOffset, minuteOffset));
+    }
+
+    /**
+     * Applies a negative offset to a Schedulable object by subtracting a positive number of hours and minutes from its
+     * start and end times.
+     * @param schedulable
+     * @param hourOffset
+     * @param minuteOffset
+     * @return
+     */
+
+    public static Schedulable applyNegativeOffset(Schedulable schedulable, int hourOffset, int minuteOffset) {
+        return new SimplePeriod(
+                schedulable.getNameString(),
+                applyNegativeOffset(schedulable.getStartLocalDateTime(), hourOffset, minuteOffset),
+                 applyNegativeOffset(schedulable.getTerminateLocalDateTime(), hourOffset, minuteOffset));
+    }
+
+    /**
+     * Offsets a local date by a negative number of hours and minutes;
+     * @return
+     */
+    public static LocalDateTime applyNegativeOffset(LocalDateTime localDateTime, int hourOffset, int minuteOffset) {
+        return localDateTime.minusHours(hourOffset).minusMinutes(minuteOffset);
+    }
+
+    /**
+     * Offsets a datetime by a positive number of hours and minutes.
+     * in @code{applyOffset}
+     *
+     * @param offSetDateTime
+     * @return
+     */
+    public static LocalDateTime applyPositiveOffset(LocalDateTime offSetDateTime, int hourOffset, int minuteOffset) {
+        return offSetDateTime.plusHours(hourOffset).plusMinutes(minuteOffset);
+    }
+
+
+
+    /**
+     * Gets the local date time of the end of the day, right before 00:00.
+     * @return
+     */
+    public static LocalDateTime getEndOfTheDay(LocalDateTime localDateTime) {
+        return localDateTime.toLocalDate().atTime(LocalTime.MAX);
+    }
+
+    /**
+     * Gets the start of the day at 00:00.
+     * @param localDateTime
+     * @return
+     */
+    public static LocalDateTime getStartOfTheDay(LocalDateTime localDateTime) {
+        return localDateTime.toLocalDate().atTime(0,0);
+    }
+
+
+}

src/main/java/seedu/address/ui/TimetablePlacementPolicy.java

@@ -1,6 +1,7 @@
 package seedu.address.ui;
 
 import seedu.address.model.schedule.Schedulable;
+import seedu.address.model.schedule.SchedulableUtil;
 import seedu.address.model.schedule.SimplePeriod;
 
 import java.time.Duration;
@@ -148,48 +149,11 @@ public double getLengthOfSlot(Schedulable schedulable) {
     public Stream<Schedulable> breakIntoDayUnits(Schedulable schedulable) {
 
         assert test(schedulable);
-        LocalDateTime startDateTime = schedulable.getStartLocalDateTime();
-        LocalDateTime endDateTime = schedulable.getTerminateLocalDateTime();
-
-        //apply offset
-        LocalDateTime offSetStartTime = applyOffset(startDateTime);
-        LocalDateTime offSetEndTime = applyOffset(endDateTime);
-
-        //same day interval.
-        if (offSetStartTime.toLocalDate().isEqual( offSetEndTime.toLocalDate())) {
-            return List.of(schedulable).stream();
-        }
-        //case when returns more than one element.
-        ArrayList<Schedulable> listOfSchedulableUnits = new ArrayList<>();
-        String name = schedulable.getNameString();
-
-        Schedulable firstPeriod = new SimplePeriod(name,
-                removeOffset(offSetStartTime),
-                removeOffset(getEndOfTheDay(offSetStartTime)));
-        listOfSchedulableUnits.add(firstPeriod);
-
-        //Check if case !endTime == 00:00
-        if (!offSetEndTime.isEqual(getStartOfTheDay(offSetEndTime))) {
-            Schedulable lastPeriod = new SimplePeriod(name,
-                    removeOffset(getStartOfTheDay(offSetEndTime)),
-                    removeOffset(offSetEndTime));
-            listOfSchedulableUnits.add(lastPeriod);
-        }
-
-        offSetStartTime = getStartOfTheDay(offSetStartTime).plusDays(1);
-        offSetEndTime = getStartOfTheDay(offSetEndTime);
-
-        //iterate through each day slot in between
-        while(offSetEndTime.isAfter(offSetStartTime)) {
-            Schedulable toAdd = new SimplePeriod(name,
-                    removeOffset(offSetStartTime),
-                    removeOffset(getEndOfTheDay(offSetStartTime)));
-            listOfSchedulableUnits.add(toAdd);
-            offSetStartTime = getStartOfTheDay(offSetStartTime).plusDays(1);
-        }
-
-        return listOfSchedulableUnits
+        Schedulable offSetSchedule = SchedulableUtil.applyNegativeOffset(schedulable, startHour, startMinute);
+        List<Schedulable> splittedSchedulables = SchedulableUtil.splitSchedulableByDay(offSetSchedule);
+        return splittedSchedulables
                 .stream()
+                .map(s -> SchedulableUtil.applyPositiveOffset(s, startHour, startMinute))
                 .filter(this :: test);
 
     }