Resolve optimiser free day conflicts (#4083)

* issue 4072

* Issue # 4072: Fixed duplicating moduleCode-lessonType conflicts for different freeDays chosen

* Issue #4072: typecheck, build, test checks done

* Deleted package-lock.json, recordings to use the uniqueKey, not displayText

* Removed redundant lessonDays code, now using lessonGroups. (#4072)

* nit: rearrange README directory order

---------

Co-authored-by: Leslie Yip <[email protected]>

Author: samthambad

.gitignore

@@ -140,6 +140,8 @@ Temporary Items
 .apdisk
 
 ### Node ###
+package-lock.json
+
 # Logs
 logs
 *.log
@@ -312,4 +314,4 @@ $RECYCLE.BIN/
 # End of https://www.gitignore.io/api/vim,node,linux,macos,emacs,windows,ansible,database,webstorm,visualstudiocode
 
 # asdf versions
-.tool-versions
+.tool-versions

website/README.md

@@ -367,6 +367,7 @@ $ yarn promote-staging  # Promote ./dist to production
 │   │       ├── hocs         - Higher order components
 │   │       ├── layout       - Global layout components
 │   │       ├── modules      - Module finder and module info components
+│   │       ├── optimiser    - Timetable optimiser related components
 │   │       ├── planner      - Module planner related components
 │   │       ├── routes       - Routing related components
 │   │       ├── settings     - Settings page component

website/src/views/optimiser/OptimiserContent.tsx

@@ -13,7 +13,7 @@ import OptimiserHeader from './OptimiserHeader';
 import OptimiserForm from './OptimiserForm';
 import OptimiserButton from './OptimiserButton';
 import OptimiserResults from './OptimiserResults';
-import { LessonOption, LessonDaysData, FreeDayConflict } from './types';
+import { LessonOption, FreeDayConflict } from './types';
 
 const OptimiserContent: React.FC = () => {
   const activeSemester = useSelector(({ app }: State) => app.activeSemester);
@@ -39,6 +39,7 @@ const OptimiserContent: React.FC = () => {
   const [error, setError] = useState<Error | null>(null);
 
   // Generate lesson options from current timetable
+  // find the lesson and the type in lessonOptions, and then find the days of that combination in lessonDaysData
   const lessonOptions = useMemo(() => {
     const options: LessonOption[] = [];
 
@@ -69,71 +70,86 @@ const OptimiserContent: React.FC = () => {
     return options;
   }, [timetable, modules, activeSemester, colors]);
 
-  const lessonDaysData = useMemo(() => {
-    const lessonDays: LessonDaysData[] = [];
-
+  // group by classNo
+  const lessonGroupsData = useMemo(() => {
+    const moduleGroupMap = new Map<string, Map<string, string[]>>();
+    // each item has moduleCode-lessonType, combination, so get all the groups with days for that group
     lessonOptions.forEach((option) => {
       const module = modules[option.moduleCode];
-      if (!module) return;
-
+      // get the timetable so that you can get the groups and the days for that group
       const moduleTimetable = getModuleTimetable(module, activeSemester);
-      const lessonsForType = moduleTimetable.filter(
-        (lesson) => lesson.lessonType === option.lessonType,
-      );
-
-      const days = new Set<string>();
-      lessonsForType.forEach((lesson) => {
-        days.add(lesson.day);
-      });
-      if (days.has('Saturday')) {
-        setHasSaturday(true);
-      }
-      lessonDays.push({
-        uniqueKey: option.uniqueKey,
-        moduleCode: option.moduleCode,
-        lessonType: option.lessonType,
-        displayText: option.displayText,
-        days,
+      // now get the groups and the days for that group
+      // the DS for this is a list of maps, {groupName(string): days(list type)}
+      const groupDayMap = new Map<string, string[]>();
+
+      moduleTimetable.forEach((lesson) => {
+        if (lesson.lessonType === option.lessonType) {
+          if (groupDayMap.has(lesson.classNo)) {
+            // find the the item with that key and push the day to the days array
+            const days = groupDayMap.get(lesson.classNo) || [];
+            days.push(lesson.day);
+            groupDayMap.set(lesson.classNo, days);
+          } else {
+            groupDayMap.set(lesson.classNo, [lesson.day]);
+          }
+        }
       });
+      moduleGroupMap.set(option.uniqueKey, groupDayMap);
+      // now you have all the groups for that module-lessonType combination
     });
-
-    return lessonDays;
+    return moduleGroupMap;
   }, [lessonOptions, modules, activeSemester]);
 
+  // Unselected module-lessonType combinations are recorded lessons `module lessonType`
   const recordings = useMemo(() => {
     const selectedKeys = new Set(selectedLessons.map((lesson) => lesson.uniqueKey));
     return lessonOptions
       .filter((lesson) => !selectedKeys.has(lesson.uniqueKey))
-      .map((lesson) => lesson.displayText);
+      .map((lesson) => lesson.uniqueKey);
   }, [selectedLessons, lessonOptions]);
 
   // Validate free days against non-recorded lessons
   useEffect(() => {
-    const recordingsSet = new Set(recordings);
     const conflicts: FreeDayConflict[] = [];
 
-    // Check each non-recorded lesson (physical lessons that user plans to attend)
-    lessonDaysData.forEach((lessonData) => {
-      // Skip if this lesson is recorded (not attending in person)
-      if (recordingsSet.has(lessonData.displayText)) return;
-
-      // Check if ALL days for this lesson are selected as free days
-      const lessonDaysArray = Array.from(lessonData.days);
-      const conflictingDays = lessonDaysArray.filter((day) => selectedFreeDays.has(day));
-
-      // If all lesson days are selected as free days, it's a conflict
-      if (conflictingDays.length === lessonDaysArray.length && conflictingDays.length > 0) {
+    // check if all groups are not possible to attend, then it's a conflict, then day of conflict is the days of one of the groups
+    // go thorugh each module-lessonType combination, and within that,
+    // go through each group and within that check if any of the selected free days are in them, if so, that group is invalid
+    lessonGroupsData.forEach((groupMap, uniqueKey) => {
+      let validGroups = 0;
+      const groupDays = new Set<string>();
+      groupMap.forEach((days, _groupName) => {
+        if (
+          recordings.includes(uniqueKey) || // if it is a recorded lesson, dont trigger a conflict
+          !days.some((day) => selectedFreeDays.has(day))
+        ) {
+          validGroups += 1;
+        }
+        days.forEach((day) => groupDays.add(day));
+      });
+      if (selectedFreeDays.size > 0 && validGroups === 0) {
+        // check if conflict with the same moduleCode and lessonType already exists, if so, remove the old one and add the new one
+        const existingConflict = conflicts.find(
+          (conflict) =>
+            conflict.moduleCode === uniqueKey.split('-')[0] &&
+            conflict.lessonType === uniqueKey.split('-')[1],
+        );
+        if (existingConflict) {
+          conflicts.splice(conflicts.indexOf(existingConflict), 1);
+        }
+        if (groupDays.has('Saturday')) {
+          setHasSaturday(true);
+        }
         conflicts.push({
-          moduleCode: lessonData.moduleCode,
-          lessonType: lessonData.lessonType,
-          displayText: lessonData.displayText,
-          conflictingDays,
+          moduleCode: uniqueKey.split('-')[0],
+          lessonType: uniqueKey.split('-')[1],
+          displayText: uniqueKey.split('-').join(' '),
+          conflictingDays: Array.from(selectedFreeDays).filter((day) => groupDays.has(day)),
         });
       }
     });
-
     setFreeDayConflicts(conflicts);
-  }, [selectedFreeDays, lessonDaysData, recordings]);
+  }, [selectedFreeDays, lessonGroupsData, recordings]);
 
   useEffect(() => {
     const availableKeys = new Set(lessonOptions.map((option) => option.uniqueKey));

website/src/views/optimiser/OptimiserForm.tsx

@@ -2,6 +2,7 @@ import React, { useCallback } from 'react';
 import classnames from 'classnames';
 import { Info, X, AlertTriangle } from 'react-feather';
 import Tooltip from 'views/components/Tooltip';
+import { WorkingDays, Day } from 'types/modules';
 import { LessonOption, FreeDayConflict } from './types';
 import styles from './OptimiserForm.scss';
 
@@ -189,8 +190,11 @@ const OptimiserForm: React.FC<OptimiserFormProps> = ({
           </div>
           {freeDayConflicts.map((conflict, index) => (
             <div key={index} className={styles.conflictItem}>
-              • <strong>{conflict.displayText}</strong> happens on:{' '}
-              {conflict.conflictingDays.join(', ')}
+              • <strong>{conflict.displayText}</strong> cannot be assigned due to your free days:{' '}
+              {conflict.conflictingDays
+                .filter((d): d is Day => WorkingDays.includes(d as Day))
+                .sort((a, b) => WorkingDays.indexOf(a as Day) - WorkingDays.indexOf(b as Day))
+                .join(', ')}
             </div>
           ))}
           <div className={styles.conflictFooter}>

website/src/views/optimiser/types.ts

@@ -16,6 +16,15 @@ export interface LessonDaysData {
   days: Set<string>;
 }
 
+export interface LessonGroupData {
+  groupName: string;
+  lessonType: LessonType;
+  moduleCode: ModuleCode;
+  displayText: string;
+  classNo: string;
+  days: Set<string>;
+}
+
 export interface FreeDayConflict {
   moduleCode: ModuleCode;
   lessonType: LessonType;