moving v2 to top level

src/hooks/canvas/canvasAssignmentHooks.ts

@@ -0,0 +1,130 @@
+import { canvasAssignmentService } from "@/services/canvas/canvasAssignmentService";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useLocalCourseSettingsQuery } from "../localCourse/localCoursesHooks";
+import { LocalAssignment } from "@/models/local/assignment/localAssignment";
+import { canvasModuleService } from "@/services/canvas/canvasModuleService";
+import {
+  useAddCanvasModuleMutation,
+  useCanvasModulesQuery,
+} from "./canvasModuleHooks";
+
+export const canvasAssignmentKeys = {
+  assignments: (canvasCourseId: number) =>
+    ["canvas", canvasCourseId, "assignments"] as const,
+};
+
+export const useCanvasAssignmentsQuery = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+
+  return useQuery({
+    queryKey: canvasAssignmentKeys.assignments(settings.canvasId),
+    queryFn: async () => canvasAssignmentService.getAll(settings.canvasId),
+  });
+};
+
+
+export const useAddAssignmentToCanvasMutation = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+  const { data: canvasModules } = useCanvasModulesQuery();
+  const addModule = useAddCanvasModuleMutation();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      assignment,
+      moduleName,
+    }: {
+      assignment: LocalAssignment;
+      moduleName: string;
+    }) => {
+      if (!canvasModules) {
+        console.log("cannot add assignment until modules loaded");
+        return;
+      }
+
+      const assignmentGroup = settings.assignmentGroups.find(
+        (g) => g.name === assignment.localAssignmentGroupName
+      );
+
+      const canvasAssignmentId = await canvasAssignmentService.create(
+        settings.canvasId,
+        assignment,
+        settings,
+        assignmentGroup?.canvasId
+      );
+      const canvasModule = canvasModules.find((c) => c.name === moduleName);
+      const moduleId = canvasModule
+        ? canvasModule.id
+        : await addModule.mutateAsync(moduleName);
+
+      await canvasModuleService.createModuleItem(
+        settings.canvasId,
+        moduleId,
+        assignment.name,
+        "Assignment",
+        canvasAssignmentId
+      );
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: canvasAssignmentKeys.assignments(settings.canvasId),
+      });
+    },
+  });
+};
+
+export const useUpdateAssignmentInCanvasMutation = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      assignment,
+      canvasAssignmentId,
+    }: {
+      assignment: LocalAssignment;
+      canvasAssignmentId: number;
+    }) => {
+      const assignmentGroup = settings.assignmentGroups.find(
+        (g) => g.name === assignment.localAssignmentGroupName
+      );
+      await canvasAssignmentService.update(
+        settings.canvasId,
+        canvasAssignmentId,
+        assignment,
+        settings,
+        assignmentGroup?.canvasId
+      );
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: canvasAssignmentKeys.assignments(settings.canvasId),
+      });
+    },
+  });
+};
+
+export const useDeleteAssignmentFromCanvasMutation = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({
+      canvasAssignmentId,
+      assignmentName,
+    }: {
+      canvasAssignmentId: number;
+      assignmentName: string;
+    }) => {
+      await canvasAssignmentService.delete(
+        settings.canvasId,
+        canvasAssignmentId,
+        assignmentName
+      );
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: canvasAssignmentKeys.assignments(settings.canvasId),
+      });
+    },
+  });
+};

src/hooks/canvas/canvasCourseHooks.ts

@@ -0,0 +1,103 @@
+import { CanvasAssignmentGroup } from "@/models/canvas/assignments/canvasAssignmentGroup";
+import { CanvasCourseModel } from "@/models/canvas/courses/canvasCourseModel";
+import { LocalAssignmentGroup } from "@/models/local/assignment/localAssignmentGroup";
+import {
+  LocalCourseSettings,
+  zodLocalCourseSettings,
+} from "@/models/local/localCourseSettings";
+import { canvasAssignmentGroupService } from "@/services/canvas/canvasAssignmentGroupService";
+import { canvasService } from "@/services/canvas/canvasService";
+import { trpc } from "@/services/serverFunctions/trpcClient";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { useUpdateLocalCourseSettingsMutation } from "../localCourse/localCoursesHooks";
+import { useCourseContext } from "@/app/course/[courseName]/context/courseContext";
+
+export const canvasCourseKeys = {
+  courseDetails: (canavasId: number) =>
+    ["canvas", canavasId, "course details"] as const,
+  assignmentGroups: (canavasId: number) =>
+    ["canvas", canavasId, "assignment groups"] as const,
+  courseListInTerm: (canvasTermId: number | undefined) =>
+    ["canvas courses in term", canvasTermId] as const,
+};
+
+export const useCourseListInTermQuery = (canvasTermId: number | undefined) =>
+  useQuery({
+    queryKey: canvasCourseKeys.courseListInTerm(canvasTermId),
+    queryFn: async (): Promise<CanvasCourseModel[]> =>
+      canvasTermId ? await canvasService.getCourses(canvasTermId) : [],
+    enabled: !!canvasTermId,
+  });
+
+export const useSetAssignmentGroupsMutation = (canvasId: number) => {
+  const updateSettingsMutation = useUpdateLocalCourseSettingsMutation();
+  const { data: canvasAssignmentGroups } = useAssignmentGroupsQuery(canvasId);
+  return useMutation({
+    mutationFn: async (settings: LocalCourseSettings) => {
+      if (typeof canvasAssignmentGroups === "undefined") {
+        console.log("cannot apply groups if no groups loaded");
+        return;
+      }
+      const localAssignmentGroups = settings.assignmentGroups;
+
+      const localNames = localAssignmentGroups.map((g) => g.name);
+      const groupsToDelete = canvasAssignmentGroups.filter(
+        (c: CanvasAssignmentGroup) => !localNames.includes(c.name)
+      );
+
+      await Promise.all(
+        groupsToDelete.map(
+          async (g: CanvasAssignmentGroup) =>
+            await canvasAssignmentGroupService.delete(canvasId, g.id, g.name)
+        )
+      );
+      const updatedGroups = await Promise.all(
+        localAssignmentGroups.map(
+          async (group): Promise<LocalAssignmentGroup> => {
+            const canvasGroup = canvasAssignmentGroups.find(
+              (c: CanvasAssignmentGroup) => c.name === group.name
+            );
+            if (!canvasGroup) {
+              const newGroup = await canvasAssignmentGroupService.create(
+                canvasId,
+                group
+              );
+              return {
+                ...group,
+                canvasId: newGroup.canvasId,
+              };
+            } else {
+              const groupWithCanvasId = {
+                ...group,
+                canvasId: canvasGroup.id,
+              };
+              if (canvasGroup.group_weight !== group.weight) {
+                await canvasAssignmentGroupService.update(
+                  canvasId,
+                  groupWithCanvasId
+                );
+              }
+              return groupWithCanvasId;
+            }
+          }
+        )
+      );
+
+      const updatedSettings: LocalCourseSettings = {
+        ...settings,
+        assignmentGroups: updatedGroups,
+      };
+
+      await updateSettingsMutation.mutateAsync({ settings: updatedSettings });
+      return updatedSettings;
+    },
+  });
+};
+
+export const useAssignmentGroupsQuery = (canvasId: number) => {
+  return useQuery({
+    queryKey: canvasCourseKeys.assignmentGroups(canvasId),
+    queryFn: async (): Promise<CanvasAssignmentGroup[]> =>
+      await canvasAssignmentGroupService.getAll(canvasId),
+  });
+};

src/hooks/canvas/canvasHooks.ts

@@ -0,0 +1,38 @@
+import { canvasService } from "@/services/canvas/canvasService";
+import { useSuspenseQuery } from "@tanstack/react-query";
+
+export const canvasKeys = {
+  allTerms: ["all canvas terms"] as const,
+  allAroundDate: (date: Date) => ["all canvas terms", date] as const,
+};
+
+export const useAllCanvasTermsQuery = () =>
+  useSuspenseQuery({
+    queryKey: canvasKeys.allTerms,
+    queryFn: canvasService.getAllTerms,
+  });
+export const useCanvasTermsQuery = (queryDate: Date) => {
+  const { data: terms } = useAllCanvasTermsQuery();
+
+  return useSuspenseQuery({
+    queryKey: canvasKeys.allAroundDate(queryDate),
+    queryFn: () => {
+      const finiteTerms = terms.filter((t) => {
+        if (!t.end_at) return false;
+
+        const endDate = new Date(t.end_at);
+        return endDate > queryDate;
+      });
+      console.log("finite terms", finiteTerms, terms);
+      const currentTerms = finiteTerms
+        .sort(
+          (a, b) =>
+            new Date(a.start_at ?? "").getTime() -
+            new Date(b.start_at ?? "").getTime()
+        )
+        .slice(0, 3);
+
+      return currentTerms;
+    },
+  });
+};

src/hooks/canvas/canvasModuleHooks.ts

@@ -0,0 +1,34 @@
+import { canvasModuleService } from "@/services/canvas/canvasModuleService";
+import {
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from "@tanstack/react-query";
+import { useLocalCourseSettingsQuery } from "../localCourse/localCoursesHooks";
+
+export const canvasCourseModuleKeys = {
+  modules: (canvasId: number) => ["canvas", canvasId, "module list"] as const,
+};
+
+export const useCanvasModulesQuery = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+  return useQuery({
+    queryKey: canvasCourseModuleKeys.modules(settings.canvasId),
+    queryFn: async () =>
+      await canvasModuleService.getCourseModules(settings.canvasId),
+  });
+};
+
+export const useAddCanvasModuleMutation = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (moduleName: string) =>
+      await canvasModuleService.createModule(settings.canvasId, moduleName),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: canvasCourseModuleKeys.modules(settings.canvasId),
+      });
+    },
+  });
+};

src/hooks/canvas/canvasPageHooks.ts

@@ -0,0 +1,102 @@
+import { LocalCoursePage } from "@/models/local/page/localCoursePage";
+import { canvasPageService } from "@/services/canvas/canvasPageService";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useLocalCourseSettingsQuery } from "../localCourse/localCoursesHooks";
+import { canvasModuleService } from "@/services/canvas/canvasModuleService";
+import {
+  useCanvasModulesQuery,
+  useAddCanvasModuleMutation,
+} from "./canvasModuleHooks";
+
+export const canvasPageKeys = {
+  pagesInCourse: (courseCanvasId: number) => [
+    "canvas",
+    courseCanvasId,
+    "pages",
+  ],
+};
+
+export const useCanvasPagesQuery = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+  return useQuery({
+    queryKey: canvasPageKeys.pagesInCourse(settings.canvasId),
+    queryFn: async () => await canvasPageService.getAll(settings.canvasId),
+  });
+};
+
+export const useCreateCanvasPageMutation = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+  const queryClient = useQueryClient();
+  const { data: canvasModules } = useCanvasModulesQuery();
+  const addModule = useAddCanvasModuleMutation();
+
+  return useMutation({
+    mutationFn: async ({
+      page,
+      moduleName,
+    }: {
+      page: LocalCoursePage;
+      moduleName: string;
+    }) => {
+      if (!canvasModules) {
+        console.log("cannot add page until modules loaded");
+        return;
+      }
+      const canvasPage = await canvasPageService.create(
+        settings.canvasId,
+        page,settings
+      );
+
+      const canvasModule = canvasModules.find((c) => c.name === moduleName);
+      const moduleId = canvasModule
+        ? canvasModule.id
+        : await addModule.mutateAsync(moduleName);
+
+      await canvasModuleService.createPageModuleItem(
+        settings.canvasId,
+        moduleId,
+        page.name,
+        canvasPage
+      );
+      return canvasPage;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: canvasPageKeys.pagesInCourse(settings.canvasId),
+      });
+    },
+  });
+};
+
+export const useUpdateCanvasPageMutation = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({
+      page,
+      canvasPageId,
+    }: {
+      page: LocalCoursePage;
+      canvasPageId: number;
+    }) => canvasPageService.update(settings.canvasId, canvasPageId, page, settings),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: canvasPageKeys.pagesInCourse(settings.canvasId),
+      });
+    },
+  });
+};
+
+export const useDeleteCanvasPageMutation = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (canvasPageId: number) =>
+      canvasPageService.delete(settings.canvasId, canvasPageId),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: canvasPageKeys.pagesInCourse(settings.canvasId),
+      });
+    },
+  });
+};

src/hooks/canvas/canvasQuizHooks.ts

@@ -0,0 +1,91 @@
+import {
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from "@tanstack/react-query";
+import { useLocalCourseSettingsQuery } from "../localCourse/localCoursesHooks";
+import { canvasQuizService } from "@/services/canvas/canvasQuizService";
+import { LocalQuiz } from "@/models/local/quiz/localQuiz";
+import {
+  useAddCanvasModuleMutation,
+  useCanvasModulesQuery,
+} from "./canvasModuleHooks";
+import { canvasModuleService } from "@/services/canvas/canvasModuleService";
+
+export const canvasQuizKeys = {
+  quizzes: (canvasCourseId: number) =>
+    ["canvas", canvasCourseId, "quizzes"] as const,
+};
+
+export const useCanvasQuizzesQuery = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+
+  return useQuery({
+    queryKey: canvasQuizKeys.quizzes(settings.canvasId),
+    queryFn: async () => canvasQuizService.getAll(settings.canvasId),
+  });
+};
+
+export const useAddQuizToCanvasMutation = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+  const queryClient = useQueryClient();
+  const { data: canvasModules } = useCanvasModulesQuery();
+  const addModule = useAddCanvasModuleMutation();
+
+  return useMutation({
+    mutationFn: async ({
+      quiz,
+      moduleName,
+    }: {
+      quiz: LocalQuiz;
+      moduleName: string;
+    }) => {
+      if (!canvasModules) {
+        console.log("cannot add quiz until modules loaded");
+        return;
+      }
+      const assignmentGroup = settings.assignmentGroups.find(
+        (g) => g.name === quiz.localAssignmentGroupName
+      );
+      const canvasQuizId = await canvasQuizService.create(
+        settings.canvasId,
+        quiz,
+        settings,
+        assignmentGroup?.canvasId
+      );
+
+      const canvasModule = canvasModules.find((c) => c.name === moduleName);
+      const moduleId = canvasModule
+        ? canvasModule.id
+        : await addModule.mutateAsync(moduleName);
+
+      await canvasModuleService.createModuleItem(
+        settings.canvasId,
+        moduleId,
+        quiz.name,
+        "Quiz",
+        canvasQuizId
+      );
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: canvasQuizKeys.quizzes(settings.canvasId),
+      });
+    },
+  });
+};
+
+export const useDeleteQuizFromCanvasMutation = () => {
+  const [settings] = useLocalCourseSettingsQuery();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (canvasQuizId: number) => {
+      await canvasQuizService.delete(settings.canvasId, canvasQuizId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: canvasQuizKeys.quizzes(settings.canvasId),
+      });
+    },
+  });
+};

src/hooks/localCourse/assignmentHooks.ts

@@ -0,0 +1,147 @@
+"use client";
+import { trpc } from "@/services/serverFunctions/trpcClient";
+import { useCourseContext } from "@/app/course/[courseName]/context/courseContext";
+import {
+  useLocalCourseSettingsQuery,
+  useUpdateLocalCourseSettingsMutation,
+} from "./localCoursesHooks";
+import {
+  extractImageSources,
+  markdownToHtmlNoImages,
+} from "@/services/htmlMarkdownUtils";
+import { useActionState, useEffect, useState } from "react";
+
+export const useAssignmentQuery = (
+  moduleName: string,
+  assignmentName: string
+) => {
+  const { courseName } = useCourseContext();
+  return trpc.assignment.getAssignment.useSuspenseQuery({
+    moduleName,
+    courseName,
+    assignmentName,
+  });
+};
+
+export const useUpdateImageSettingsForAssignment = ({
+  moduleName,
+  assignmentName,
+}: {
+  moduleName: string;
+  assignmentName: string;
+}) => {
+  const [settings] = useLocalCourseSettingsQuery();
+  const [assignment] = useAssignmentQuery(moduleName, assignmentName);
+  const updateSettings = useUpdateLocalCourseSettingsMutation();
+  const [isUpdatingSettings, setIsUpdatingSettings] = useState(false);
+  const createCanvasUrlMutation =
+    trpc.canvasFile.getCanvasFileUrl.useMutation();
+
+  // useEffect(() => {
+  //   if (isUpdatingSettings) {
+  //     console.log("not updating image assets, still loading");
+  //     return;
+  //   }
+  //   setIsUpdatingSettings(true);
+  //   const assignmentMarkdown = markdownToHtmlNoImages(assignment.description);
+
+  //   const imageSources = extractImageSources(assignmentMarkdown);
+  //   const imagesToUpdate = imageSources.filter((source) =>
+  //     settings.assets.every((a) => a.sourceUrl !== source)
+  //   );
+  //   console.log("images to update", imagesToUpdate);
+
+  //   if (imagesToUpdate.length) {
+  //     Promise.all(
+  //       imagesToUpdate.map(async (source) => {
+  //         // todo: get canvas url
+  //         // const canvasUrl = "";
+  //         const canvasUrl = await createCanvasUrlMutation.mutateAsync({
+  //           sourceUrl: source,
+  //           canvasCourseId: settings.canvasId,
+  //         });
+  //         console.log("got canvas url", source, canvasUrl);
+  //         return { sourceUrl: source, canvasUrl };
+  //       })
+  //     ).then(async (newAssets) => {
+  //       await updateSettings.mutateAsync({
+  //         settings: {
+  //           ...settings,
+  //           assets: [...settings.assets, ...newAssets],
+  //         },
+  //       });
+  //       setIsUpdatingSettings(false);
+  //     });
+  //   }
+  // }, [
+  //   assignment.description,
+  //   createCanvasUrlMutation,
+  //   isUpdatingSettings,
+  //   settings,
+  //   settings.assets,
+  //   updateSettings,
+  // ]);
+};
+
+export const useAssignmentNamesQuery = (moduleName: string) => {
+  const { courseName } = useCourseContext();
+  return trpc.assignment.getAllAssignments.useSuspenseQuery(
+    {
+      moduleName,
+      courseName,
+    },
+    {
+      select: (assignments) => assignments.map((a) => a.name),
+    }
+  );
+};
+
+export const useUpdateAssignmentMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.assignment.updateAssignment.useMutation({
+    onSuccess: (
+      _,
+      { courseName, moduleName, assignmentName, previousAssignmentName }
+    ) => {
+      utils.assignment.getAllAssignments.invalidate({ courseName, moduleName });
+      utils.assignment.getAssignment.invalidate({
+        courseName,
+        moduleName,
+        assignmentName,
+      });
+      utils.assignment.getAssignment.invalidate({
+        courseName,
+        moduleName,
+        assignmentName: previousAssignmentName,
+      });
+    },
+  });
+};
+
+export const useCreateAssignmentMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.assignment.createAssignment.useMutation({
+    onSuccess: (_, { courseName, moduleName }) => {
+      utils.assignment.getAllAssignments.invalidate({ courseName, moduleName });
+    },
+  });
+};
+
+export const useDeleteAssignmentMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.assignment.deleteAssignment.useMutation({
+    onSuccess: (_, { courseName, moduleName, assignmentName }) => {
+      utils.assignment.getAllAssignments.invalidate({ courseName, moduleName });
+      utils.assignment.getAssignment.invalidate(
+        {
+          courseName,
+          moduleName,
+          assignmentName,
+        },
+        {
+          refetchType: "all",
+        }
+      );
+    },
+  });
+};

src/hooks/localCourse/lectureHooks.ts

@@ -0,0 +1,25 @@
+import { useCourseContext } from "@/app/course/[courseName]/context/courseContext";
+import { trpc } from "@/services/serverFunctions/trpcClient";
+
+export const useLecturesSuspenseQuery = () => {
+  const { courseName } = useCourseContext();
+  return trpc.lectures.getLectures.useSuspenseQuery({ courseName });
+};
+
+export const useLectureUpdateMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.lectures.updateLecture.useMutation({
+    onSuccess: () => {
+      utils.lectures.getLectures.invalidate();
+    },
+  });
+};
+
+export const useDeleteLectureMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.lectures.deleteLecture.useMutation({
+    onSuccess: () => {
+      utils.lectures.getLectures.invalidate();
+    },
+  });
+};

src/hooks/localCourse/localCourseModuleHooks.ts

@@ -0,0 +1,60 @@
+import { useCourseContext } from "@/app/course/[courseName]/context/courseContext";
+import { trpc } from "@/services/serverFunctions/trpcClient";
+import { LocalAssignment } from "@/models/local/assignment/localAssignment";
+
+export const useModuleNamesQuery = () => {
+  const { courseName } = useCourseContext();
+  return trpc.module.getModuleNames.useSuspenseQuery({ courseName });
+};
+
+export const useCreateModuleMutation = () => {
+  const { courseName } = useCourseContext();
+  const utils = trpc.useUtils();
+
+  return trpc.module.createModule.useMutation({
+    onSuccess: () => {
+      utils.module.getModuleNames.invalidate({ courseName });
+    },
+  });
+};
+
+export const useAllCourseDataQuery = (): {
+  assignmentsAndModules: {
+    moduleName: string;
+    assignment: LocalAssignment;
+  }[];
+  quizzesAndModules: any[];
+  pagesAndModules: any[];
+} => {
+  const { courseName } = useCourseContext();
+  const [moduleNames] = useModuleNamesQuery();
+  const [assignments] = trpc.useSuspenseQueries((t) =>
+    moduleNames.map((moduleName) =>
+      t.assignment.getAllAssignments({ courseName, moduleName })
+    )
+  );
+
+  const [quizzes] = trpc.useSuspenseQueries((t) =>
+    moduleNames.map((moduleName) =>
+      t.quiz.getAllQuizzes({ courseName, moduleName })
+    )
+  );
+
+  const [pages] = trpc.useSuspenseQueries((t) =>
+    moduleNames.map((moduleName) =>
+      t.page.getAllPages({ courseName, moduleName })
+    )
+  );
+
+  const assignmentsAndModules = moduleNames.flatMap((moduleName, index) => {
+    return assignments[index].map((assignment) => ({ moduleName, assignment }));
+  });
+  const quizzesAndModules = moduleNames.flatMap((moduleName, index) => {
+    return quizzes[index].map((quiz) => ({ moduleName, quiz }));
+  });
+  const pagesAndModules = moduleNames.flatMap((moduleName, index) => {
+    return pages[index].map((page) => ({ moduleName, page }));
+  });
+
+  return { assignmentsAndModules, quizzesAndModules, pagesAndModules };
+};

src/hooks/localCourse/localCoursesHooks.ts

@@ -0,0 +1,33 @@
+"use client";
+import { useCourseContext } from "@/app/course/[courseName]/context/courseContext";
+import { trpc } from "@/services/serverFunctions/trpcClient";
+
+export const useLocalCoursesSettingsQuery = () =>
+  trpc.settings.allCoursesSettings.useSuspenseQuery();
+
+export const useLocalCourseSettingsQuery = () => {
+  const { courseName } = useCourseContext();
+  return trpc.settings.courseSettings.useSuspenseQuery({ courseName });
+};
+
+export const useCreateLocalCourseMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.settings.createCourse.useMutation({
+    onSuccess: () => {
+      utils.settings.allCoursesSettings.invalidate();
+      utils.directories.getEmptyDirectories.invalidate();
+    },
+  });
+};
+
+export const useUpdateLocalCourseSettingsMutation = () => {
+  const { courseName } = useCourseContext();
+  const utils = trpc.useUtils();
+
+  return trpc.settings.updateSettings.useMutation({
+    onSuccess: () => {
+      utils.settings.allCoursesSettings.invalidate();
+      utils.settings.courseSettings.invalidate({ courseName });
+    },
+  });
+};

src/hooks/localCourse/pageHooks.ts

@@ -0,0 +1,53 @@
+"use client";
+
+import { useCourseContext } from "@/app/course/[courseName]/context/courseContext";
+import { trpc } from "@/services/serverFunctions/trpcClient";
+
+export const usePageQuery = (moduleName: string, pageName: string) => {
+  const { courseName } = useCourseContext();
+  return trpc.page.getPage.useSuspenseQuery({
+    courseName,
+    moduleName,
+    pageName,
+  });
+};
+
+export const usePagesQueries = (moduleName: string) => {
+  const { courseName } = useCourseContext();
+  return trpc.page.getAllPages.useSuspenseQuery({
+    courseName,
+    moduleName,
+  });
+};
+
+export const useUpdatePageMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.page.updatePage.useMutation({
+    onSuccess: (_, { courseName, moduleName, pageName }) => {
+      utils.page.getAllPages.invalidate({ courseName, moduleName });
+      utils.page.getPage.invalidate({ courseName, moduleName, pageName });
+    },
+  });
+};
+export const useCreatePageMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.page.createPage.useMutation({
+    onSuccess: (_, { courseName, moduleName }) => {
+      utils.page.getAllPages.invalidate({ courseName, moduleName });
+    },
+  });
+};
+export const useDeletePageMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.page.deletePage.useMutation({
+    onSuccess: (_, { courseName, moduleName, pageName }) => {
+      utils.page.getAllPages.invalidate(
+        { courseName, moduleName },
+        {
+          refetchType: "all",
+        }
+      );
+      utils.page.getPage.invalidate({ courseName, moduleName, pageName });
+    },
+  });
+};

src/hooks/localCourse/quizHooks.ts

@@ -0,0 +1,51 @@
+"use client";
+
+import { useCourseContext } from "@/app/course/[courseName]/context/courseContext";
+import { trpc } from "@/services/serverFunctions/trpcClient";
+
+export const useQuizQuery = (moduleName: string, quizName: string) => {
+  const { courseName } = useCourseContext();
+  return trpc.quiz.getQuiz.useSuspenseQuery({
+    courseName,
+    moduleName,
+    quizName,
+  });
+};
+
+export const useQuizzesQueries = (moduleName: string) => {
+  const { courseName } = useCourseContext();
+  return trpc.quiz.getAllQuizzes.useSuspenseQuery({
+    courseName,
+    moduleName,
+  });
+};
+
+export const useUpdateQuizMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.quiz.updateQuiz.useMutation({
+    onSuccess: (_, { courseName, moduleName, quizName }) => {
+      utils.quiz.getAllQuizzes.invalidate({ courseName, moduleName });
+      utils.quiz.getQuiz.invalidate({ courseName, moduleName, quizName });
+    },
+  });
+};
+export const useCreateQuizMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.quiz.createQuiz.useMutation({
+    onSuccess: (_, { courseName, moduleName }) => {
+      utils.quiz.getAllQuizzes.invalidate({ courseName, moduleName });
+    },
+  });
+};
+export const useDeleteQuizMutation = () => {
+  const utils = trpc.useUtils();
+  return trpc.quiz.deleteQuiz.useMutation({
+    onSuccess: (_, { courseName, moduleName, quizName }) => {
+      utils.quiz.getAllQuizzes.invalidate(
+        { courseName, moduleName },
+        { refetchType: "all" }
+      );
+      utils.quiz.getQuiz.invalidate({ courseName, moduleName, quizName });
+    },
+  });
+};

src/hooks/localCourse/storageDirectoryHooks.ts

@@ -0,0 +1,8 @@
+import { trpc } from "@/services/serverFunctions/trpcClient";
+
+export const directoryKeys = {
+  emptyFolders: ["empty folders"] as const,
+};
+
+export const useEmptyDirectoriesQuery = () =>
+  trpc.directories.getEmptyDirectories.useSuspenseQuery();