working on assignment groups

nextjs/src/app/course/[courseName]/settings/AssignmentGroupManagement.tsx

@@ -9,6 +9,7 @@ import { useEffect, useState } from "react";
 import TextInput from "../../../../components/form/TextInput";
 import { useSetAssignmentGroupsMutation } from "@/hooks/canvas/canvasCourseHooks";
 import { settingsBox } from "./sharedSettings";
+import { Spinner } from "@/components/Spinner";
 
 export default function AssignmentGroupManagement() {
   const [settings] = useLocalCourseSettingsQuery();
@@ -93,6 +94,29 @@ export default function AssignmentGroupManagement() {
           Add Assignment Group
         </button>
       </div>
+      <br />
+      <div className="flex justify-end">
+        <button
+          onClick={() => {
+            applyInCanvas.mutate(settings);
+          }}
+          disabled={applyInCanvas.isPending}
+        >
+          Update Assignment Groups In Canvas
+        </button>
+        {applyInCanvas.isPending && <Spinner />}
+        {applyInCanvas.isSuccess && (
+          <div>
+            {
+              "You will need to go to your course assignments page > settings > Assignment Group Weights"
+            }
+            <br />
+            {
+              "and check the 'Weight final grade based on assignment groups' box"
+            }
+          </div>
+        )}
+      </div>
     </div>
   );
 }

nextjs/src/app/newCourse/NewCourseForm.tsx

@@ -100,7 +100,7 @@ export default function NewCourseForm() {
                       (assignmentGroup) => {
                         const { canvasId, ...groupWithoutCanvas } =
                           assignmentGroup;
-                        return groupWithoutCanvas;
+                        return { ...groupWithoutCanvas, canvasId: undefined };
                       }
                     ),
                   }

nextjs/src/hooks/canvas/canvasCourseHooks.ts

@@ -1,9 +1,12 @@
 import { CanvasAssignmentGroup } from "@/models/canvas/assignments/canvasAssignmentGroup";
 import { CanvasCourseModel } from "@/models/canvas/courses/canvasCourseModel";
 import { LocalAssignmentGroup } from "@/models/local/assignment/localAssignmentGroup";
+import { LocalCourseSettings } from "@/models/local/localCourseSettings";
 import { canvasAssignmentGroupService } from "@/services/canvas/canvasAssignmentGroupService";
 import { canvasService } from "@/services/canvas/canvasService";
+import { trpc } from "@/services/trpc/utils";
 import { useMutation, useQuery } from "@tanstack/react-query";
+import { useUpdateLocalCourseSettingsMutation } from "../localCourse/localCoursesHooks";
 
 export const canvasCourseKeys = {
   courseDetails: (canavasId: number) =>
@@ -22,39 +25,65 @@ export const useCourseListInTermQuery = (canvasTermId: number | undefined) =>
     enabled: !!canvasTermId,
   });
 
-// export const useCanvasCourseQuery = (canvasId: number) =>
-//   useQuery({
-//     queryKey: canvasCourseKeys.courseDetails(canvasId),
-//     queryFn: async () => await canvasService.getCourse(canvasId),
-//   });
-
 export const useSetAssignmentGroupsMutation = (canvasId: number) => {
+  const updateSettingsMutation = useUpdateLocalCourseSettingsMutation();
   const { data: canvasAssignmentGroups } = useAssignmentGroupsQuery(canvasId);
   return useMutation({
-    mutationFn: async (localAssignmentGroups: LocalAssignmentGroup[]) => {
+    mutationFn: async (settings: LocalCourseSettings) => {
-      if (!canvasAssignmentGroups) return;
+      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([
+      console.log("updating canvas groups", groupsToDelete);
-        ...groupsToDelete.map(
+      await Promise.all(
+        groupsToDelete.map(
           async (g: CanvasAssignmentGroup) =>
             await canvasAssignmentGroupService.delete(canvasId, g.id, g.name)
-        ),
+        )
-        ...localAssignmentGroups.map(async (group) => {
+      );
-          const canvasGroup = canvasAssignmentGroups.find(
+      const updatedGroups = await Promise.all(
-            (c: CanvasAssignmentGroup) => c.name === group.name
+        localAssignmentGroups.map(
-          );
+          async (group): Promise<LocalAssignmentGroup> => {
-          if (!canvasGroup) {
+            const canvasGroup = canvasAssignmentGroups.find(
-            await canvasAssignmentGroupService.create(canvasId, group);
+              (c: CanvasAssignmentGroup) => c.name === group.name
-          } else {
+            );
-            if (canvasGroup.group_weight !== group.weight)
+            if (!canvasGroup) {
-              await canvasAssignmentGroupService.update(canvasId, group);
+              const newGroup = await canvasAssignmentGroupService.create(
+                canvasId,
+                group
+              );
+              return {
+                ...group,
+                canvasId: newGroup.canvasId,
+              };
+            } else {
+              if (canvasGroup.group_weight !== group.weight) {
+                await canvasAssignmentGroupService.update(canvasId, group);
+              }
+              return {
+                ...group,
+                canvasId: canvasGroup.id,
+              };
+            }
           }
-        }),
+        )
-      ]);
+      );
+
+      const updatedSettings: LocalCourseSettings = {
+        ...settings,
+        assignmentGroups: updatedGroups,
+      };
+      console.log(
+        "finished updating canvas assignment groups, updating settings of file system",
+        updatedSettings
+      );
+      await updateSettingsMutation.mutateAsync({ settings: updatedSettings });
     },
   });
 };
@@ -62,6 +91,7 @@ export const useSetAssignmentGroupsMutation = (canvasId: number) => {
 export const useAssignmentGroupsQuery = (canvasId: number) => {
   return useQuery({
     queryKey: canvasCourseKeys.assignmentGroups(canvasId),
-    queryFn: async (): Promise<CanvasAssignmentGroup[]> => await canvasAssignmentGroupService.getAll(canvasId),
+    queryFn: async (): Promise<CanvasAssignmentGroup[]> =>
+      await canvasAssignmentGroupService.getAll(canvasId),
   });
 };

nextjs/src/hooks/localCourse/localCoursesHooks.ts

@@ -24,7 +24,7 @@ export const useUpdateLocalCourseSettingsMutation = () => {
   const { courseName } = useCourseContext();
   const utils = trpc.useUtils();
 
-  return trpc.settings.createCourse.useMutation({
+  return trpc.settings.updateSettings.useMutation({
     onSuccess: () => {
       utils.settings.allCoursesSettings.invalidate();
       utils.settings.courseSettings.invalidate({ courseName });