refactor: move server to local plan logic to one file

Author: D0dii

frontend/src/app/plans/edit/[id]/_components/app-sidebar.tsx

@@ -8,7 +8,6 @@ import Link from "next/link";
 import React from "react";
 
 import { getFaculties } from "@/actions/get-faculties";
-import type { ExtendedCourse, ExtendedGroup } from "@/atoms/plan-family";
 import { GroupsAccordionItem } from "@/components/groups-accordion";
 import { Icons } from "@/components/icons";
 import { PlanDisplayLink } from "@/components/plan-display-link";
@@ -33,12 +32,8 @@ import { Skeleton } from "@/components/ui/skeleton";
 import { fetchClient } from "@/lib/fetch";
 import type { usePlanType } from "@/lib/use-plan";
 import { registrationReplacer } from "@/lib/utils";
-import type {
-  CourseType,
-  FacultyType,
-  LessonType,
-  PlanResponseType,
-} from "@/types";
+import { serverToLocalPlan } from "@/lib/utils/server-to-local-plan";
+import type { CourseType, FacultyType, PlanResponseType } from "@/types";
 
 import { OfflineAlert } from "./offline-alert";
 import { SyncErrorAlert } from "./sync-error-alert";
@@ -240,48 +235,11 @@ export function AppSidebar({
                   } else {
                     coursesFunction.mutate(selectedRegistration.id, {
                       onSuccess: (data) => {
-                        const extendedCourses: ExtendedCourse[] = data
-                          .map((c) => ({
-                            id: c.id,
-                            name: c.name,
-                            isChecked: true,
-                            registrationId: c.registrationId,
-                            type: c.groups.at(0)?.type ?? ("" as LessonType),
-                            groups: c.groups.map(
-                              (g) =>
-                                ({
-                                  groupId: g.group + c.id + g.type,
-                                  groupNumber: g.group.toString(),
-                                  groupOnlineId: g.id,
-                                  courseId: c.id,
-                                  courseName: c.name,
-                                  isChecked: false,
-                                  courseType: g.type,
-                                  day: g.day,
-                                  lecturer: g.lecturer,
-                                  registrationId: c.registrationId,
-                                  week: g.week.replace("-", "") as
-                                    | ""
-                                    | "TN"
-                                    | "TP",
-                                  endTime: g.endTime
-                                    .split(":")
-                                    .slice(0, 2)
-                                    .join(":"),
-                                  startTime: g.startTime
-                                    .split(":")
-                                    .slice(0, 2)
-                                    .join(":"),
-                                  spotsOccupied: g.spotsOccupied,
-                                  spotsTotal: g.spotsTotal,
-                                  averageRating: g.averageRating,
-                                  opinionsCount: g.opinionsCount,
-                                }) satisfies ExtendedGroup,
-                            ),
-                          }))
-                          .sort((a, b) => {
-                            return a.name.localeCompare(b.name);
-                          });
+                        const extendedCourses = serverToLocalPlan(
+                          data,
+                          true,
+                          false,
+                        );
                         plan.addRegistration(
                           selectedRegistration,
                           extendedCourses,

frontend/src/lib/utils/server-to-local-plan.ts

@@ -0,0 +1,56 @@
+import type { ExtendedCourse, ExtendedGroup } from "@/atoms/plan-family";
+import type {
+  CourseType,
+  LessonType,
+  SingleCourse,
+  SingleGroup,
+} from "@/types";
+
+export const serverToLocalPlan = (
+  courses: CourseType,
+  shouldCourseBeChecked: ((course: SingleCourse) => boolean) | boolean,
+  shouldGroupBeChecked:
+    | ((course: SingleCourse, group: SingleGroup) => boolean)
+    | boolean,
+) => {
+  const extendedCourses: ExtendedCourse[] = courses
+    .map((c) => ({
+      id: c.id,
+      name: c.name,
+      isChecked:
+        typeof shouldCourseBeChecked === "boolean"
+          ? shouldCourseBeChecked
+          : shouldCourseBeChecked(c),
+      registrationId: c.registrationId,
+      type: c.groups.at(0)?.type ?? ("" as LessonType),
+      groups: c.groups.map(
+        (g) =>
+          ({
+            groupId: g.group + c.id + g.type,
+            groupNumber: g.group.toString(),
+            groupOnlineId: g.id,
+            courseId: c.id,
+            courseName: c.name,
+            isChecked:
+              typeof shouldGroupBeChecked === "boolean"
+                ? shouldGroupBeChecked
+                : shouldGroupBeChecked(c, g),
+            courseType: g.type,
+            day: g.day,
+            lecturer: g.lecturer,
+            registrationId: c.registrationId,
+            week: g.week.replace("-", "") as "" | "TN" | "TP",
+            endTime: g.endTime.split(":").slice(0, 2).join(":"),
+            startTime: g.startTime.split(":").slice(0, 2).join(":"),
+            spotsOccupied: g.spotsOccupied,
+            spotsTotal: g.spotsTotal,
+            averageRating: g.averageRating,
+            opinionsCount: g.opinionsCount,
+          }) satisfies ExtendedGroup,
+      ),
+    }))
+    .sort((a, b) => {
+      return a.name.localeCompare(b.name);
+    });
+  return extendedCourses;
+};

frontend/src/lib/utils/update-local-plan.ts

@@ -1,13 +1,16 @@
 import type { UseMutationResult } from "@tanstack/react-query";
 
-import type { ExtendedCourse, ExtendedGroup } from "@/atoms/plan-family";
+import type { ExtendedCourse } from "@/atoms/plan-family";
 import type {
   CourseType,
-  LessonType,
   PlanResponseType,
   Registration,
+  SingleCourse,
+  SingleGroup,
 } from "@/types";
 
+import { serverToLocalPlan } from "./server-to-local-plan";
+
 type UpdateLocalPlanResult =
   | {
       status: "ERROR";
@@ -41,40 +44,19 @@ export const updateLocalPlan = async (
   for (const registration of onlinePlan.registrations) {
     try {
       const courses = await coursesFunction.mutateAsync(registration.id);
-      const extendedCourses: ExtendedCourse[] = courses
-        .map((c) => {
-          const groups: ExtendedGroup[] = c.groups.map((g) => ({
-            groupId: g.group + c.id + g.type,
-            groupNumber: g.group.toString(),
-            groupOnlineId: g.id,
-            courseId: c.id,
-            courseName: c.name,
-            isChecked:
-              onlinePlan.courses
-                .find((oc) => oc.id === c.id)
-                ?.groups.some((og) => og.id === g.id) ?? false,
-            courseType: g.type,
-            day: g.day,
-            lecturer: g.lecturer,
-            registrationId: c.registrationId,
-            week: g.week.replace("-", "") as "" | "TN" | "TP",
-            endTime: g.endTime.split(":").slice(0, 2).join(":"),
-            startTime: g.startTime.split(":").slice(0, 2).join(":"),
-            spotsOccupied: g.spotsOccupied,
-            spotsTotal: g.spotsTotal,
-            opinionsCount: g.opinionsCount,
-            averageRating: g.averageRating,
-          }));
-          return {
-            id: c.id,
-            name: c.name,
-            isChecked: onlinePlan.courses.some((oc) => oc.id === c.id),
-            registrationId: c.registrationId,
-            type: c.groups.at(0)?.type ?? ("" as LessonType),
-            groups,
-          };
-        })
-        .sort((a, b) => a.name.localeCompare(b.name));
+      const extendedCourses = serverToLocalPlan(
+        courses,
+        (course: SingleCourse) => {
+          return onlinePlan.courses.some((oc) => oc.id === course.id);
+        },
+        (courseId: SingleCourse, groupId: SingleGroup) => {
+          return (
+            onlinePlan.courses
+              .find((oc) => oc.id === courseId.id)
+              ?.groups.some((og) => og.id === groupId.id) ?? false
+          );
+        },
+      );
 
       // Add unique registrations to the updatedRegistrations array
       updatedRegistrations = [...updatedRegistrations, registration].filter(

frontend/src/types/index.ts

@@ -124,30 +124,34 @@ export interface DeletePlanResponseType {
   message: string;
 }
 
-export type CourseType = {
+export interface SingleGroup {
+  id: number;
+  name: string;
+  startTime: string;
+  endTime: string;
+  group: string;
+  lecturer: string;
+  week: "-" | "TN" | "TP";
+  day: Day;
+  type: "C" | "L" | "P" | "S" | "W";
+  url: string;
+  courseId: string;
+  spotsOccupied: number;
+  spotsTotal: number;
+  averageRating: number;
+  createdAt: string;
+  updatedAt: string;
+  opinionsCount: number;
+}
+
+export interface SingleCourse {
   id: string;
   name: string;
   registrationId: string;
-  groups: {
-    id: number;
-    name: string;
-    startTime: string;
-    endTime: string;
-    group: string;
-    lecturer: string;
-    week: "-" | "TN" | "TP";
-    day: Day;
-    type: "C" | "L" | "P" | "S" | "W";
-    url: string;
-    courseId: string;
-    spotsOccupied: number;
-    spotsTotal: number;
-    averageRating: number;
-    createdAt: string;
-    updatedAt: string;
-    opinionsCount: number;
-  }[];
-}[];
+  groups: SingleGroup[];
+}
+
+export type CourseType = SingleCourse[];
 
 export type FacultyType = {
   id: string;