alex/canvasManagement
1
0
Fork 0
mirror of https://github.com/alexmickelson/canvasManagement.git synced 2026-03-26 07:38:33 -06:00
Code Issues Packages Projects Releases Wiki Activity

renaming modules doesnt duplicate files anymore

Browse Source
This commit is contained in:
Alex Mickelson
2023-11-28 10:25:22 -07:00
parent dd4ec9a761
commit c08e9b478b
9 changed files with 78 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Management/Features/Configuration/AssignmentEditorContext.cs
View File

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

77
Management/Features/Configuration/CoursePlanner.cs
View File

@@ -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);
}
}

19
Management/Features/Configuration/Synchronization/AssignmentSyncronizationExtensions.cs
View File

@@ -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();

110
Management/Features/Configuration/Synchronization/ModuleSyncronizationExtensions.cs
View File

@@ -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
{
await canvas.Modules.UpdateModule(canvasCourseId, canvasModule.Id, module.Name, canvasModule.Position);
}
});
await Task.WhenAll(moduleTasks);
}
// internal static async Task SortCanvasModulesByLocalOrder(
// this LocalCourse localCourse,
// 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)))
// {
internal static async Task SortCanvasModulesByLocalOrder(
this LocalCourse localCourse,
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 canvasModule = canvasModules.FirstOrDefault(c => c.Name == localModule.Name) ?? throw new Exception($"error sorting canvas module, could not find canvas module with name {localModule.Name}"); ;
uint correctPosition = (uint)(i + 1);
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}"); ;
var currentCanvasPosition = currentCanvasPositions[canvasModule.Id];
if (currentCanvasPosition != correctPosition)
{
await canvas.Modules.UpdateModule(canvasId, canvasModule.Id, localModule.Name, correctPosition);
}
}
}
// var currentCanvasPosition = currentCanvasPositions[canvasModule.Id];
// 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);
}
}

13
Management/Services/FileStorageManager.cs
View File

@@ -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)