feat(website): Add TA mode

website/src/actions/export.ts

@@ -5,6 +5,7 @@
 import { captureException } from 'utils/error';
 import retryImport from 'utils/retryImport';
 import { getSemesterTimetableLessons } from 'selectors/timetables';
+import { TaModuleConfig } from 'types/timetables';
 import { SET_EXPORTED_DATA } from './constants';
 
 function downloadUrl(blob: Blob, filename: string) {
@@ -32,11 +33,18 @@
         const state = getState();
         const { modules } = state.moduleBank;
         const hiddenModules: ModuleCode[] = state.timetables.hidden[semester] || [];
+        const taModules: TaModuleConfig = state.timetables.ta[semester] || {};
 
         const timetable = getSemesterTimetableLessons(state)(semester);
         const timetableWithLessons = hydrateSemTimetableWithLessons(timetable, modules, semester);
 
-        const events = icalUtils.default(semester, timetableWithLessons, modules, hiddenModules);
+        const events = icalUtils.default(
+          semester,
+          timetableWithLessons,
+          modules,
+          hiddenModules,
+          taModules,
+        );
         const cal = ical.default({
           domain: 'nusmods.com',
           prodId: '//NUSMods//NUSMods//EN',

website/src/actions/timetables.ts

@@ -1,6 +1,12 @@
 import { each, flatMap } from 'lodash';
 
-import type { ColorIndex, Lesson, ModuleLessonConfig, SemTimetableConfig } from 'types/timetables';
+import type {
+  ColorIndex,
+  Lesson,
+  ModuleLessonConfig,
+  SemTimetableConfig,
+  TaModuleConfig,
+} from 'types/timetables';
 import type { Dispatch, GetState } from 'types/redux';
 import type { ColorMapping } from 'types/reducers';
 import type { ClassNo, LessonType, Module, ModuleCode, Semester } from 'types/modules';
@@ -19,17 +25,18 @@
 export const SET_TIMETABLE = 'SET_TIMETABLE' as const;
 export const ADD_MODULE = 'ADD_MODULE' as const;
 export const SET_HIDDEN_IMPORTED = 'SET_HIDDEN_IMPORTED' as const;
-export const HIDDEN_IMPORTED_SEM = 'HIDDEN_IMPORTED_SEM' as const;
+export const SET_TA_IMPORTED = 'SET_TA_IMPORTED' as const;
 export const Internal = {
   setTimetable(
     semester: Semester,
     timetable: SemTimetableConfig | undefined,
     colors?: ColorMapping,
     hiddenModules?: ModuleCode[],
+    taModules?: TaModuleConfig,
   ) {
     return {
       type: SET_TIMETABLE,
-      payload: { semester, timetable, colors, hiddenModules },
+      payload: { semester, timetable, colors, hiddenModules, taModules },
     };
   },
 
@@ -165,7 +172,8 @@
         semester,
         validatedTimetable,
         colors,
-        getState().timetables.hidden[HIDDEN_IMPORTED_SEM] || [],
+        getState().timetables.hidden[semester] || [],
+        getState().timetables.ta[semester] || {},
       ),
     );
   };
@@ -211,14 +219,25 @@
   };
 }
 
-export function setHiddenModulesFromImport(hiddenModules: ModuleCode[]) {
-  return (dispatch: Dispatch) => dispatch(setHiddenImported(hiddenModules));
+export function setHiddenModulesFromImport(semester: Semester, hiddenModules: ModuleCode[]) {
+  return (dispatch: Dispatch) => dispatch(setHiddenImported(semester, hiddenModules));
 }
 
-export function setHiddenImported(hiddenModules: ModuleCode[]) {
+export function setHiddenImported(semester: Semester, hiddenModules: ModuleCode[]) {
   return {
     type: SET_HIDDEN_IMPORTED,
-    payload: { semester: HIDDEN_IMPORTED_SEM, hiddenModules },
+    payload: { semester, hiddenModules },
+  };
+}
+
+export function setTaModulesFromImport(semester: Semester, taModules: TaModuleConfig) {
+  return (dispatch: Dispatch) => dispatch(setTaImported(semester, taModules));
+}
+
+export function setTaImported(semester: Semester, taModules: TaModuleConfig) {
+  return {
+    type: SET_TA_IMPORTED,
+    payload: { semester, taModules },
   };
 }
 
@@ -253,3 +272,27 @@
     payload: { moduleCode, semester },
   };
 }
+
+export const ADD_TA_LESSON_IN_TIMETABLE = 'ADD_TA_LESSON_IN_TIMETABLE' as const;
+export function addTaLessonInTimetable(
+  semester: Semester,
+  moduleCode: ModuleCode,
+  lessonType: LessonType,
+) {
+  return {
+    type: ADD_TA_LESSON_IN_TIMETABLE,
+    payload: { moduleCode, lessonType, semester },
+  };
+}
+
+export const REMOVE_TA_LESSON_IN_TIMETABLE = 'REMOVE_TA_LESSON_IN_TIMETABLE' as const;
+export function removeTaLessonInTimetable(
+  semester: Semester,
+  moduleCode: ModuleCode,
+  lessonType: LessonType,
+) {
+  return {
+    type: REMOVE_TA_LESSON_IN_TIMETABLE,
+    payload: { moduleCode, lessonType, semester },
+  };
+}

website/src/entry/export/TimetableOnly.tsx

@@ -44,6 +44,7 @@ export default class TimetableOnly extends Component<Props, State> {
               timetable={timetable}
               colors={timetableColors}
               hiddenImportedModules={null}
+              taImportedModules={null}
               readOnly
             />
           </div>

website/src/reducers/index.test.ts

@@ -29,6 +29,9 @@ const exportData: ExportData = {
     PC1222: 2,
   },
   hidden: ['PC1222'],
+  ta: {
+    CS1010S: ['Tutorial'],
+  },
   theme: {
     id: 'google',
     timetableOrientation: VERTICAL,
@@ -74,6 +77,11 @@ test('reducers should set export data state', () => {
       },
     },
     hidden: { [1]: ['PC1222'] },
+    ta: {
+      [1]: {
+        CS1010S: ['Tutorial'],
+      },
+    },
     academicYear: expect.any(String),
     archive: {},
   });

website/src/reducers/timetables.test.ts

@@ -8,8 +8,9 @@ import {
   setLessonConfig,
   showLessonInTimetable,
   setHiddenImported,
-  HIDDEN_IMPORTED_SEM,
   Internal,
+  addTaLessonInTimetable,
+  removeTaLessonInTimetable,
 } from 'actions/timetables';
 import { TimetablesState } from 'types/reducers';
 import config from 'config';
@@ -73,6 +74,7 @@ describe('color reducers', () => {
           timetable: { CS1010S: {} },
           colors: { CS1010S: 0 },
           hiddenModules: [],
+          taModules: {},
         },
       }).colors[1],
     ).toEqual({
@@ -124,6 +126,54 @@ describe('hidden module reducer', () => {
   });
 });
 
+describe('TA module reducer', () => {
+  const withTaModules: TimetablesState = {
+    ...initialState,
+    ta: { [1]: { CS1010S: ['Tutorial'] }, [2]: { CS1010S: ['Tutorial'] } },
+  };
+
+  test('should update TA modules', () => {
+    expect(reducer(initialState, addTaLessonInTimetable(1, 'CS3216', 'Tutorial'))).toHaveProperty(
+      'ta.1',
+      { CS3216: ['Tutorial'] },
+    );
+
+    expect(
+      reducer(initialState, removeTaLessonInTimetable(1, 'CS1010S', 'Tutorial')),
+    ).toMatchObject({
+      ta: {
+        [1]: {},
+      },
+    });
+
+    expect(
+      reducer(withTaModules, removeTaLessonInTimetable(1, 'CS1010S', 'Tutorial')),
+    ).toMatchObject({
+      ta: {
+        [1]: {},
+        [2]: { CS1010S: ['Tutorial'] },
+      },
+    });
+  });
+
+  test('should remove modules from list when modules are removed', () => {
+    expect(
+      reducer(
+        {
+          ...initialState,
+          ta: { [1]: { CS1010S: ['Tutorial'] }, [2]: { CS1010S: ['Tutorial'] } },
+        },
+        removeModule(1, 'CS1010S'),
+      ),
+    ).toMatchObject({
+      ta: {
+        [1]: {},
+        [2]: { CS1010S: ['Tutorial'] },
+      },
+    });
+  });
+});
+
 describe('lesson reducer', () => {
   test('should allow lesson config to be set', () => {
     expect(
@@ -213,6 +263,7 @@ describe('stateReconciler', () => {
     hidden: {
       [1]: ['CS1010S'],
     },
+    ta: {},
     academicYear: config.academicYear,
     archive: oldArchive,
   };
@@ -249,53 +300,36 @@ describe('stateReconciler', () => {
 });
 
 describe('import timetable', () => {
+  const stateWithHidden = {
+    ...initialState,
+    hidden: {
+      [1]: ['CS1101S', 'CS1231S'],
+    },
+  };
+
   test('should have hidden modules set when importing hidden', () => {
-    expect(reducer(initialState, setHiddenImported(['CS1101S', 'CS1231S'])).hidden).toMatchObject({
-      [HIDDEN_IMPORTED_SEM]: ['CS1101S', 'CS1231S'],
+    expect(
+      reducer(initialState, setHiddenImported(1, ['CS1101S', 'CS1231S'])).hidden,
+    ).toMatchObject({
+      [1]: ['CS1101S', 'CS1231S'],
     });
 
     // Should change hidden modules when a new set of modules is imported
     expect(
-      reducer(
-        {
-          ...initialState,
-          hidden: {
-            [HIDDEN_IMPORTED_SEM]: ['CS1101S', 'CS1231S'],
-          },
-        },
-        setHiddenImported(['CS2100', 'CS2103T']),
-      ).hidden,
+      reducer(stateWithHidden, setHiddenImported(1, ['CS2100', 'CS2103T'])).hidden,
     ).toMatchObject({
-      [HIDDEN_IMPORTED_SEM]: ['CS2100', 'CS2103T'],
+      [1]: ['CS2100', 'CS2103T'],
     });
 
     // should delete hidden modules when there are none
-    expect(
-      reducer(
-        {
-          ...initialState,
-          hidden: {
-            [HIDDEN_IMPORTED_SEM]: ['CS1101S', 'CS1231S'],
-          },
-        },
-        setHiddenImported([]),
-      ).hidden,
-    ).toMatchObject({
-      [HIDDEN_IMPORTED_SEM]: [],
+    expect(reducer(stateWithHidden, setHiddenImported(1, [])).hidden).toMatchObject({
+      [1]: [],
     });
   });
 
   test('should copy over hidden modules when deciding to replace saved timetable', () => {
     expect(
-      reducer(
-        {
-          ...initialState,
-          hidden: {
-            [HIDDEN_IMPORTED_SEM]: ['CS1101S', 'CS1231S'],
-          },
-        },
-        Internal.setTimetable(1, {}, {}, ['CS1101S', 'CS1231S']),
-      ).hidden,
+      reducer(stateWithHidden, Internal.setTimetable(1, {}, {}, stateWithHidden.hidden[1])).hidden,
     ).toMatchObject({
       '1': ['CS1101S', 'CS1231S'],
     });