am syncing assignment groups

Management/Features/Configuration/AssignmentEditorContext.cs

@@ -17,7 +17,6 @@ public class AssignmentEditorContext
     get => _assignment;
     set
     {
-      Console.WriteLine("saving");
       _assignment = value;
       StateHasChanged?.Invoke();
     }

Management/Features/Configuration/CoursePlanner.cs

@@ -72,6 +72,7 @@ public class CoursePlanner
   public event Action? StateHasChanged;
 
   public IEnumerable<CanvasAssignment>? CanvasAssignments { get; internal set; }
+  public IEnumerable<CanvasAssignmentGroup>? CanvasAssignmentGroups { get; internal set; }
   public IEnumerable<CanvasQuiz>? CanvasQuizzes { get; internal set; }
   public IEnumerable<CanvasModule>? CanvasModules { get; internal set; }
   public Dictionary<ulong, IEnumerable<CanvasModuleItem>>? CanvasModulesItems { get; internal set; }
@@ -80,7 +81,8 @@ public class CoursePlanner
     IEnumerable<CanvasAssignment> CanvasAssignments,
     IEnumerable<CanvasModule> CanvasModules,
     Dictionary<ulong, IEnumerable<CanvasModuleItem>> CanvasModulesItems,
-    IEnumerable<CanvasQuiz> canvasQuizzes
+    IEnumerable<CanvasQuiz> canvasQuizzes,
+    IEnumerable<CanvasAssignmentGroup> canvasAssignmentGroups
   )> LoadCanvasData()
   {
     LoadingCanvasData = true;
@@ -92,16 +94,18 @@ public class CoursePlanner
     var assignmentsTask = canvas.Assignments.GetAll(canvasId);
     var quizzesTask = canvas.Quizzes.GetAll(canvasId);
     var modulesTask = canvas.GetModules(canvasId);
+    var assignmentGroupsTask = canvas.AssignmentGroups.GetAll(canvasId);
 
     CanvasAssignments = await assignmentsTask;
     CanvasQuizzes = await quizzesTask;
     CanvasModules = await modulesTask;
+    CanvasAssignmentGroups = await assignmentGroupsTask;
 
     CanvasModulesItems = await canvas.GetAllModulesItems(canvasId, CanvasModules);
 
     LoadingCanvasData = false;
     StateHasChanged?.Invoke();
-    return (CanvasAssignments, CanvasModules, CanvasModulesItems, CanvasQuizzes);
+    return (CanvasAssignments, CanvasModules, CanvasModulesItems, CanvasQuizzes, CanvasAssignmentGroups);
   }
 
   public async Task SyncWithCanvas()
@@ -119,18 +123,31 @@ public class CoursePlanner
     LoadingCanvasData = true;
     StateHasChanged?.Invoke();
 
-    var (canvasAssignments, canvasModules, canvasModuleItems, canvasQuizzes) = await LoadCanvasData();
+    var (
+      canvasAssignments,
+      canvasModules,
+      canvasModuleItems,
+      canvasQuizzes,
+      canvasAssignmentGroups
+    ) = await LoadCanvasData();
+
     LoadingCanvasData = true;
     StateHasChanged?.Invoke();
     LocalCourse = LocalCourse.deleteCanvasIdsThatNoLongerExist(
       canvasModules,
       canvasAssignments,
+      canvasAssignmentGroups,
       canvasQuizzes
     );
 
     var canvasId =
       LocalCourse.CanvasId ?? throw new Exception("no course canvas id to sync with canvas");
 
+    var newAssignmentGroups = await LocalCourse.EnsureAllAssignmentGroupsExistInCanvas(
+      canvasId, canvasAssignmentGroups, canvas);
+    LocalCourse = LocalCourse with { AssignmentGroups = newAssignmentGroups };
+
+
     var newModules = await LocalCourse.EnsureAllModulesExistInCanvas(
       canvasId,
       CanvasModules,

Management/Features/Configuration/CoursePlannerValidationExtensions.cs

@@ -47,6 +47,7 @@ public static class CoursePlannerExtensions
     this LocalCourse localCourse,
     IEnumerable<CanvasModule> canvasModules,
     IEnumerable<CanvasAssignment> canvasAssignments,
+    IEnumerable<CanvasAssignmentGroup> canvasAssignmentGroups,
     IEnumerable<CanvasQuiz> canvasQuizzes
   )
   {
@@ -56,9 +57,21 @@ public static class CoursePlannerExtensions
       .Select((m) => m.validateCanvasIds(canvasModules, canvasAssignments, canvasQuizzes))
       .ToArray();
 
+    var canvasAssignmentGroupIds = canvasAssignmentGroups.Select(g => g.Id).ToArray();
+    var correctAssignmentGroups = localCourse.AssignmentGroups.Select(
+      g =>
+      {
+        var groupCanvasId = g.CanvasId ?? 0;
+        return canvasAssignmentGroupIds.Contains(groupCanvasId)
+          ? g
+          : g with { CanvasId = null };
+      }
+    ).ToArray();
+
     return localCourse with
     {
-      Modules = correctedModules
+      Modules = correctedModules,
+      AssignmentGroups = correctAssignmentGroups,
     };
   }
 

Management/Features/Configuration/Synchronization/AssignemntGroupSyncronizationExtensions.cs

@@ -0,0 +1,40 @@
+using CanvasModel.Assignments;
+using CanvasModel.Modules;
+using LocalModels;
+using Management.Services.Canvas;
+
+namespace Management.Planner;
+
+public static partial class AssignmentGroupSyncronizationExtensions
+{
+  internal static async Task<IEnumerable<LocalAssignmentGroup>> EnsureAllAssignmentGroupsExistInCanvas(
+    this LocalCourse localCourse,
+    ulong courseCanvasId,
+    IEnumerable<CanvasAssignmentGroup> canvasAssignmentGroups,
+    CanvasService canvas
+  )
+  {
+    var canvasAssignmentGroupIds = canvasAssignmentGroups.Select(g => g.Id).ToArray();
+    var assignmentGroups = await Task.WhenAll((Task<LocalAssignmentGroup>[])localCourse.AssignmentGroups.Select(
+      async assignmentGroup =>
+      {
+        var canvasGroupWithSameName = canvasAssignmentGroups.FirstOrDefault(
+          cg => cg.Name.Equals(assignmentGroup.Name)
+        );
+        if (canvasGroupWithSameName == null)
+          return await canvas.AssignmentGroups.Create(courseCanvasId, assignmentGroup);
+
+        var correctGroup = assignmentGroup with { CanvasId = canvasGroupWithSameName.Id };
+
+        var needsUpdate = canvasGroupWithSameName.GroupWeight != correctGroup.Weight;
+
+        if (needsUpdate)
+          await canvas.AssignmentGroups.Update(courseCanvasId, assignmentGroup);
+
+        return correctGroup;
+      }
+    ).ToArray());
+
+    return assignmentGroups;
+  }
+}

Management/Models/CanvasModels/Assignments/CanvasAssignmentGroup.cs

@@ -0,0 +1,29 @@
+
+namespace CanvasModel.Assignments;
+
+public record CanvasAssignmentGroup
+{
+  [JsonPropertyName("id")]
+  public ulong Id { get; init; }
+
+  [JsonPropertyName("name")]
+  public required string Name { get; init; }
+
+  [JsonPropertyName("position")]
+  public int Position { get; init; }
+
+  [JsonPropertyName("group_weight")]
+  public double GroupWeight { get; init; }
+
+  // [JsonPropertyName("sis_source_id")]
+  // public string? SisSourceId { get; init; } = null;
+
+  // [JsonPropertyName("integration_data")]
+  // public Dictionary<string, string> IntegrationData { get; init; } = new Dictionary<string, string>();
+
+  // [JsonPropertyName("assignments")]
+  // public List<CanvasAssignment> Assignments { get; init; }
+
+  // [JsonPropertyName("rules")]
+  // public object Rules { get; init; } // The specific type for 'Rules' is not detailed in the spec, so using object for now.
+}

Management/Models/Local/LocalAssignmentGroup.cs

@@ -0,0 +1,9 @@
+namespace LocalModels;
+
+public record LocalAssignmentGroup
+{
+  public ulong? CanvasId { get; init; }
+  public string Id { get; init; } = string.Empty;
+  public required string Name { get; init; }
+  public double Weight { get; init; }
+}

Management/Models/Local/LocalCourse.cs

@@ -11,6 +11,8 @@ public record LocalCourse
   public SimpleTimeOnly DefaultDueTime { get; init; } = new SimpleTimeOnly();
   public IEnumerable<AssignmentTemplate> AssignmentTemplates { get; init; } =
     Enumerable.Empty<AssignmentTemplate>();
+  public IEnumerable<LocalAssignmentGroup> AssignmentGroups { get; init; } = 
+    Enumerable.Empty<LocalAssignmentGroup>();
 }
 
 public record SimpleTimeOnly

Management/Services/Canvas/CanvasAssignmentGroupService.cs

@@ -0,0 +1,70 @@
+using CanvasModel.Assignments;
+using LocalModels;
+using RestSharp;
+
+namespace Management.Services.Canvas;
+
+public class CanvasAssignmentGroupService
+{
+  private readonly IWebRequestor webRequestor;
+  private readonly CanvasServiceUtils utils;
+
+  public CanvasAssignmentGroupService(IWebRequestor webRequestor, CanvasServiceUtils utils)
+  {
+    this.webRequestor = webRequestor;
+    this.utils = utils;
+  }
+  public async Task<IEnumerable<CanvasAssignmentGroup>> GetAll(ulong courseId)
+  {
+    var url = $"courses/{courseId}/assignment_groups";
+    var request = new RestRequest(url);
+    var assignmentResponse = await utils.PaginatedRequest<IEnumerable<CanvasAssignmentGroup>>(request);
+    return assignmentResponse.SelectMany(
+      assignments => assignments
+    );
+  }
+
+  public async Task<LocalAssignmentGroup> Create(
+    ulong canvasCourseId,
+    LocalAssignmentGroup localAssignmentGroup
+  )
+  {
+    Console.WriteLine($"creating assignment group: {localAssignmentGroup.Name}");
+    var url = $"courses/{canvasCourseId}/assignment_groups";
+    var request = new RestRequest(url);
+    var body = new
+    {
+      name = localAssignmentGroup.Name,
+      group_weight = localAssignmentGroup.Weight,
+    };
+    request.AddBody(body);
+
+    var (canvasAssignmentGroup, response) = await webRequestor.PostAsync<CanvasAssignmentGroup>(request);
+    if (canvasAssignmentGroup == null)
+      throw new Exception("created canvas assignment group was null");
+
+    return localAssignmentGroup with
+    {
+      CanvasId = canvasAssignmentGroup.Id
+    };
+  }
+  public async Task Update(
+    ulong canvasCourseId,
+    LocalAssignmentGroup localAssignmentGroup
+  )
+  {
+    Console.WriteLine($"updating assignment group: {localAssignmentGroup.Name}");
+    if (localAssignmentGroup.CanvasId == null)
+      throw new Exception("cannot update assignment group if canvas id is null");
+    var url = $"courses/{canvasCourseId}/assignment_groups/{localAssignmentGroup.CanvasId}";
+    var request = new RestRequest(url);
+    var body = new
+    {
+      name = localAssignmentGroup.Name,
+      group_weight = localAssignmentGroup.Weight,
+    };
+    request.AddBody(body);
+
+    await webRequestor.PutAsync<CanvasAssignmentGroup>(request);
+  }
+}

Management/Services/Canvas/CanvasService.cs

@@ -13,18 +13,21 @@ public class CanvasService
   private readonly CanvasServiceUtils utils;
 
   public CanvasAssignmentService Assignments { get; }
+  public CanvasAssignmentGroupService AssignmentGroups { get; }
   public CanvasQuizService Quizzes { get; }
 
   public CanvasService(
     IWebRequestor webRequestor,
     CanvasServiceUtils utils,
     CanvasAssignmentService Assignments,
+    CanvasAssignmentGroupService AssignmentGroups,
     CanvasQuizService Quizzes
   )
   {
     this.webRequestor = webRequestor;
     this.utils = utils;
     this.Assignments = Assignments;
+    this.AssignmentGroups = AssignmentGroups;
     this.Quizzes = Quizzes;
   }