renaming modules doesnt duplicate files anymore

Management.Web/Shared/Components/Quiz/DroppableQuiz.razor.cs

@@ -1,3 +1,4 @@
+using System.Runtime.CompilerServices;
 using Microsoft.AspNetCore.Components;
 
 namespace Management.Web.Shared.Components.Quiz;
@@ -41,7 +42,14 @@ public class DroppableQuiz : ComponentBase
     );
 
     var NewQuizList = currentModule.Quizzes
-      .Select(q => q.Name + q.Description != Quiz.Name + Quiz.Description ? q : q with { DueAt = defaultDueTimeDate })
+      .Select(q => 
+        q.Name + q.Description != Quiz.Name + Quiz.Description 
+          ? q : 
+          q with { 
+            DueAt = defaultDueTimeDate,
+            LockAt = q.LockAt > defaultDueTimeDate ? q.LockAt : defaultDueTimeDate
+          }
+      )
       .ToArray();
 
     var updatedModule = currentModule with { Quizzes = NewQuizList };

Management.Web/Shared/Course/AssignmentGroups.razor

@@ -17,6 +17,7 @@
     planner.StateHasChanged -= reload;
   }
 
+  private bool syncingAssignmentGroups { get; set; } = false;
   private void AddAssignmentGroup()
   {
     if(planner.LocalCourse != null)
@@ -83,6 +84,13 @@
       }
     };  
   }
+
+  private async Task SyncAssignmentGroupsWithCanvas()
+  {
+    syncingAssignmentGroups = true;
+    await planner.SyncAssignmentGroups();
+    syncingAssignmentGroups = false;
+  }
 }
 
 @if(planner.LocalCourse != null)
@@ -119,4 +127,16 @@
       + Assignment Group
     </button>
   </div>
+
+  <button 
+    class="btn btn-outline-secondary"
+    @onclick="SyncAssignmentGroupsWithCanvas"
+    disabled="@syncingAssignmentGroups"
+  >
+    Sync Assignment Groups With Canvas
+  </button>
+  @if(syncingAssignmentGroups)
+  {
+    <Spinner />
+  }
 }

Management.Web/Shared/Course/CourseSettings.razor

@@ -56,6 +56,7 @@
       }
     }
   }
+
 }
 
 <button 

Management.Web/Shared/Module/ModuleDetail.razor

@@ -141,11 +141,11 @@
             if(!isSyncedWithCanvas)
             {
               <button 
-                class="btn btn-outline-primarycanvasCourseId"
+                class="btn btn-outline-primary"
                 @onclick="Publish" 
                 disabled="@publishing"
               >
-                Publish
+                Add to Canvas
               </button>
             }
           }

Management/Features/Configuration/AssignmentEditorContext.cs

@@ -153,6 +153,7 @@ public class AssignmentEditorContext
       (ulong)courseCanvasId,
       canvasModule.Id,
       Assignment.Name,
+      
       "Assignment",
       createdAssignmentCanvasId
     );

Management/Features/Configuration/CoursePlanner.cs

@@ -109,69 +109,6 @@ public class CoursePlanner
     return (CanvasAssignments, CanvasModules, CanvasModulesItems, CanvasQuizzes, CanvasAssignmentGroups);
   }
 
-  public async Task SyncWithCanvas()
-  {
-    if (
-      LocalCourse == null
-      || LocalCourse.Settings.CanvasId == null
-      || CanvasAssignments == null
-      || CanvasModules == null
-      || CanvasQuizzes == null
-    )
-      return;
-
-    Console.WriteLine("syncing with canvas");
-    LoadingCanvasData = true;
-    StateHasChanged?.Invoke();
-
-    var (
-      canvasAssignments,
-      canvasModules,
-      canvasModuleItems,
-      canvasQuizzes,
-      canvasAssignmentGroups
-    ) = await LoadCanvasData();
-
-    LoadingCanvasData = true;
-    StateHasChanged?.Invoke();
-
-    var canvasId =
-      LocalCourse.Settings.CanvasId ?? throw new Exception("no course canvas id to sync with canvas");
-
-    var newAssignmentGroups = await LocalCourse.EnsureAllAssignmentGroupsExistInCanvas(
-      canvasId, canvasAssignmentGroups, canvas);
-    LocalCourse = LocalCourse with
-    {
-      Settings = LocalCourse.Settings with
-      {
-        AssignmentGroups = newAssignmentGroups
-      }
-    };
-
-
-    await LocalCourse.CreateAllModules(
-      canvasId,
-      CanvasModules,
-      canvas
-    );
-    CanvasModules = await canvas.Modules.GetModules(canvasId);
-
-    await LocalCourse.SortCanvasModulesByLocalOrder(canvasId, CanvasModules, canvas);
-    CanvasModulesItems = await canvas.Modules.GetAllModulesItems(canvasId, CanvasModules);
-
-    LocalCourse = await LocalCourse.SyncAssignmentsWithCanvas(canvasId, CanvasAssignments, canvas);
-    CanvasAssignments = await canvas.Assignments.GetAll(canvasId);
-
-    CanvasModulesItems = await canvas.Modules.GetAllModulesItems(canvasId, CanvasModules);
-
-    await LocalCourse.SyncModuleItemsWithCanvas(canvasId, CanvasModulesItems, canvas, CanvasAssignments);
-    CanvasModulesItems = await canvas.Modules.GetAllModulesItems(canvasId, CanvasModules);
-
-    LoadingCanvasData = false;
-    StateHasChanged?.Invoke();
-    Console.WriteLine("done syncing with canvas\n");
-  }
-
   public async Task CreateModule(LocalModule newModule)
   {
     if(LocalCourse == null)
@@ -188,4 +125,18 @@ public class CoursePlanner
     CanvasAssignments = null;
     CanvasModules = null;
   }
+
+  public async Task SyncAssignmentGroups()
+  {
+    if(LocalCourse == null)
+      return;
+
+    var canvasCourseId =
+      LocalCourse.Settings.CanvasId ?? throw new Exception("no course canvas id to use to create module");
+    
+    
+    CanvasAssignmentGroups = await canvas.AssignmentGroups.GetAll(canvasCourseId);
+
+    await LocalCourse.EnsureAllAssignmentGroupsExistInCanvas(canvasCourseId, CanvasAssignmentGroups, canvas);
+  }
 }

Management/Features/Configuration/Synchronization/AssignmentSyncronizationExtensions.cs

@@ -236,25 +236,6 @@ public static partial class AssignmentSyncronizationExtensions
       || !assignmentGroupSame;
   }
 
-  internal static async Task<LocalCourse> SyncAssignmentsWithCanvas(
-    this LocalCourse localCourse,
-    ulong canvasCourseId,
-    IEnumerable<CanvasAssignment> canvasAssignments,
-    CanvasService canvas
-  )
-  {
-    var moduleTasks = localCourse.Modules.Select(async m =>
-    {
-      var assignmentTasks = m.Assignments.Select(
-        async (a) => await localCourse.SyncAssignmentToCanvas(canvasCourseId, a, canvasAssignments, canvas)
-      );
-      await Task.WhenAll(assignmentTasks);
-      return m;
-    });
-
-    var modules = await Task.WhenAll(moduleTasks);
-    return localCourse with { Modules = modules };
-  }
 
   [GeneratedRegex("<script.*script>")]
   private static partial Regex CanvasScriptTagRegex();

Management/Features/Configuration/Synchronization/ModuleSyncronizationExtensions.cs

@@ -7,50 +7,28 @@ namespace Management.Planner;
 
 public static partial class ModuleSyncronizationExtensions
 {
-  internal static async Task CreateAllModules(
-    this LocalCourse localCourse,
-    ulong canvasCourseId,
-    IEnumerable<CanvasModule> canvasModules,
-    CanvasService canvas
-  )
-  {
-    var moduleTasks = localCourse.Modules.Select(async module =>
-    {
-      var canvasModule = canvasModules.FirstOrDefault(cm => cm.Name == module.Name);
-      if (canvasModule == null)
-      {
-        var newModule = await canvas.Modules.CreateModule(canvasCourseId, module.Name);
-      }
 
-      if (canvasModule?.Name != module.Name) // TODO: maybe check to see if we have name change here
+  // internal static async Task SortCanvasModulesByLocalOrder(
-      {
+  //   this LocalCourse localCourse,
-        await canvas.Modules.UpdateModule(canvasCourseId, canvasModule.Id, module.Name, canvasModule.Position);
+  //   ulong canvasId,
-      }
+  //   IEnumerable<CanvasModule> canvasModules,
-    });
+  //   CanvasService canvas
-    await Task.WhenAll(moduleTasks);
+  // )
-  }
+  // {
+  //   var currentCanvasPositions = canvasModules.ToDictionary(m => m.Id, m => m.Position);
+  //   foreach (var (localModule, i) in localCourse.Modules.Select((m, i) => (m, i)))
+  //   {
 
-  internal static async Task SortCanvasModulesByLocalOrder(
+  //     uint correctPosition = (uint)(i + 1);
-    this LocalCourse localCourse,
+  //     var canvasModule = canvasModules.FirstOrDefault(c => c.Name == localModule.Name) ?? throw new Exception($"error sorting canvas module, could not find canvas module with name {localModule.Name}"); ;
-    ulong canvasId,
-    IEnumerable<CanvasModule> canvasModules,
-    CanvasService canvas
-  )
-  {
-    var currentCanvasPositions = canvasModules.ToDictionary(m => m.Id, m => m.Position);
-    foreach (var (localModule, i) in localCourse.Modules.Select((m, i) => (m, i)))
-    {
 
-      uint correctPosition = (uint)(i + 1);
+  //     var currentCanvasPosition = currentCanvasPositions[canvasModule.Id];
-      var canvasModule = canvasModules.FirstOrDefault(c => c.Name == localModule.Name) ?? throw new Exception($"error sorting canvas module, could not find canvas module with name {localModule.Name}"); ;
+  //     if (currentCanvasPosition != correctPosition)
-
+  //     {
-      var currentCanvasPosition = currentCanvasPositions[canvasModule.Id];
+  //       await canvas.Modules.UpdateModule(canvasId, canvasModule.Id, localModule.Name, correctPosition);
-      if (currentCanvasPosition != correctPosition)
+  //     }
-      {
+  //   }
-        await canvas.Modules.UpdateModule(canvasId, canvasModule.Id, localModule.Name, correctPosition);
+  // }
-      }
-    }
-  }
 
   public static async Task SortModuleItems(
     this LocalModule localModule,
@@ -64,19 +42,11 @@ public static partial class ModuleSyncronizationExtensions
     var moduleItemsInCorrectOrder = canvasModuleItems
       .OrderBy(i => i.ContentDetails?.DueAt)
       .Select((a, i) => (Item: a, Position: i + 1));
-    // 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 (moduleItem, position) in moduleItemsInCorrectOrder)
     {
       var itemIsInCorrectOrder = moduleItem.Position == position;
 
-      // var currentCanvasItem = canvasModuleItems.First(i => i.ContentId == moduleItem.CanvasId);
       if (!itemIsInCorrectOrder)
       {
         await canvas.UpdateModuleItem(
@@ -123,46 +93,4 @@ public static partial class ModuleSyncronizationExtensions
     return anyUpdated;
   }
 
-  internal static async Task SyncModuleItemsWithCanvas(
-    this LocalCourse localCourse,
-    ulong courseCanvasId,
-    Dictionary<CanvasModule, IEnumerable<CanvasModuleItem>> canvasModulesItems,
-    CanvasService canvas,
-    IEnumerable<CanvasAssignment> canvasAssignments
-  )
-  {
-    foreach (var localModule in localCourse.Modules)
-    {
-      await localModule.SyncAndSortCanvasModule(courseCanvasId, canvasModulesItems, canvas, canvasAssignments);
-    }
-  }
-
-  public static async Task SyncAndSortCanvasModule(
-    this LocalModule localModule,
-    ulong courseCanvasId,
-    Dictionary<CanvasModule, IEnumerable<CanvasModuleItem>> canvasModulesItems,
-    CanvasService canvas,
-    IEnumerable<CanvasAssignment> canvasAssignments
-  )
-  {
-    var canvasModule = canvasModulesItems.Keys.FirstOrDefault(k => k.Name == localModule.Name);
-    if (canvasModule == null)
-    {
-      throw new Exception($"cannot sync module items in canvas, could not find module with name ${localModule.Name}");
-    }
-
-    bool anyUpdated = await localModule.EnsureAllModulesItemsCreated(
-      courseCanvasId,
-      canvasModule,
-      canvasModulesItems,
-      canvas,
-      canvasAssignments
-    );
-
-    var canvasModuleItems = anyUpdated
-      ? await canvas.Modules.GetModuleItems(courseCanvasId, canvasModule.Id)
-      : canvasModulesItems[canvasModule];
-
-    await localModule.SortModuleItems(courseCanvasId, canvasModule.Id, canvas);
-  }
 }

Management/Services/FileStorageManager.cs

@@ -1,7 +1,6 @@
 using LocalModels;
 using Management.Services;
 using YamlDotNet.Serialization;
-using YamlDotNet.Serialization.NamingConventions;
 
 public class FileStorageManager
 {
@@ -59,6 +58,18 @@ public class FileStorageManager
       await saveAssignments(course, module);
     }
 
+    var moduleNames = course.Modules.Select(m => m.Name);
+    foreach (var moduleDirectoryPath in Directory.EnumerateDirectories(courseDirectory))
+    {
+      var directoryName = Path.GetFileName(moduleDirectoryPath);
+      if (!moduleNames.Contains(directoryName))
+      {
+        Console.WriteLine($"deleting extra module directory, it was probably renamed {moduleDirectoryPath}");
+        Directory.Delete(moduleDirectoryPath, true);
+
+      }
+    }
+
   }
 
   private static async Task saveSettings(LocalCourse course, string courseDirectory)