feat: Course Syllabi Lookup (#89)

* feat: course syllabi json

* feat: basic functionality

* fix: rm unused declaration

* fix: sort by year and season

* fix: remove async functionality

* feat: add note and rm instructor if not found

* fix: 4 digit and 2 digit year value allowed

* fix: tentype issues

* fix: clarify error message when inputting multiple/invalid course codes

---------

Co-authored-by: TenType <55125103+TenType@users.noreply.github.com>

Author: Gostmeaper

src/commands/courses.ts

@@ -14,6 +14,7 @@ import {
     underline,
 } from "discord.js";
 import { FYW_MINIS, SCOTTYLABS_URL } from "../constants.js";
+import SyllabiData from "../data/course-api.syllabi.json" with { type: "json" };
 import CoursesData from "../data/finalCourseJSON.json" with { type: "json" };
 import { parseAndEvaluate } from "../modules/operator-parser.ts";
 import type { SlashCommand } from "../types.d.ts";
@@ -44,6 +45,17 @@ type FCERecord = {
     responseRate: number;
 };
 
+type Syllabus = {
+    _id: {
+        $oid: string;
+    };
+    season: string;
+    year: number;
+    number: string;
+    section: string;
+    url: string;
+};
+
 function loadCoursesData(): Record<string, Course> {
     return CoursesData as Record<string, Course>;
 }
@@ -167,6 +179,40 @@ function loadFCEData(): Record<string, FCEData> {
     return fceMap;
 }
 
+function loadSyllabiData(): Record<string, Syllabus[]> {
+    const syllabiData = SyllabiData as Syllabus[];
+    const syllabi: Record<string, Syllabus[]> = {};
+
+    const seasonOrder: Record<string, number> = {
+        F: 0,
+        S: 1,
+        M: 2,
+        N: 3,
+    };
+
+    for (const entry of syllabiData) {
+        const courseid = formatCourseNumber(entry.number) ?? "";
+        if (!syllabi[courseid]) {
+            syllabi[courseid] = [];
+        }
+        syllabi[courseid].push(entry);
+    }
+
+    for (const courseid in syllabi) {
+        syllabi[courseid]!.sort((a, b) => {
+            if (a.year !== b.year) {
+                return b.year - a.year;
+            }
+
+            return (
+                (seasonOrder[a.season] ?? 99) - (seasonOrder[b.season] ?? 99)
+            );
+        });
+    }
+
+    return syllabi;
+}
+
 const command: SlashCommand = {
     data: new SlashCommandBuilder()
         .setName("courses")
@@ -209,6 +255,19 @@ const command: SlashCommand = {
                         )
                         .setRequired(true),
                 ),
+        )
+        .addSubcommand((subcommand) =>
+            subcommand
+                .setName("syllabus")
+                .setDescription("Get pdfs of syllabi for a course")
+                .addStringOption((option) =>
+                    option
+                        .setName("course_id")
+                        .setDescription(
+                            "Course code in XX-XXX or XXXXX format (e.g., 15-112)",
+                        )
+                        .setRequired(true),
+                ),
         ),
     async execute(interaction) {
         const coursesData = loadCoursesData();
@@ -581,6 +640,99 @@ const command: SlashCommand = {
                 return interaction.reply({ embeds: [embed] });
             }
         }
+        if (interaction.options.getSubcommand() === "syllabus") {
+            const convertSem: Record<string, string> = {
+                F: "Fall",
+                S: "Spring",
+                M: "Summer",
+                N: "Summer",
+            };
+
+            const syllabi = loadSyllabiData();
+            const fceData = loadFCEData();
+
+            const courseid = formatCourseNumber(
+                interaction.options.getString("course_id", true),
+            );
+
+            if (!courseid) {
+                return interaction.reply({
+                    content:
+                        "Please provide a valid course code in the format XX-XXX or XXXXX.",
+                    flags: MessageFlags.Ephemeral,
+                });
+            }
+
+            const course = coursesData[courseid];
+
+            if (!syllabi[courseid] || !course) {
+                return interaction.reply({
+                    content: `Course ${courseid} not found.`,
+                    flags: MessageFlags.Ephemeral,
+                });
+            }
+            let foundSyllabi = syllabi[courseid];
+
+            const uniqueSyllabi = [
+                ...new Map(foundSyllabi.map((s) => [s.url, s])).values(),
+            ];
+
+            const embeds: EmbedBuilder[] = [];
+            let currentDesc = "";
+
+            let links = 0;
+
+            for (const syllabus of uniqueSyllabi) {
+                /*
+                Currently this uses fce data to find instructor data
+                However, syllabi data should be updated to include instructor,
+                and courses data should be changed to correctly include
+                syllabi and session as intended
+                */
+
+                let fceRec = fceData[courseid]?.records ?? [];
+                let fceEntry = undefined;
+
+                for (const rec of fceRec) {
+                    // Rec.year and Syllabus.year will both be 2 digits
+                    if (
+                        rec.semester == convertSem[syllabus.season] &&
+                        rec.year == syllabus.year + 2000 &&
+                        rec.section == syllabus.section
+                    ) {
+                        fceEntry = rec;
+                    }
+                }
+                const line: string = hyperlink(
+                    `${syllabus.season}${syllabus.year}: ${syllabus.number}-${syllabus.section} ${fceEntry?.instructor ? `(${fceEntry?.instructor})` : ""} \n`,
+                    `${syllabus.url}`,
+                );
+                if (links >= 20) {
+                    embeds.push(
+                        new EmbedBuilder()
+                            .setTitle(`Syllabi for ${courseid}: ${course.name}`)
+                            .setURL(`${SCOTTYLABS_URL}/course/${courseid}`)
+                            .setDescription(currentDesc),
+                    );
+                    currentDesc = line;
+                    links = 1;
+                } else {
+                    currentDesc += line;
+                    links++;
+                }
+            }
+
+            if (currentDesc) {
+                embeds.push(
+                    new EmbedBuilder()
+                        .setTitle(`Syllabi for ${courseid}: ${course.name}`)
+                        .setURL(`${SCOTTYLABS_URL}/course/${courseid}`)
+                        .setDescription(currentDesc),
+                );
+            }
+
+            return new EmbedPaginator(embeds).send(interaction);
+        }
     },
 };