got basic question and answer creation from canvas

Management/Features/Configuration/Synchronization/AssignmentSyncronizationExtensions.cs

@@ -9,10 +9,9 @@ namespace Management.Planner;
 
 public static partial class AssignmentSyncronizationExtensions
 {
-
   internal static async Task<LocalAssignment> SyncAssignmentToCanvas(
     this LocalCourse localCourse,
-    ulong canvasId,
+    ulong canvasCourseId,
     LocalAssignment localAssignment,
     IEnumerable<CanvasAssignment> canvasAssignments,
     CanvasService canvas
@@ -25,23 +24,41 @@ public static partial class AssignmentSyncronizationExtensions
       localCourse.AssignmentTemplates
     );
 
-    if (canvasAssignment != null)
-    {
-      var assignmentNeedsUpdates = localAssignment.NeedsUpdates(
+    return canvasAssignment != null
+      ? await updateAssignmentIfNeeded(
+        localCourse,
+        canvasCourseId,
+        localAssignment,
         canvasAssignments,
-        localCourse.AssignmentTemplates,
-        quiet: false
-      );
-      if (assignmentNeedsUpdates)
-      {
-        await canvas.Assignments.Update(courseId: canvasId, localAssignment, localHtmlDescription);
-      }
-      return localAssignment;
-    }
-    else
+        canvas,
+        localHtmlDescription
+      )
+      : await canvas.Assignments.Create(canvasCourseId, localAssignment, localHtmlDescription);
+  }
+
+  private static async Task<LocalAssignment> updateAssignmentIfNeeded(
+    LocalCourse localCourse,
+    ulong canvasCourseId,
+    LocalAssignment localAssignment,
+    IEnumerable<CanvasAssignment> canvasAssignments,
+    CanvasService canvas,
+    string localHtmlDescription
+  )
+  {
+    var assignmentNeedsUpdates = localAssignment.NeedsUpdates(
+      canvasAssignments,
+      localCourse.AssignmentTemplates,
+      quiet: false
+    );
+    if (assignmentNeedsUpdates)
     {
-      return await canvas.Assignments.Create(canvasId, localAssignment, localHtmlDescription);
+      await canvas.Assignments.Update(
+        courseId: canvasCourseId,
+        localAssignment,
+        localHtmlDescription
+      );
     }
+    return localAssignment;
   }
 
   public static bool NeedsUpdates(
@@ -168,7 +185,7 @@ public static partial class AssignmentSyncronizationExtensions
 
   internal static async Task<LocalCourse> SyncAssignmentsWithCanvas(
     this LocalCourse localCourse,
-    ulong canvasId,
+    ulong canvasCourseId,
     IEnumerable<CanvasAssignment> canvasAssignments,
     CanvasService canvas
   )
@@ -176,7 +193,7 @@ public static partial class AssignmentSyncronizationExtensions
     var moduleTasks = localCourse.Modules.Select(async m =>
     {
       var assignmentTasks = m.Assignments.Select(
-        (a) => localCourse.SyncAssignmentToCanvas(canvasId, a, canvasAssignments, canvas)
+        (a) => localCourse.SyncAssignmentToCanvas(canvasCourseId, a, canvasAssignments, canvas)
       );
       var assignments = await Task.WhenAll(assignmentTasks);
       return m with { Assignments = assignments };

Management/Features/Configuration/Synchronization/ModuleSyncronizationExtensions.cs

@@ -69,4 +69,99 @@ public static partial class ModuleSyncronizationExtensions
       })
     };
   }
+  internal static async Task SortModuleItems(
+    this LocalModule localModule,
+    ulong canvasId,
+    ulong moduleCanvasId,
+    IEnumerable<CanvasModuleItem> canvasModuleItems,
+    CanvasService canvas
+  )
+  {
+    var localItemsWithCorrectOrder = localModule.Assignments
+      .OrderBy(a => a.DueAt)
+      .Select((a, i) => (Assignment: a, Position: i + 1));
+
+    var canvasContentIdsByCurrentPosition =
+      canvasModuleItems.ToDictionary(item => item.Position, item => item.ContentId)
+      ?? new Dictionary<int, ulong?>();
+
+    foreach (var (localAssignment, position) in localItemsWithCorrectOrder)
+    {
+      var itemIsInCorrectOrder =
+        canvasContentIdsByCurrentPosition.ContainsKey(position)
+        && canvasContentIdsByCurrentPosition[position] == localAssignment.CanvasId;
+
+      var currentCanvasItem = canvasModuleItems.First(i => i.ContentId == localAssignment.CanvasId);
+      if (!itemIsInCorrectOrder)
+      {
+        await canvas.UpdateModuleItem(
+          canvasId,
+          moduleCanvasId,
+          currentCanvasItem with
+          {
+            Position = position
+          }
+        );
+      }
+    }
+  }
+
+  internal static async Task<bool> EnsureAllModulesItemsCreated(
+    this LocalModule localModule,
+    ulong canvasId,
+    ulong moduleCanvasId,
+    Dictionary<ulong, IEnumerable<CanvasModuleItem>> canvasModulesItems,
+    CanvasService canvas
+  )
+  {
+    var anyUpdated = false;
+    foreach (var localAssignment in localModule.Assignments)
+    {
+      var canvasModuleItemContentIds = canvasModulesItems[moduleCanvasId].Select(i => i.ContentId);
+      if (!canvasModuleItemContentIds.Contains(localAssignment.CanvasId))
+      {
+        var canvasAssignmentId =
+          localAssignment.CanvasId
+          ?? throw new Exception("cannot create module item if assignment does not have canvas id");
+        await canvas.CreateModuleItem(
+          canvasId,
+          moduleCanvasId,
+          localAssignment.Name,
+          "Assignment",
+          canvasAssignmentId
+        );
+        anyUpdated = true;
+      }
+    }
+
+    return anyUpdated;
+  }
+
+  internal static async Task SyncModuleItemsWithCanvas(
+    this LocalCourse localCourse,
+    ulong canvasId,
+    Dictionary<ulong, IEnumerable<CanvasModuleItem>> canvasModulesItems,
+    CanvasService canvas
+  )
+  {
+    foreach (var localModule in localCourse.Modules)
+    {
+      var moduleCanvasId =
+        localModule.CanvasId
+        ?? throw new Exception("cannot sync canvas modules items if module not synced with canvas");
+
+      bool anyUpdated = await localModule.EnsureAllModulesItemsCreated(
+        canvasId,
+        moduleCanvasId,
+        canvasModulesItems,
+        canvas
+      );
+
+      var canvasModuleItems = anyUpdated
+        ? await canvas.GetModuleItems(canvasId, moduleCanvasId)
+        : canvasModulesItems[moduleCanvasId];
+
+      await localModule.SortModuleItems(canvasId, moduleCanvasId, canvasModuleItems, canvas);
+    }
+  }
 }

Management/Features/Configuration/Synchronization/QuizSyncronizationExtensions.cs

@@ -9,16 +9,9 @@ namespace Management.Planner;
 
 public static partial class QuizSyncronizationExtensions
 {
-  internal static async Task<LocalQuiz> SyncQuizToCanvas(
-    this LocalCourse localCourse,
-    ulong canvasId,
-    LocalQuiz localQuiz,
-    IEnumerable<CanvasQuiz> canvasQuizzes,
-    CanvasService canvas
-  )
+  public static bool QuizIsCreated(this LocalQuiz localQuiz, IEnumerable<CanvasQuiz> canvasQuizzes)
   {
-    // TODO actually sync
-    return localQuiz;
+    return canvasQuizzes.Any(q => q.Id == localQuiz.CanvasId);
   }
 
   internal static async Task<LocalCourse> SyncQuizzesWithCanvas(
@@ -38,6 +31,28 @@ public static partial class QuizSyncronizationExtensions
     });
 
     var modules = await Task.WhenAll(moduleTasks);
-    return localCourse;
+    return localCourse with { Modules = modules };
+  }
+
+  internal static async Task<LocalQuiz> SyncQuizToCanvas(
+    this LocalCourse localCourse,
+    ulong canvasCourseId,
+    LocalQuiz localQuiz,
+    IEnumerable<CanvasQuiz> canvasQuizzes,
+    CanvasService canvas
+  )
+  {
+    var isCreated = localQuiz.QuizIsCreated(canvasQuizzes);
+
+    if (isCreated)
+    {
+      // TODO write update
+    }
+    else
+    {
+      return await canvas.Quizzes.Create(canvasCourseId, localQuiz);
+    }
+
+    return localQuiz;
   }
 }