First draft of timetable generation

thomasyzy7 · thomasyzy7 · commit ee1ae6216580 · 2025-03-17T08:07:47.000-04:00
Testing and tweaking needed.
diff --git a/course-matrix/backend/__tests__/canInsert.test.ts b/course-matrix/backend/__tests__/canInsert.test.ts
@@ -0,0 +1,104 @@
+import {describe, expect, it, test} from '@jest/globals';
+
+import {canInsert, createOffering, Offering} from '../src/controllers/generatorController';
+
+describe('canInsert function', () => {
+  const offering1: Offering = createOffering(
+      {id: 1, course_id: 101, day: 'MO', start: '09:00:00', end: '10:00:00'});
+  const offering2: Offering = createOffering(
+      {id: 2, course_id: 102, day: 'MO', start: '10:00:00', end: '11:00:00'});
+  const offering3: Offering = createOffering(
+      {id: 3, course_id: 103, day: 'MO', start: '11:00:00', end: '12:00:00'});
+
+  it('should return true if there is no overlap with existing offerings',
+     async () => {
+       const toInsert: Offering = createOffering({
+         id: 4,
+         course_id: 104,
+         day: 'MO',
+         start: '12:00:00',
+         end: '13:00:00'
+       });
+       const curList: Offering[] = [offering1, offering2, offering3];
+
+       const result = await canInsert(toInsert, curList);
+
+       expect(result).toBe(true);  // No overlap, should return true
+     });
+
+  it('should return false if there is an overlap with an existing offering',
+     async () => {
+       const toInsert: Offering = createOffering({
+         id: 4,
+         course_id: 104,
+         day: 'MO',
+         start: '09:30:00',
+         end: '10:30:00'
+       });
+       const curList: Offering[] = [offering1, offering2, offering3];
+
+       const result = await canInsert(toInsert, curList);
+
+       expect(result).toBe(
+           false);  // There is an overlap with offering1, should return false
+     });
+
+  it('should return true if the new offering starts after the last one ends',
+     async () => {
+       const toInsert: Offering = createOffering({
+         id: 4,
+         course_id: 104,
+         day: 'MO',
+         start: '13:00:00',
+         end: '14:00:00'
+       });
+       const curList: Offering[] = [offering1, offering2, offering3];
+
+       const result = await canInsert(toInsert, curList);
+
+       expect(result).toBe(true);  // No overlap, should return true
+     });
+
+  it('should return true if the new offering ends before the first one starts',
+     async () => {
+       const toInsert: Offering = createOffering({
+         id: 4,
+         course_id: 104,
+         day: 'MO',
+         start: '07:00:00',
+         end: '08:00:00'
+       });
+       const curList: Offering[] = [offering1, offering2, offering3];
+
+       const result = await canInsert(toInsert, curList);
+
+       expect(result).toBe(true);  // No overlap, should return true
+     });
+
+  it('should return false if the new offering is completely inside an existing one',
+     async () => {
+       const toInsert: Offering = createOffering({
+         id: 4,
+         course_id: 104,
+         day: 'MO',
+         start: '09:30:00',
+         end: '09:45:00'
+       });
+       const curList: Offering[] = [offering1, offering2, offering3];
+
+       const result = await canInsert(toInsert, curList);
+
+       expect(result).toBe(
+           false);  // Overlaps with offering1, should return false
+     });
+
+  it('should return true if the day is different (no overlap)', async () => {
+    const toInsert: Offering = createOffering(
+        {id: 4, course_id: 104, day: 'TU', start: '09:00:00', end: '10:00:00'});
+    const curList: Offering[] = [offering1, offering2, offering3];
+
+    const result = await canInsert(toInsert, curList);
+
+    expect(result).toBe(true);  // Different day, no overlap
+  });
+});
diff --git a/course-matrix/backend/src/controllers/generatorController.ts b/course-matrix/backend/src/controllers/generatorController.ts
@@ -3,7 +3,66 @@ import {Request, Response} from 'express';
 import {supabase} from '../db/setupDb';
 import asyncHandler from '../middleware/asyncHandler';
 
-async function getOfferings(course_id: number, semester: string) {
+export interface Offering {
+  id: number;
+  course_id: number;
+  meeting_section: string;
+  offering: string;
+  day: string;
+  start: string;
+  end: string;
+  location: string;
+  current: number;
+  max: number;
+  is_waitlisted: boolean;
+  delivery_mode: string;
+  instructor: string;
+  notes: string;
+  code: string;
+}
+
+export function createOffering(overrides: Partial<Offering> = {}): Offering {
+  return {
+    id: overrides.id ?? -1,
+    course_id: overrides.course_id ?? -1,
+    meeting_section: overrides.meeting_section ?? 'No Section',
+    offering: overrides.offering ?? 'No Offering',
+    day: overrides.day ?? 'N/A',
+    start: overrides.start ?? '00:00:00',
+    end: overrides.end ?? '00:00:00',
+    location: overrides.location ?? 'No Room',
+    current: overrides.current ?? -1,
+    max: overrides.max ?? -1,
+    is_waitlisted: overrides.is_waitlisted ?? false,
+    delivery_mode: overrides.delivery_mode ?? 'N/A',
+    instructor: overrides.instructor ?? 'N/A',
+    notes: overrides.notes ?? 'N/A',
+    code: overrides.code ?? 'N/A',
+  };
+}
+
+export enum RestrictionType {
+  RestrictBefore = 'Restrict Before',
+  RestrictAfter = 'Restrict After',
+  RestrictBetween = 'Restrict Between',
+  RestrictDay = 'Restrict Day',
+  RestrictDaysOff = 'Days Off'
+}
+
+export interface Restriction {
+  type: RestrictionType;
+  days: string[];
+  startTime: string;
+  endTime: string;
+  disabled: boolean;
+}
+
+export interface OfferingList {
+  course_id: number;
+  offerings: Offering[];
+}
+
+export async function getOfferings(course_id: number, semester: string) {
   let {data: offeringData, error: offeringError} = await supabase
                                                        .schema('course')
                                                        .from('offerings')
@@ -29,23 +88,123 @@ async function getOfferings(course_id: number, semester: string) {
 }
 
 
+
+export const filterValidOfferings =
+    (offerings: Offering[], f: (x: Offering) => boolean):
+        Offering[] => {
+          return offerings.filter(f);
+        }
+
+export function isValidOffering(
+    offering: Offering, restrictions: Restriction[]) {
+  for (const restriction of restrictions) {
+    if (restriction.disabled) continue;
+
+    switch (restriction.type) {
+      case RestrictionType.RestrictBefore:
+        if (offering.start < restriction.startTime) return false;
+        break;
+
+      case RestrictionType.RestrictAfter:
+        if (offering.end > restriction.endTime) return false;
+        break;
+
+      case RestrictionType.RestrictBetween:
+        if (offering.start >= restriction.startTime &&
+            offering.end <= restriction.endTime) {
+          return false;
+        }
+        break;
+      case RestrictionType.RestrictDay:
+        if (restriction.days.includes(offering.day)) {
+          return false;
+        }
+        break;
+    }
+  }
+  return true;
+}
+
+export async function getValidOfferings(
+    offerings: Offering[], restrictions: Restriction[]) {
+  return filterValidOfferings(offerings, x => isValidOffering(x, restrictions));
+}
+
+export async function canInsert(toInsert: Offering, curList: Offering[]) {
+  for (const offering of curList) {
+    if (offering.day == toInsert.day) {
+      if (offering.start < toInsert.end && toInsert.start < offering.end) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+export async function getValidSchedules(
+    courseOfferingsList: OfferingList[], curList: Offering[], cur: number,
+    len: number):
+    Promise<Offering[][]> {
+      if (cur == len) return [curList];
+
+      const validSchedules: Offering[][] = [];
+
+      const offeringsForCourse = courseOfferingsList[cur];
+
+      for (const offering of offeringsForCourse.offerings) {
+        if (await canInsert(offering, curList)) {
+          curList.push(offering);
+          // Recursively call the function for the next course
+          const res: Offering[][] = await getValidSchedules(
+              courseOfferingsList, curList, cur + 1, len);
+
+          // If a valid schedule is found, return it
+          validSchedules.push(...res);
+
+          // If no valid schedule is found, pop the offering and continue
+          curList.pop();
+        }
+      }
+
+      // If no valid schedule is found for this course, return null
+      return validSchedules;
+    }
+
 export default {
   generateTimetable: asyncHandler(async (req: Request, res: Response) => {
     try {
       // Retrieve event properties from the request body
       const {name, date, semester, search, courses, restrictions} = req.body;
-      const courseOfferingsList = [];
+      const courseOfferingsList: OfferingList[] = [];
+      const validCourseOfferingsList: OfferingList[] = [];
       // Retrieve the authenticated user
       const user_id = (req as any).user.id;
 
       // extracting offerings from each course
       for (const course of courses) {
         const {id, code, name} = course;
         courseOfferingsList.push(
-            {course_id: id, offerings: await getOfferings(id, semester)});
+            {course_id: id, offerings: await getOfferings(id, semester) ?? []});
       }
+      courseOfferingsList.forEach(
+          course => console.log(JSON.stringify(course, null, 2)));
 
-      return res.status(200).json(courseOfferingsList);
+      // filter out invalid course entries
+      for (const {course_id, offerings} of courseOfferingsList) {
+        validCourseOfferingsList.push({
+          course_id: course_id,
+          offerings: await getValidOfferings(offerings ?? [], restrictions)
+        });
+      }
+
+      const validSchedules = await getValidSchedules(
+          validCourseOfferingsList, [], 0, validCourseOfferingsList.length);
+
+      if (validSchedules.length === 0) {
+        return res.status(404).json({error: 'No valid schedules found.'});
+      }
+      return res.status(200).json({validSchedules});
     } catch (error) {
       return res.status(500).send({error});
     }
