before I dive too much more into adding pages in canvas

Management/Features/Configuration/CoursePlanner.cs

@@ -8,6 +8,7 @@ using Management.Services.Canvas;
 using System.Text.RegularExpressions;
 using CanvasModel.Quizzes;
 using Management.Services;
+using CanvasModel.Pages;
 
 namespace Management.Planner;
 
@@ -109,6 +110,7 @@ public class CoursePlanner
   public IEnumerable<CanvasAssignmentGroup>? CanvasAssignmentGroups { get; internal set; }
   public IEnumerable<CanvasQuiz>? CanvasQuizzes { get; internal set; }
   public IEnumerable<CanvasModule>? CanvasModules { get; internal set; }
+  public IEnumerable<CanvasPage>? CanvasPages { get; internal set; }
   public Dictionary<CanvasModule, IEnumerable<CanvasModuleItem>>? CanvasModulesItems { get; internal set; }
 
   public async Task<(
@@ -131,6 +133,7 @@ public class CoursePlanner
     var quizzesTask = canvas.Quizzes.GetAll(canvasId);
     var modulesTask = canvas.Modules.GetModules(canvasId);
     var assignmentGroupsTask = canvas.AssignmentGroups.GetAll(canvasId);
+    var coursePagesTask = canvas.Pages.GetAll(canvasId);
 
     CanvasAssignments = await assignmentsTask;
     CanvasQuizzes = await quizzesTask;

Management/Features/Configuration/PageEditorContext.cs

@@ -82,13 +82,13 @@ public class PageEditorContext(
 
   public async Task AddPageToCanvas()
   {
-    // logger.Log("started to add quiz to canvas");
-    // if (Quiz == null)
-    // {
-    //   logger.Log("cannot add null quiz to canvas");
-    //   return;
-    // }
-    // await planner.LoadCanvasData();
+    logger.Log("started to add page to canvas");
+    if (Page == null)
+    {
+      logger.Log("cannot add null page to canvas");
+      return;
+    }
+    await planner.LoadCanvasData();
     // if (planner.CanvasQuizzes == null)
     // {
     //   logger.Log("cannot add quiz to canvas, failed to retrieve current quizzes");
@@ -128,6 +128,11 @@ public class PageEditorContext(
     // logger.Log($"finished adding quiz {Quiz.Name} to canvas");
   }
 
+  public async Task UpdateInCanvas(string pageId)
+  {
+
+  }
+
 
 
   private static LocalModule getCurrentLocalModule(LocalCoursePage page, LocalCourse course)

Management/Models/CanvasModels/Pages/CanvasPage.cs

@@ -1,6 +1,6 @@
 
 namespace CanvasModel.Pages;
-public record PageModel (
+public record CanvasPage (
   [property: JsonPropertyName("page_id")] string PageId,
   [property: JsonPropertyName("url")] string Url,
   [property: JsonPropertyName("title")] string Title,

Management/Models/Local/Assignment/LocalAssignment.cs

@@ -20,7 +20,6 @@ public record LocalAssignment: IModuleItem
     }
   }
   public string Description { get; init; } = "";
-  // public bool LockAtDueDate { get; init; }
   public DateTime? LockAt { get; init; }
   public DateTime DueAt { get; init; }
   public string? LocalAssignmentGroupName { get; init; }

Management/Models/Local/LocalCoursePage.cs

@@ -5,6 +5,7 @@ public record LocalCoursePage: IModuleItem
   public required string Name { get; init; }
   public required string Text { get; set; }
   public DateTime DueAt { get; init; }
+  public string GetBodyHtml() => Markdig.Markdown.ToHtml(Text);
 
   public string ToMarkdown()
   {
@@ -34,6 +35,7 @@ public record LocalCoursePage: IModuleItem
       Text = text
     };
   }
+
 }
 
 

Management/Models/Local/LocalModules.cs

@@ -7,4 +7,11 @@ public record LocalModule
   public IEnumerable<LocalAssignment> Assignments { get; init; } = [];
   public IEnumerable<LocalQuiz> Quizzes { get; init; } = [];
   public IEnumerable<LocalCoursePage> Pages { get; init; } = [];
+
+  public IEnumerable<IModuleItem> SortedModuleItems =>
+    Enumerable.Empty<IModuleItem>()
+      .Concat(Assignments)
+      .Concat(Quizzes)
+      .Concat(Pages)
+      .OrderBy(i => i.DueAt);
 }

Management/Services/Canvas/CanvasAssignmentService.cs

@@ -4,22 +4,15 @@ using RestSharp;
 
 namespace Management.Services.Canvas;
 
-public class CanvasAssignmentService
-{
-  private readonly IWebRequestor webRequestor;
-  private readonly CanvasServiceUtils utils;
-  private readonly MyLogger<CanvasAssignmentService> log;
-
-  public CanvasAssignmentService(
-    IWebRequestor webRequestor,
-    CanvasServiceUtils utils,
-    MyLogger<CanvasAssignmentService> logger
+public class CanvasAssignmentService(
+  IWebRequestor webRequestor,
+  CanvasServiceUtils utils,
+  MyLogger<CanvasAssignmentService> logger
   )
-  {
-    this.webRequestor = webRequestor;
-    this.utils = utils;
-    this.log = logger;
-  }
+{
+  private readonly IWebRequestor webRequestor = webRequestor;
+  private readonly CanvasServiceUtils utils = utils;
+  private readonly MyLogger<CanvasAssignmentService> log = logger;
 
   public async Task<IEnumerable<CanvasAssignment>> GetAll(ulong courseId)
   {
@@ -86,10 +79,10 @@ public class CanvasAssignmentService
       points_possible = localAssignment.PointsPossible,
       assignment_group_id = canvasAssignmentGroupId,
     };
-    
+
     var bodyObj = new { assignment = body };
     request.AddBody(bodyObj);
-    
+
     await webRequestor.PutAsync(request);
 
     await CreateRubric(courseId, canvasAssignmentId, localAssignment);

Management/Services/Canvas/CanvasCoursePageService.cs

@@ -0,0 +1,87 @@
+
+using CanvasModel.Courses;
+using CanvasModel.Modules;
+using CanvasModel.Pages;
+using LocalModels;
+using RestSharp;
+
+namespace Management.Services.Canvas;
+public class CanvasCoursePageService(
+  IWebRequestor webRequestor,
+  CanvasServiceUtils utils,
+  MyLogger<CanvasCoursePageService> logger
+  )
+{
+  private readonly IWebRequestor webRequestor = webRequestor;
+  private readonly CanvasServiceUtils utils = utils;
+  private readonly MyLogger<CanvasCoursePageService> log = logger;
+
+
+
+  public async Task<IEnumerable<CanvasPage>> GetAll(ulong courseId)
+  {
+    var url = $"courses/{courseId}/pages";
+    var request = new RestRequest(url);
+    // request.AddParameter("include[]", "overrides");
+    var pagesResponse = await utils.PaginatedRequest<IEnumerable<CanvasPage>>(request);
+    return pagesResponse.SelectMany(
+      pages => pages
+    );
+  }
+
+
+  public async Task<string> Create(
+    ulong canvasCourseId,
+    LocalCoursePage localCourse
+  )
+  {
+    log.Log($"creating course page: {localCourse.Name}");
+    var url = $"courses/{canvasCourseId}/pages";
+    var request = new RestRequest(url);
+    var body = new
+    {
+      title = localCourse.Name,
+      body = localCourse.GetBodyHtml()
+    };
+    var bodyObj = new { wiki_page = body };
+    request.AddBody(bodyObj);
+    var (canvasPage, response) = await webRequestor.PostAsync<CanvasPage>(request);
+    if (canvasPage == null)
+      throw new Exception("created canvas course page was null");
+
+    return canvasPage.PageId;
+  }
+
+  public async Task Update(
+    ulong courseId,
+    string canvasPageId,
+    LocalCoursePage localCourse
+  )
+  {
+    log.Log($"updating course page: {localCourse.Name}");
+    var url = $"courses/{courseId}/pages/{canvasPageId}";
+    var request = new RestRequest(url);
+    var body = new
+    {
+      title = localCourse.Name,
+      body = localCourse.GetBodyHtml()
+    };
+    var bodyObj = new { wiki_page = body };
+    request.AddBody(bodyObj);
+
+    await webRequestor.PutAsync(request);
+  }
+
+  public async Task Delete(ulong courseId, string canvasPageId)
+  {
+    log.Log($"deleting page from canvas {canvasPageId}");
+    var url = $"courses/{courseId}/pages/{canvasPageId}";
+    var request = new RestRequest(url);
+    var response = await webRequestor.DeleteAsync(request);
+    if (!response.IsSuccessful)
+    {
+      log.Log(url);
+      throw new Exception("Failed to delete canvas course page");
+    }
+  }
+}

Management/Services/Canvas/CanvasService.cs

@@ -8,35 +8,26 @@ using RestSharp;
 
 namespace Management.Services.Canvas;
 
-public class CanvasService
-{
-  private readonly IWebRequestor webRequestor;
-  private readonly CanvasServiceUtils utils;
-  private readonly MyLogger<CanvasService> logger;
-
-  public CanvasAssignmentService Assignments { get; }
-  public CanvasAssignmentGroupService AssignmentGroups { get; }
-  public CanvasModuleService Modules { get; }
-  public CanvasQuizService Quizzes { get; }
-
-  public CanvasService(
-    IWebRequestor webRequestor,
-    CanvasServiceUtils utils,
-    CanvasAssignmentService Assignments,
-    CanvasAssignmentGroupService AssignmentGroups,
-    CanvasModuleService Modules,
-    CanvasQuizService Quizzes,
-    MyLogger<CanvasService> logger
+public class CanvasService(
+  IWebRequestor webRequestor,
+  CanvasServiceUtils utils,
+  CanvasAssignmentService Assignments,
+  CanvasAssignmentGroupService AssignmentGroups,
+  CanvasModuleService Modules,
+  CanvasQuizService Quizzes,
+  CanvasCoursePageService Pages,
+  MyLogger<CanvasService> logger
   )
-  {
-    this.webRequestor = webRequestor;
-    this.utils = utils;
-    this.Assignments = Assignments;
-    this.AssignmentGroups = AssignmentGroups;
-    this.Modules = Modules;
-    this.Quizzes = Quizzes;
-    this.logger = logger;
-  }
+{
+  private readonly IWebRequestor webRequestor = webRequestor;
+  private readonly CanvasServiceUtils utils = utils;
+  private readonly MyLogger<CanvasService> logger = logger;
+
+  public CanvasAssignmentService Assignments { get; } = Assignments;
+  public CanvasAssignmentGroupService AssignmentGroups { get; } = AssignmentGroups;
+  public CanvasModuleService Modules { get; } = Modules;
+  public CanvasQuizService Quizzes { get; } = Quizzes;
+  public CanvasCoursePageService Pages { get; } = Pages;
 
   public async Task<IEnumerable<EnrollmentTermModel>> GetTerms()
   {

Management/Services/Files/FileStorageManager.cs

@@ -1,7 +1,6 @@
 using System.Diagnostics;
 using LocalModels;
 using Management.Services;
-using YamlDotNet.Serialization;
 
 public class FileStorageManager
 {

Management/Services/Files/LoadMarkdownCourse.cs

@@ -131,7 +131,7 @@ public class CourseMarkdownLoader
   }
   private async Task<IEnumerable<LocalCoursePage>> loadPagesFromPath(string modulePath)
   {
-    using var activity = DiagnosticsConfig.Source?.StartActivity("loading Pages from file");
+    using var activity = DiagnosticsConfig.Source?.StartActivity("loading Pages from path");
     var pagesPath = $"{modulePath}/pages";
     if (!Directory.Exists(pagesPath))
     {