Requirement builder with the new data format

src/components/Modals/NewCourse/NewCourseModal.vue

@@ -54,8 +54,8 @@ export default defineComponent({
   components: { CourseSelector, TeleportModal, SelectedRequirementEditor },
   emits: {
     'close-course-modal': () => true,
-    'add-course': (course: CornellCourseRosterCourse, requirementID: string) =>
-      typeof course === 'object' && typeof requirementID === 'string',
+    'add-course': (course: CornellCourseRosterCourse, choice: FirestoreCourseOptInOptOutChoices) =>
+      typeof course === 'object' && typeof choice === 'object',
   },
   data() {
     return {
@@ -98,7 +98,7 @@ export default defineComponent({
         selectedCourse,
         store.state.groupedRequirementFulfillmentReport,
         store.state.toggleableRequirementChoices,
-        /* deprecated AppOverriddenFulfillmentChoices */ {}
+        store.state.overriddenFulfillmentChoices
       );
 
       const requirementsThatAllowDoubleCounting: string[] = [];
@@ -137,7 +137,15 @@ export default defineComponent({
     },
     addCourse() {
       if (this.selectedCourse == null) return;
-      this.$emit('add-course', this.selectedCourse, this.selectedRequirementID);
+      this.$emit('add-course', this.selectedCourse, {
+        optOut: this.relatedRequirements
+          .filter(it => it.id !== this.selectedRequirementID)
+          .map(it => it.id),
+        acknowledgedCheckerWarningOptIn: this.selfCheckRequirements
+          .filter(it => it.id !== this.selectedRequirementID)
+          .map(it => it.id),
+        arbitraryOptIn: {},
+      });
       this.closeCurrentModal();
     },
     onSelectedChange(selected: string) {

src/components/Requirements/IncompleteSelfCheck.vue

@@ -41,9 +41,12 @@ import store from '@/store';
 import {
   cornellCourseRosterCourseToFirebaseSemesterCourseWithGlobalData,
   addCourseToSemester,
-  addCourseToSelectableRequirements,
+  updateRequirementChoice,
 } from '@/global-firestore-data';
-import { canFulfillChecker } from '@/requirements/requirement-frontend-utils';
+import {
+  canFulfillChecker,
+  getAllEligibleRelatedRequirementIds,
+} from '@/requirements/requirement-frontend-utils';
 
 import NewSelfCheckCourseModal from '@/components/Modals/NewCourse/NewSelfCheckCourseModal.vue';
 
@@ -150,12 +153,42 @@ export default defineComponent({
     },
     addExistingCourse(option: string) {
       this.showDropdown = false;
-      addCourseToSelectableRequirements(this.selfCheckCourses[option].uniqueID, this.subReqId);
+      updateRequirementChoice(this.selfCheckCourses[option].uniqueID, choice => ({
+        ...choice,
+        // Since we edit from a self-check requirement,
+        // we know it must be `acknowledgedCheckerWarningOptIn`.
+        acknowledgedCheckerWarningOptIn: Array.from(
+          new Set([...choice.acknowledgedCheckerWarningOptIn, this.subReqId])
+        ),
+        // Keep existing behavior of keeping it connected to at most one requirement.
+        optOut: getAllEligibleRelatedRequirementIds(
+          this.selfCheckCourses[option].crseId,
+          store.state.groupedRequirementFulfillmentReport,
+          store.state.toggleableRequirementChoices
+        ),
+      }));
     },
     addNewCourse(course: CornellCourseRosterCourse, season: FirestoreSemesterSeason, year: number) {
       this.showDropdown = false;
       const newCourse = cornellCourseRosterCourseToFirebaseSemesterCourseWithGlobalData(course);
-      addCourseToSemester(year, season, newCourse, this.subReqId, this.$gtag);
+      addCourseToSemester(
+        year,
+        season,
+        newCourse,
+        // Since the course is new, we know the old choice does not exist.
+        () => ({
+          arbitraryOptIn: {},
+          // Since we edit from a self-check requirement,
+          // we know it must be `acknowledgedCheckerWarningOptIn`.
+          acknowledgedCheckerWarningOptIn: [this.subReqId],
+          optOut: getAllEligibleRelatedRequirementIds(
+            newCourse.crseId,
+            store.state.groupedRequirementFulfillmentReport,
+            store.state.toggleableRequirementChoices
+          ),
+        }),
+        this.$gtag
+      );
     },
     openCourseModal() {
       this.isCourseModalOpen = true;

src/components/Requirements/RequirementSelfCheckSlots.vue

@@ -21,7 +21,6 @@ import IncompleteSelfCheck from '@/components/Requirements/IncompleteSelfCheck.v
 
 import store from '@/store';
 import {
-  convertFirestoreSemesterCourseToCourseTaken,
   getMatchedRequirementFulfillmentSpecification,
   courseIsAPIB,
 } from '@/requirements/requirement-frontend-utils';
@@ -39,13 +38,9 @@ export default defineComponent({
   computed: {
     fulfilledSelfCheckCourses(): readonly CourseTaken[] {
       // selectedCourses are courses that fulfill the requirement based on user-choice
-      // they are taken from derivedSelectableRequirementData
-      const selectedFirestoreCourses =
-        store.state.derivedSelectableRequirementData.requirementToCoursesMap[
-          this.requirementFulfillment.requirement.id
-        ] || [];
-      const selectedCourses = selectedFirestoreCourses.map(
-        convertFirestoreSemesterCourseToCourseTaken
+      // they are taken from requirement graph
+      const selectedCourses = store.state.requirementFulfillmentGraph.getConnectedCoursesFromRequirement(
+        this.requirementFulfillment.requirement.id
       );
 
       // fulfillableCourses are the courses that can fulfill this requirement

src/components/Semester/Semester.vue

@@ -139,9 +139,10 @@ import {
   addCourseToSemester,
   deleteCourseFromSemester,
   deleteAllCoursesFromSemester,
-  addCoursesToSelectableRequirements,
+  updateRequirementChoices,
 } from '@/global-firestore-data';
-import { updateSubjectColorData } from '@/store';
+import store, { updateSubjectColorData } from '@/store';
+import { getAllEligibleRelatedRequirementIds } from '@/requirements/requirement-frontend-utils';
 
 type ComponentRef = { $el: HTMLDivElement };
 
@@ -239,11 +240,24 @@ export default defineComponent({
             courses,
           })
         );
-        const newChoices: Record<string, string> = {};
-        newCourses.forEach(({ uniqueID, requirementID }) => {
-          if (requirementID) newChoices[uniqueID] = requirementID;
+        updateRequirementChoices(oldChoices => {
+          const choices = { ...oldChoices };
+          newCourses.forEach(({ uniqueID, requirementID, crseId }) => {
+            if (requirementID == null) return;
+            const choice = choices[uniqueID] || {
+              arbitraryOptIn: {},
+              acknowledgedCheckerWarningOptIn: [],
+              optOut: [],
+            };
+            const optOut = getAllEligibleRelatedRequirementIds(
+              crseId,
+              store.state.groupedRequirementFulfillmentReport,
+              store.state.toggleableRequirementChoices
+            ).filter(it => it !== requirementID);
+            choices[uniqueID] = { ...choice, optOut };
+          });
+          return choices;
         });
-        addCoursesToSelectableRequirements(newChoices);
       },
     },
     // Add space for a course if there is a "shadow" of it, decrease if it is from the current sem
@@ -330,9 +344,10 @@ export default defineComponent({
     closeConfirmationModal() {
       this.isConfirmationOpen = false;
     },
-    addCourse(data: CornellCourseRosterCourse, requirementID: string) {
+    addCourse(data: CornellCourseRosterCourse, choice: FirestoreCourseOptInOptOutChoices) {
       const newCourse = cornellCourseRosterCourseToFirebaseSemesterCourseWithGlobalData(data);
-      addCourseToSemester(this.year, this.season, newCourse, requirementID, this.$gtag);
+      // Since the course is new, we know the old choice does not exist.
+      addCourseToSemester(this.year, this.season, newCourse, () => choice, this.$gtag);
 
       const courseCode = `${data.subject} ${data.catalogNbr}`;
       this.openConfirmationModal(`Added ${courseCode} to ${this.season} ${this.year}`);

src/global-firestore-data/index.ts

@@ -26,7 +26,7 @@ export {
 } from './semesters';
 export { default as chooseToggleableRequirementOption } from './toggleable-requirement-choices';
 export {
-  addCourseToSelectableRequirements,
-  addCoursesToSelectableRequirements,
-  deleteCourseFromSelectableRequirements,
-} from './selectable-requirement-choices';
+  updateRequirementChoice,
+  updateRequirementChoices,
+  deleteCourseFromRequirementChoices,
+} from './override-fulfillment-choices';

src/global-firestore-data/override-fulfillment-choices.ts

@@ -0,0 +1,46 @@
+import { overriddenFulfillmentChoicesCollection } from '../firebase-frontend-config';
+import store from '../store';
+
+export const updateRequirementChoice = (
+  courseUniqueID: string | number,
+  choiceUpdater: (choice: FirestoreCourseOptInOptOutChoices) => FirestoreCourseOptInOptOutChoices
+): void => {
+  overriddenFulfillmentChoicesCollection.doc(store.state.currentFirebaseUser.email).set({
+    ...store.state.overriddenFulfillmentChoices,
+    [courseUniqueID]: choiceUpdater(
+      store.state.overriddenFulfillmentChoices[courseUniqueID] || {
+        arbitraryOptIn: {},
+        acknowledgedCheckerWarningOptIn: [],
+        optOut: [],
+      }
+    ),
+  });
+};
+
+export const updateRequirementChoices = (
+  updater: (
+    oldChoices: FirestoreOverriddenFulfillmentChoices
+  ) => FirestoreOverriddenFulfillmentChoices
+): void => {
+  overriddenFulfillmentChoicesCollection
+    .doc(store.state.currentFirebaseUser.email)
+    .set(updater(store.state.overriddenFulfillmentChoices));
+};
+
+export const deleteCourseFromRequirementChoices = (courseUniqueID: string | number): void =>
+  deleteCoursesFromRequirementChoices([courseUniqueID]);
+
+export const deleteCoursesFromRequirementChoices = (
+  courseUniqueIds: readonly (string | number)[]
+): void => {
+  const courseUniqueIdStrings = new Set(courseUniqueIds.map(uniqueId => uniqueId.toString()));
+  overriddenFulfillmentChoicesCollection
+    .doc(store.state.currentFirebaseUser.email)
+    .set(
+      Object.fromEntries(
+        Object.entries(store.state.overriddenFulfillmentChoices).filter(
+          ([uniqueId]) => !courseUniqueIdStrings.has(uniqueId)
+        )
+      )
+    );
+};

src/global-firestore-data/semesters.ts

@@ -4,10 +4,10 @@ import { GTag, GTagEvent } from '../gtag';
 import { sortedSemesters } from '../utilities';
 
 import {
-  addCourseToSelectableRequirements,
-  deleteCourseFromSelectableRequirements,
-  deleteCoursesFromSelectableRequirements,
-} from './selectable-requirement-choices';
+  updateRequirementChoice,
+  deleteCourseFromRequirementChoices,
+  deleteCoursesFromRequirementChoices,
+} from './override-fulfillment-choices';
 
 export const editSemesters = (
   updater: (oldSemesters: readonly FirestoreSemester[]) => readonly FirestoreSemester[]
@@ -81,7 +81,7 @@ export const deleteSemester = (
   GTagEvent(gtag, 'delete-semester');
   const semester = store.state.semesters.find(sem => semesterEquals(sem, year, season));
   if (semester) {
-    deleteCoursesFromSelectableRequirements(semester.courses.map(course => course.uniqueID));
+    deleteCoursesFromRequirementChoices(semester.courses.map(course => course.uniqueID));
     editSemesters(oldSemesters => oldSemesters.filter(sem => !semesterEquals(sem, year, season)));
   }
 };
@@ -90,7 +90,7 @@ export const addCourseToSemester = (
   year: number,
   season: FirestoreSemesterSeason,
   newCourse: FirestoreSemesterCourse,
-  requirementID?: string,
+  choiceUpdater: (choice: FirestoreCourseOptInOptOutChoices) => FirestoreCourseOptInOptOutChoices,
   gtag?: GTag
 ): void => {
   GTagEvent(gtag, 'add-course');
@@ -106,9 +106,7 @@ export const addCourseToSemester = (
     if (semesterFound) return newSemestersWithCourse;
     return [...oldSemesters, createSemester(year, season, [newCourse])];
   });
-  if (requirementID) {
-    addCourseToSelectableRequirements(newCourse.uniqueID, requirementID);
-  }
+  updateRequirementChoice(newCourse.uniqueID, choiceUpdater);
 };
 
 export const deleteCourseFromSemester = (
@@ -120,7 +118,7 @@ export const deleteCourseFromSemester = (
   GTagEvent(gtag, 'delete-course');
   const semester = store.state.semesters.find(sem => semesterEquals(sem, year, season));
   if (semester) {
-    deleteCourseFromSelectableRequirements(courseUniqueID);
+    deleteCourseFromRequirementChoices(courseUniqueID);
     editSemesters(oldSemesters =>
       oldSemesters.map(sem => ({
         ...sem,
@@ -140,7 +138,7 @@ export const deleteAllCoursesFromSemester = (
   GTagEvent(gtag, 'delete-semester-courses');
   const semester = store.state.semesters.find(sem => semesterEquals(sem, year, season));
   if (semester) {
-    deleteCoursesFromSelectableRequirements(semester.courses.map(course => course.uniqueID));
+    deleteCoursesFromRequirementChoices(semester.courses.map(course => course.uniqueID));
     editSemesters(oldSemesters =>
       oldSemesters.map(sem => ({
         ...sem,
@@ -160,7 +158,7 @@ export const deleteCourseFromSemesters = (courseUniqueID: number, gtag?: GTag):
       return { ...semester, courses: coursesWithoutDeleted };
     })
   );
-  deleteCourseFromSelectableRequirements(courseUniqueID);
+  deleteCourseFromRequirementChoices(courseUniqueID);
 };
 
 // exposed for testing