Ty/scrum 52 timetable generation (#81)

Co-authored-by: dawangk <[email protected]>

Author: thomasyzy7

course-matrix/backend/__tests__/canInsert.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it, test } from "@jest/globals";
+
+import { createOffering, canInsert } from "../src/utils/generatorHelpers";
+import { Offering } from "../src/types/generatorTypes";
+
+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
+  });
+});

course-matrix/backend/__tests__/getFrequencyTable.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it, test } from "@jest/globals";
+
+import {
+  createOffering,
+  getFrequencyTable,
+} from "../src/utils/generatorHelpers";
+import { Offering } from "../src/types/generatorTypes";
+
+describe("getFrequencyTable", () => {
+  test("should return a frequency map of days", () => {
+    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: "TU",
+      start: "10:00:00",
+      end: "11:00:00",
+    });
+    const offering3: Offering = createOffering({
+      id: 3,
+      course_id: 103,
+      day: "TU",
+      start: "11:00:00",
+      end: "12:00:00",
+    });
+    const offering4: Offering = createOffering({
+      id: 4,
+      course_id: 104,
+      day: "MO",
+      start: "11:00:00",
+      end: "12:00:00",
+    });
+    const offering5: Offering = createOffering({
+      id: 5,
+      course_id: 105,
+      day: "WE",
+      start: "11:00:00",
+      end: "12:00:00",
+    });
+    const offering6: Offering = createOffering({
+      id: 6,
+      course_id: 106,
+      day: "WE",
+      start: "11:00:00",
+      end: "12:00:00",
+    });
+    const offering7: Offering = createOffering({
+      id: 7,
+      course_id: 107,
+      day: "WE",
+      start: "11:00:00",
+      end: "12:00:00",
+    });
+
+    const result = getFrequencyTable([
+      offering1,
+      offering2,
+      offering3,
+      offering4,
+      offering5,
+      offering6,
+      offering7,
+    ]);
+
+    expect(result.get("MO")).toBe(2);
+    expect(result.get("TU")).toBe(2);
+    expect(result.get("WE")).toBe(3);
+    expect(result.get("TH")).toBeUndefined(); // Day not in data
+    expect(result.get("FR")).toBeUndefined(); // Day not in data
+    expect(result.size).toBe(3);
+  });
+
+  test("should return an empty map for an empty array", () => {
+    const result = getFrequencyTable([]);
+    expect(result.size).toBe(0);
+  });
+});

course-matrix/backend/__tests__/isValidOffering.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it, test } from "@jest/globals";
+
+import { createOffering, isValidOffering } from "../src/utils/generatorHelpers";
+import {
+  Offering,
+  Restriction,
+  RestrictionType,
+} from "../src/types/generatorTypes";
+
+describe("isValidOffering", () => {
+  const sampleOffering: Offering = createOffering({
+    id: 1,
+    course_id: 101,
+    day: "MO",
+    start: "10:00:00",
+    end: "11:00:00",
+  });
+
+  test("should allow offering if there are no restrictions", () => {
+    expect(isValidOffering(sampleOffering, [])).toBe(true);
+  });
+
+  test("should allow offering if all restrictions are disabled", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictBefore,
+        days: ["MO"],
+        startTime: "",
+        endTime: "09:00:00",
+        disabled: true,
+        numDays: 0,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(true);
+  });
+
+  test("should reject offering if it starts before restriction start time", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictBefore,
+        days: ["MO"],
+        startTime: "",
+        endTime: "11:00:00",
+        disabled: false,
+        numDays: 0,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(false);
+  });
+
+  test("should reject offering if it ends after restriction end time", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictAfter,
+        days: ["MO"],
+        startTime: "10:30:00",
+        endTime: "",
+        disabled: false,
+        numDays: 0,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(false);
+  });
+
+  test("should reject offering if it is within restricted time range", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictBetween,
+        days: ["MO"],
+        startTime: "09:00:00",
+        endTime: "12:00:00",
+        disabled: false,
+        numDays: 0,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(false);
+  });
+
+  test("should reject offering if the day is restricted", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictDay,
+        days: ["MO"],
+        startTime: "",
+        endTime: "",
+        disabled: false,
+        numDays: 0,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(false);
+  });
+
+  test("should allow offering if the day is not restricted", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictDay,
+        days: ["TU"],
+        startTime: "",
+        endTime: "",
+        disabled: false,
+        numDays: 0,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(true);
+  });
+});

course-matrix/backend/src/controllers/generatorController.ts

@@ -0,0 +1,86 @@
+import exp from "constants";
+import { Request, Response } from "express";
+
+import {
+  Offering,
+  OfferingList,
+  GroupedOfferingList,
+} from "../types/generatorTypes";
+import {
+  getMaxDays,
+  groupOfferings,
+  getValidOfferings,
+  categorizeValidOfferings,
+  trim,
+} from "../utils/generatorHelpers";
+import getOfferings from "../services/getOfferings";
+import { getValidSchedules } from "../services/getValidSchedules";
+
+import asyncHandler from "../middleware/asyncHandler"; // Middleware to handle async route handlers
+
+// Express route handler to generate timetables based on user input
+export default {
+  generateTimetable: asyncHandler(async (req: Request, res: Response) => {
+    try {
+      // Extract event details and course information from the request
+      const { semester, courses, restrictions } = req.body;
+      const courseOfferingsList: OfferingList[] = [];
+      const validCourseOfferingsList: GroupedOfferingList[] = [];
+      const maxdays = await getMaxDays(restrictions);
+      const validSchedules: Offering[][] = [];
+      // Fetch offerings for each course
+      for (const course of courses) {
+        const { id } = course;
+        courseOfferingsList.push({
+          course_id: id,
+          offerings: (await getOfferings(id, semester)) ?? [],
+        });
+      }
+
+      const groupedOfferingsList: GroupedOfferingList[] =
+        await groupOfferings(courseOfferingsList);
+
+      // console.log(JSON.stringify(groupedOfferingsList, null, 2));
+
+      // Filter out invalid offerings based on the restrictions
+      for (const { course_id, groups } of groupedOfferingsList) {
+        validCourseOfferingsList.push({
+          course_id: course_id,
+          groups: await getValidOfferings(groups, restrictions),
+        });
+      }
+
+      const categorizedOfferings = await categorizeValidOfferings(
+        validCourseOfferingsList,
+      );
+
+      // console.log(typeof categorizedOfferings);
+      // console.log(JSON.stringify(categorizedOfferings, null, 2));
+
+      // Generate valid schedules for the given courses and restrictions
+      await getValidSchedules(
+        validSchedules,
+        categorizedOfferings,
+        [],
+        0,
+        categorizedOfferings.length,
+        maxdays,
+      );
+
+      // Return error if no valid schedules are found
+      if (validSchedules.length === 0) {
+        return res.status(404).json({ error: "No valid schedules found." });
+      }
+      // Return the valid schedules
+      return res.status(200).json({
+        amount: validSchedules.length,
+        schedules: trim(validSchedules),
+      });
+    } catch (error) {
+      // Catch any error and return the error message
+      const errorMessage =
+        error instanceof Error ? error.message : "An unknown error occurred";
+      return res.status(500).send({ error: errorMessage });
+    }
+  }),
+};