Setting up helper functions for flowchart ai

server/src/db/models/courses/courseServices.ts

@@ -8,6 +8,9 @@
   CourseDocument,
   CourseObject,
   FormattedGeCourses,
+  TechElectiveDocument,
+  TechElective,
+  TechElectiveData,
 } from "@polylink/shared/types";
 import * as geCollection from "./geCollection";
 import { MongoQuery } from "../../../types/mongo";
@@ -517,3 +520,22 @@
     throw error;
   }
 };
+
+export const getTechElectivesCourses = async (
+  code: string
+): Promise<TechElectiveData> => {
+  if (!code) {
+    throw new Error("Code is required");
+  }
+  try {
+    const techElectives =
+      await techElectiveCollection.findTechElectiveCourses(code);
+
+    return techElectives;
+  } catch (error) {
+    if (environment === "dev") {
+      console.error("Error fetching tech electives courses: ", error);
+    }
+    throw error;
+  }
+};

server/src/db/models/flowchart/flowchartHelpers.ts

@@ -0,0 +1,47 @@
+export const TERM_MAP = {
+  "-1": "Skip",
+  1: "Fall",
+  2: "Winter",
+  3: "Spring",
+  5: "Fall",
+  6: "Winter",
+  7: "Spring",
+  9: "Fall",
+  10: "Winter",
+  11: "Spring",
+  13: "Fall",
+  14: "Winter",
+  15: "Spring",
+  17: "Fall",
+  18: "Winter",
+  19: "Spring",
+  21: "Fall",
+  22: "Winter",
+  23: "Spring",
+  25: "Fall",
+  26: "Winter",
+  27: "Spring",
+  29: "Fall",
+  30: "Winter",
+  31: "Spring",
+};
+
+export const getCatalogYear = (shortCatalogYear?: string): string => {
+  const catalogYear = shortCatalogYear?.split(".")[0];
+  if (!catalogYear) {
+    return "2022-2026"; // Default catalog year
+  }
+
+  switch (catalogYear) {
+    case "19-20":
+      return "2019-2020";
+    case "20-21":
+      return "2020-2021";
+    case "21-22":
+      return "2021-2022";
+    case "22-26":
+      return "2022-2026";
+    default:
+      return "2022-2026"; // Default catalog year
+  }
+};

server/src/db/models/flowchart/flowchartServices.ts

@@ -11,6 +11,7 @@ import {
   FetchedFlowchartObject,
   FetchFlowchartResponse,
   FlowchartData,
+  FlowchartDocument,
 } from "@polylink/shared/types";
 import { BulkWriteResult } from "mongodb";
 import { environment } from "../../../index";
@@ -270,15 +271,18 @@ export const isPrimaryFlowchart = async (
 
 export const fetchPrimaryFlowchart = async (
   userId: string
-): Promise<FlowchartData> => {
+): Promise<FlowchartData | null> => {
   try {
     const primaryFlowchart = await flowchartModel.fetchPrimaryFlowchart(userId);
     if (!primaryFlowchart) {
       // Fetch any flowchart
       const flowchartList = await fetchAllFlowcharts(userId);
       const anyFlowchart = flowchartList[0];
       if (!anyFlowchart) {
-        throw new Error("No flowcharts found");
+        if (environment === "dev") {
+          console.error("No flowcharts found");
+        }
+        return null;
       }
       const flowchart = await fetchFlowchart(anyFlowchart.flowchartId, userId);
       return flowchart.flowchartData;
@@ -290,3 +294,33 @@ export const fetchPrimaryFlowchart = async (
     );
   }
 };
+
+export const fetchPrimaryFlowchartDoc = async (
+  userId: string
+): Promise<FlowchartDocument | null> => {
+  try {
+    const primaryFlowchart = await flowchartModel.fetchPrimaryFlowchart(userId);
+    if (!primaryFlowchart) {
+      // Fetch any flowchart
+      const flowchartList = await fetchAllFlowcharts(userId);
+      const anyFlowchart = flowchartList[0];
+      if (!anyFlowchart) {
+        if (environment === "dev") {
+          console.error("No flowcharts found");
+        }
+        return null;
+      }
+      const flowchart = await flowchartModel.fetchFlowchart(
+        anyFlowchart.flowchartId,
+        userId
+      );
+      return flowchart;
+    }
+    return primaryFlowchart;
+  } catch (error) {
+    if (environment === "dev") {
+      console.error("Error fetching primary flowchart:", error);
+    }
+    return null;
+  }
+};

server/src/db/models/section/sectionServices.ts

@@ -463,5 +463,9 @@ export async function getSectionsByCourseIds(
 
   const result = await getSectionsByFilter(filter, userId, 0, 25);
 
-  return result.sections;
+  return result.sections.sort((a, b) => {
+    const aRating = a.instructorsWithRatings?.[0]?.overallRating || 0;
+    const bRating = b.instructorsWithRatings?.[0]?.overallRating || 0;
+    return bRating - aRating;
+  });
 }

server/src/helpers/assistants/scheduleBuilder/helpers.ts

@@ -12,8 +12,12 @@ import {
   SelectedSection,
   ProfessorRatingDocument,
   SectionAddedOrRemoved,
+  AcademicPlan,
 } from "@polylink/shared/types";
-import { fetchPrimaryFlowchart } from "../../../db/models/flowchart/flowchartServices";
+import {
+  fetchPrimaryFlowchart,
+  fetchPrimaryFlowchartDoc,
+} from "../../../db/models/flowchart/flowchartServices";
 import {
   getSectionsByCourseIds,
   getSectionsByIds,
@@ -30,6 +34,18 @@ import {
   SUGGESTED_SECTIONS_PER_COURSE,
   POTENTIAL_SECTIONS_PER_COURSE,
 } from "./const";
+import {
+  getCatalogYear,
+  TERM_MAP,
+} from "../../../db/models/flowchart/flowchartHelpers";
+import {
+  getGeCourses,
+  getGeSubjects,
+} from "../../../db/models/courses/courseServices";
+import {
+  getGeAreas,
+  getTechElectivesCourses,
+} from "../../../db/models/courses/courseServices";
 
 export const getAlternateSections = async ({
   userId,
@@ -88,7 +104,12 @@ export const getUserNextEligibleSections = async ({
   potentialSectionsClassNums: number[];
 }> => {
   const flowchart = await fetchPrimaryFlowchart(userId);
-
+  if (!flowchart) {
+    return {
+      suggestedSections: [],
+      potentialSectionsClassNums: [],
+    };
+  }
   // Sort terms by tIndex
   const terms = (flowchart.termData || []).sort(
     (a: Term, b: Term) => a.tIndex - b.tIndex
@@ -596,3 +617,142 @@ export async function buildSectionSummaries(
   });
   return summaries;
 }
+
+export async function getFlowchartSummary(
+  userId: string
+): Promise<AcademicPlan | null> {
+  const flowchart = await fetchPrimaryFlowchartDoc(userId);
+
+  if (!flowchart) {
+    return null;
+  }
+
+  const startYear =
+    flowchart.flowchartData.startYear === "incoming-transfer"
+      ? 2024
+      : parseInt(flowchart.flowchartData.startYear);
+
+  let summary = `Academic Plan Summary for ${flowchart.flowInfo.majorName} with ${flowchart.flowInfo.concName}concentration\n\n`;
+
+  // Process each term
+  const termSummary = flowchart.flowchartData.termData.map((term) => {
+    const termNumber = term.tIndex;
+    const termName = TERM_MAP[termNumber as keyof typeof TERM_MAP];
+    const baseYearOffset = Math.floor((termNumber - 1) / 4);
+    const yearOffset =
+      termName === "Spring" ? baseYearOffset + 1 : baseYearOffset;
+    const year = startYear + yearOffset;
+    const termLabel = `${termName} ${year}`;
+
+    // Get completed and remaining courses
+    const completedCourses = term.courses.filter((course) => course.completed);
+    const remainingCourses = term.courses.filter((course) => !course.completed);
+
+    // If all courses are completed, just show a brief summary
+    if (remainingCourses.length === 0) {
+      return `\n${termLabel}: Completed`;
+    }
+
+    let termInfo = `\n${termLabel}:\n`;
+
+    if (completedCourses.length > 0) {
+      termInfo += "Completed Courses:\n";
+      completedCourses.forEach((course) => {
+        if (course.id) {
+          termInfo += `- ${course.id}: ${course.displayName} (${course.units} units)\n`;
+        } else if (course.customId) {
+          termInfo += `- ${course.customId}: ${course.customDisplayName || course.customId} (${course.customUnits} units)\n`;
+        }
+      });
+    }
+
+    if (remainingCourses.length > 0) {
+      termInfo += "\nRemaining Courses:\n";
+      remainingCourses.forEach((course) => {
+        if (course.id) {
+          termInfo += `- ${course.id}: ${course.displayName} (${course.units} units)\n`;
+        } else if (course.customId) {
+          termInfo += `- ${course.customId}: ${course.customDisplayName || course.customId} (${course.customUnits} units)\n`;
+        }
+      });
+    }
+
+    return termInfo;
+  });
+
+  summary += termSummary.join("\n");
+
+  // Add remaining requirements summary
+  const remainingCourses = flowchart.flowchartData.termData.flatMap((term) =>
+    term.courses.filter((course) => !course.completed)
+  );
+
+  const remainingRequired = remainingCourses.filter((course) => course.id);
+  const remainingElectives = remainingCourses.filter(
+    (course) => course.customId
+  );
+  const completedCoursesIds = flowchart.flowchartData.termData.flatMap((term) =>
+    term.courses
+      .filter((course) => course.completed)
+      .map((course) => course.id)
+      .filter((id): id is string => !!id)
+  );
+  const catalogYear = getCatalogYear(flowchart.flowchartData.name);
+  const geAreas = await getGeAreas(catalogYear, completedCoursesIds);
+  const geAreasLeft = geAreas.filter((area) => !area.completed);
+  const techElectives = await getTechElectivesCourses(flowchart.flowInfo.code);
+  const techElectivesLeft = techElectives.techElectives
+    .map((techElective) => ({
+      ...techElective,
+      courses: techElective.courses.filter(
+        (course) => !completedCoursesIds.includes(course)
+      ),
+    }))
+    .filter((techElective) => techElective.courses.length > 0);
+
+  // Get courses for each GE area
+  const geAreasWithCourses = await Promise.all(
+    geAreasLeft.map(async (area) => {
+      const subjects = await getGeSubjects(
+        area.category,
+        catalogYear,
+        completedCoursesIds
+      );
+      const courses = await Promise.all(
+        subjects.map((subject) =>
+          getGeCourses(subject.subject, area.category, catalogYear)
+        )
+      );
+      return {
+        category: area.category,
+        courses: courses
+          .flatMap((courseGroup) =>
+            Object.values(
+              courseGroup as Record<string, Record<string, unknown[]>>
+            ).flatMap((subjectCourses) => Object.values(subjectCourses).flat())
+          )
+          .map((course) => (course as { courseId: string }).courseId),
+      };
+    })
+  );
+
+  summary += "\n\nRemaining Requirements Summary:\n";
+  summary += `Total Remaining Courses: ${remainingCourses.length}\n`;
+  summary += `Required Courses Remaining: ${remainingRequired.length}\n`;
+  summary += `Elective Courses Remaining: ${remainingElectives.length}\n`;
+  summary += `GE Areas Remaining: ${geAreasLeft.map((area) => area.category).join(", ")}\n`;
+  summary += `Tech Electives Remaining: ${techElectivesLeft.map((elective) => elective.name).join(", ")}\n`;
+
+  return {
+    completedCoursesIds,
+    requiredCoursesLeft: remainingRequired
+      .filter((course) => course.id)
+      .map((course) => course.id as string),
+    techElectives,
+    GEAreasLeft: geAreasWithCourses.map((area) => ({
+      category: area.category,
+      courses: area.courses,
+    })),
+    summary,
+  };
+}