moving v2 to top level

src/services/serverFunctions/router/app.ts

@@ -0,0 +1,30 @@
+import { createTrpcContext } from "../context";
+import { createCallerFactory, router } from "../trpcSetup";
+import { assignmentRouter } from "./assignmentRouter";
+import { canvasFileRouter } from "./canvasFileRouter";
+import { directoriesRouter } from "./directoriesRouter";
+import { lectureRouter } from "./lectureRouter";
+import { moduleRouter } from "./moduleRouter";
+import { pageRouter } from "./pageRouter";
+import { quizRouter } from "./quizRouter";
+import { settingsRouter } from "./settingsRouter";
+
+export const trpcAppRouter = router({
+  assignment: assignmentRouter,
+  lectures: lectureRouter,
+  settings: settingsRouter,
+  quiz: quizRouter,
+  page: pageRouter,
+  module: moduleRouter,
+  directories: directoriesRouter,
+  canvasFile: canvasFileRouter,
+});
+
+export const createCaller = createCallerFactory(trpcAppRouter);
+
+export const createAsyncCaller = async () => {
+  const context = await createTrpcContext();
+  return createCaller(context);
+};
+
+export type AppRouter = typeof trpcAppRouter;

src/services/serverFunctions/router/assignmentRouter.ts

@@ -0,0 +1,116 @@
+import publicProcedure from "../procedures/public";
+import { z } from "zod";
+import { router } from "../trpcSetup";
+import { fileStorageService } from "@/services/fileStorage/fileStorageService";
+import { zodLocalAssignment } from "@/models/local/assignment/localAssignment";
+
+export const assignmentRouter = router({
+  getAssignment: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        assignmentName: z.string(),
+      })
+    )
+    .query(async ({ input: { courseName, moduleName, assignmentName } }) => {
+      const assignment = await fileStorageService.assignments.getAssignment(
+        courseName,
+        moduleName,
+        assignmentName
+      );
+      // console.log(assignment);
+      return assignment;
+    }),
+  getAllAssignments: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+      })
+    )
+    .query(async ({ input: { courseName, moduleName } }) => {
+      const assignments = await fileStorageService.assignments.getAssignments(
+        courseName,
+        moduleName
+      );
+      return assignments;
+    }),
+  createAssignment: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        assignmentName: z.string(),
+        assignment: zodLocalAssignment,
+      })
+    )
+    .mutation(
+      async ({
+        input: { courseName, moduleName, assignmentName, assignment },
+      }) => {
+        await fileStorageService.assignments.updateOrCreateAssignment({
+          courseName,
+          moduleName,
+          assignmentName,
+          assignment,
+        });
+      }
+    ),
+  updateAssignment: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        previousModuleName: z.string(),
+        previousAssignmentName: z.string(),
+        assignmentName: z.string(),
+        assignment: zodLocalAssignment,
+      })
+    )
+    .mutation(
+      async ({
+        input: {
+          courseName,
+          moduleName,
+          assignmentName,
+          assignment,
+          previousModuleName,
+          previousAssignmentName,
+        },
+      }) => {
+        await fileStorageService.assignments.updateOrCreateAssignment({
+          courseName,
+          moduleName,
+          assignmentName,
+          assignment,
+        });
+
+        if (
+          assignment.name !== previousAssignmentName ||
+          moduleName !== previousModuleName
+        ) {
+          fileStorageService.assignments.delete({
+            courseName,
+            moduleName: previousModuleName,
+            assignmentName: previousAssignmentName,
+          });
+        }
+      }
+    ),
+  deleteAssignment: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        assignmentName: z.string(),
+      })
+    )
+    .mutation(async ({ input: { courseName, moduleName, assignmentName } }) => {
+      await fileStorageService.assignments.delete({
+        courseName,
+        moduleName,
+        assignmentName,
+      });
+    }),
+});

src/services/serverFunctions/router/canvasFileRouter.ts

@@ -0,0 +1,34 @@
+import publicProcedure from "../procedures/public";
+import { z } from "zod";
+import { router } from "../trpcSetup";
+import {
+  downloadUrlToTempDirectory,
+  uploadToCanvasPart1,
+  uploadToCanvasPart2,
+} from "@/services/canvas/files/canvasFileService";
+
+export const canvasFileRouter = router({
+  getCanvasFileUrl: publicProcedure
+    .input(
+      z.object({
+        sourceUrl: z.string(),
+        canvasCourseId: z.number(),
+      })
+    )
+    .mutation(async ({ input: { sourceUrl, canvasCourseId } }) => {
+      const localTempFile = await downloadUrlToTempDirectory(sourceUrl);
+      console.log("local temp file", localTempFile);
+      const { upload_url, upload_params } = await uploadToCanvasPart1(
+        localTempFile,
+        canvasCourseId
+      );
+      console.log("part 1 done", upload_url, upload_params);
+      const canvasUrl = await uploadToCanvasPart2({
+        pathToUpload: localTempFile,
+        upload_url,
+        upload_params,
+      });
+      console.log("canvas url done");
+      return canvasUrl;
+    }),
+});

src/services/serverFunctions/router/directoriesRouter.ts

@@ -0,0 +1,11 @@
+import publicProcedure from "../procedures/public";
+import { z } from "zod";
+import { router } from "../trpcSetup";
+import { fileStorageService } from "@/services/fileStorage/fileStorageService";
+import { zodLocalAssignment } from "@/models/local/assignment/localAssignment";
+
+export const directoriesRouter = router({
+  getEmptyDirectories: publicProcedure.query(async () => {
+    return await fileStorageService.getEmptyDirectories();
+  }),
+});

src/services/serverFunctions/router/lectureRouter.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import publicProcedure from "../procedures/public";
+import { router } from "../trpcSetup";
+import {
+  deleteLecture,
+  getLectures,
+  updateLecture,
+} from "@/services/fileStorage/lectureFileStorageService";
+import { zodLecture } from "@/models/local/lecture";
+import { zodLocalCourseSettings } from "@/models/local/localCourseSettings";
+
+export const lectureRouter = router({
+  getLectures: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+      })
+    )
+    .query(async ({ input: { courseName } }) => {
+      return await getLectures(courseName);
+    }),
+  updateLecture: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        lecture: zodLecture,
+        previousDay: z.string().optional(),
+        settings: zodLocalCourseSettings,
+      })
+    )
+    .mutation(
+      async ({ input: { courseName, settings, lecture, previousDay } }) => {
+        await updateLecture(courseName, settings, lecture);
+
+        if (previousDay && previousDay !== lecture.date) {
+          await deleteLecture(courseName, settings, previousDay);
+        }
+      }
+    ),
+  deleteLecture: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        lectureDay: z.string(),
+        settings: zodLocalCourseSettings,
+      })
+    )
+    .mutation(async ({ input: { courseName, settings, lectureDay } }) => {
+      await deleteLecture(courseName, settings, lectureDay);
+    }),
+});

src/services/serverFunctions/router/moduleRouter.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import publicProcedure from "../procedures/public";
+import { router } from "../trpcSetup";
+import { fileStorageService } from "@/services/fileStorage/fileStorageService";
+
+export const moduleRouter = router({
+  getModuleNames: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+      })
+    )
+    .query(async ({ input: { courseName } }) => {
+      return await fileStorageService.modules.getModuleNames(courseName);
+    }),
+  createModule: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+      })
+    )
+    .mutation(async ({ input: { courseName, moduleName } }) => {
+      await fileStorageService.modules.createModule(courseName, moduleName);
+    }),
+});

src/services/serverFunctions/router/pageRouter.ts

@@ -0,0 +1,107 @@
+import publicProcedure from "../procedures/public";
+import { z } from "zod";
+import { router } from "../trpcSetup";
+import { fileStorageService } from "@/services/fileStorage/fileStorageService";
+import { zodLocalCoursePage } from "@/models/local/page/localCoursePage";
+
+export const pageRouter = router({
+  getPage: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        pageName: z.string(),
+      })
+    )
+    .query(async ({ input: { courseName, moduleName, pageName } }) => {
+      return await fileStorageService.pages.getPage(
+        courseName,
+        moduleName,
+        pageName
+      );
+    }),
+
+  getAllPages: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+      })
+    )
+    .query(async ({ input: { courseName, moduleName } }) => {
+      return await fileStorageService.pages.getPages(courseName, moduleName);
+    }),
+  createPage: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        pageName: z.string(),
+        page: zodLocalCoursePage,
+      })
+    )
+    .mutation(async ({ input: { courseName, moduleName, pageName, page } }) => {
+      await fileStorageService.pages.updatePage({
+        courseName,
+        moduleName,
+        pageName,
+        page,
+      });
+    }),
+  updatePage: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        previousModuleName: z.string(),
+        previousPageName: z.string(),
+        pageName: z.string(),
+        page: zodLocalCoursePage,
+      })
+    )
+    .mutation(
+      async ({
+        input: {
+          courseName,
+          moduleName,
+          pageName,
+          page,
+          previousModuleName,
+          previousPageName,
+        },
+      }) => {
+        await fileStorageService.pages.updatePage({
+          courseName,
+          moduleName,
+          pageName,
+          page,
+        });
+
+        if (
+          page.name !== previousPageName ||
+          moduleName !== previousModuleName
+        ) {
+          fileStorageService.pages.delete({
+            courseName,
+            moduleName: previousModuleName,
+            pageName: previousPageName,
+          });
+        }
+      }
+    ),
+  deletePage: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        pageName: z.string(),
+      })
+    )
+    .mutation(async ({ input: { courseName, moduleName, pageName } }) => {
+      await fileStorageService.pages.delete({
+        courseName,
+        moduleName,
+        pageName,
+      });
+    }),
+});

src/services/serverFunctions/router/quizRouter.ts

@@ -0,0 +1,110 @@
+import publicProcedure from "../procedures/public";
+import { z } from "zod";
+import { router } from "../trpcSetup";
+import { fileStorageService } from "@/services/fileStorage/fileStorageService";
+import { zodLocalQuiz } from "@/models/local/quiz/localQuiz";
+
+export const quizRouter = router({
+  getQuiz: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        quizName: z.string(),
+      })
+    )
+    .query(async ({ input: { courseName, moduleName, quizName } }) => {
+      return await fileStorageService.quizzes.getQuiz(
+        courseName,
+        moduleName,
+        quizName
+      );
+    }),
+
+  getAllQuizzes: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+      })
+    )
+    .query(async ({ input: { courseName, moduleName } }) => {
+      return await fileStorageService.quizzes.getQuizzes(
+        courseName,
+        moduleName
+      );
+    }),
+  createQuiz: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        quizName: z.string(),
+        quiz: zodLocalQuiz,
+      })
+    )
+    .mutation(async ({ input: { courseName, moduleName, quizName, quiz } }) => {
+      await fileStorageService.quizzes.updateQuiz({
+        courseName,
+        moduleName,
+        quizName,
+        quiz,
+      });
+    }),
+  updateQuiz: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        previousModuleName: z.string(),
+        previousQuizName: z.string(),
+        quizName: z.string(),
+        quiz: zodLocalQuiz,
+      })
+    )
+    .mutation(
+      async ({
+        input: {
+          courseName,
+          moduleName,
+          quizName,
+          quiz,
+          previousModuleName,
+          previousQuizName,
+        },
+      }) => {
+        await fileStorageService.quizzes.updateQuiz({
+          courseName,
+          moduleName,
+          quizName,
+          quiz,
+        });
+
+        if (
+          quiz.name !== previousQuizName ||
+          moduleName !== previousModuleName
+        ) {
+          fileStorageService.quizzes.delete({
+            courseName,
+            moduleName: previousModuleName,
+            quizName: previousQuizName,
+          });
+        }
+      }
+    ),
+  deleteQuiz: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+        moduleName: z.string(),
+        quizName: z.string(),
+      })
+    )
+    .mutation(async ({ input: { courseName, moduleName, quizName } }) => {
+      await fileStorageService.quizzes.delete({
+        courseName,
+        moduleName,
+        quizName,
+      });
+    }),
+});

src/services/serverFunctions/router/settingsRouter.ts

@@ -0,0 +1,148 @@
+import publicProcedure from "../procedures/public";
+import { z } from "zod";
+import { router } from "../trpcSetup";
+import { fileStorageService } from "@/services/fileStorage/fileStorageService";
+import { zodLocalCourseSettings } from "@/models/local/localCourseSettings";
+import { trpc } from "../trpcClient";
+import {
+  getLectures,
+  updateLecture,
+} from "@/services/fileStorage/lectureFileStorageService";
+import {
+  prepAssignmentForNewSemester,
+  prepLectureForNewSemester,
+  prepPageForNewSemester,
+  prepQuizForNewSemester,
+} from "@/models/local/utils/semesterTransferUtils";
+
+export const settingsRouter = router({
+  allCoursesSettings: publicProcedure.query(async () => {
+    return await fileStorageService.settings.getAllCoursesSettings();
+  }),
+  courseSettings: publicProcedure
+    .input(
+      z.object({
+        courseName: z.string(),
+      })
+    )
+    .query(async ({ input: { courseName } }) => {
+      const settingsList =
+        await fileStorageService.settings.getAllCoursesSettings();
+      const s = settingsList.find((s) => s.name === courseName);
+      if (!s) {
+        console.log(courseName, settingsList);
+        throw Error("Could not find settings for course " + courseName);
+      }
+      return s;
+    }),
+  createCourse: publicProcedure
+    .input(
+      z.object({
+        settings: zodLocalCourseSettings,
+        settingsFromCourseToImport: zodLocalCourseSettings.optional(),
+      })
+    )
+    .mutation(async ({ input: { settings, settingsFromCourseToImport } }) => {
+      await fileStorageService.settings.updateCourseSettings(
+        settings.name,
+        settings
+      );
+
+      if (settingsFromCourseToImport) {
+        const oldCourseName = settingsFromCourseToImport.name;
+        const newCourseName = settings.name;
+        const oldModules = await fileStorageService.modules.getModuleNames(
+          oldCourseName
+        );
+        await Promise.all(
+          oldModules.map(async (moduleName) => {
+            await fileStorageService.modules.createModule(
+              newCourseName,
+              moduleName
+            );
+
+            const [oldAssignments, oldQuizzes, oldPages, oldLecturesByWeek] =
+              await Promise.all([
+                fileStorageService.assignments.getAssignments(
+                  oldCourseName,
+                  moduleName
+                ),
+                await fileStorageService.quizzes.getQuizzes(
+                  oldCourseName,
+                  moduleName
+                ),
+                await fileStorageService.pages.getPages(
+                  oldCourseName,
+                  moduleName
+                ),
+                await getLectures(oldCourseName),
+              ]);
+
+            await Promise.all([
+              ...oldAssignments.map(async (oldAssignment) => {
+                const newAssignment = prepAssignmentForNewSemester(
+                  oldAssignment,
+                  settingsFromCourseToImport.startDate,
+                  settings.startDate
+                );
+                await fileStorageService.assignments.updateOrCreateAssignment({
+                  courseName: newCourseName,
+                  moduleName,
+                  assignmentName: newAssignment.name,
+                  assignment: newAssignment,
+                });
+              }),
+              ...oldQuizzes.map(async (oldQuiz) => {
+                const newQuiz = prepQuizForNewSemester(
+                  oldQuiz,
+                  settingsFromCourseToImport.startDate,
+                  settings.startDate
+                );
+                await fileStorageService.quizzes.updateQuiz({
+                  courseName: newCourseName,
+                  moduleName,
+                  quizName: newQuiz.name,
+                  quiz: newQuiz,
+                });
+              }),
+              ...oldPages.map(async (oldPage) => {
+                const newPage = prepPageForNewSemester(
+                  oldPage,
+                  settingsFromCourseToImport.startDate,
+                  settings.startDate
+                );
+                await fileStorageService.pages.updatePage({
+                  courseName: newCourseName,
+                  moduleName,
+                  pageName: newPage.name,
+                  page: newPage,
+                });
+              }),
+              ...oldLecturesByWeek.flatMap(async (oldLectureByWeek) =>
+                oldLectureByWeek.lectures.map(async (oldLecture) => {
+                  const newLecture = prepLectureForNewSemester(
+                    oldLecture,
+                    settingsFromCourseToImport.startDate,
+                    settings.startDate
+                  );
+                  await updateLecture(newCourseName, settings, newLecture);
+                })
+              ),
+            ]);
+          })
+        );
+      }
+    }),
+  updateSettings: publicProcedure
+    .input(
+      z.object({
+        settings: zodLocalCourseSettings,
+      })
+    )
+    .mutation(async ({ input: { settings } }) => {
+      await fileStorageService.settings.updateCourseSettings(
+        settings.name,
+        settings
+      );
+    }),
+});