only actors can save me

Management/Features/Configuration/CoursePlanner.cs

@@ -39,6 +39,7 @@ public class CoursePlanner
   private int _debounceInterval = 1000;
   private LocalCourse? _localCourse { get; set; }
   private LocalCourse? _lastSavedCourse { get; set; }
+  private string loadedCourseName = "";
   public LocalCourse? LocalCourse
   {
     get => _localCourse;
@@ -48,10 +49,13 @@ public class CoursePlanner
       {
         _localCourse = null;
         StateHasChanged?.Invoke();
+
+        loadedCourseName = "";
         return;
       }
 
       var verifiedCourse = value.GeneralCourseCleanup();
+      loadedCourseName = verifiedCourse.Settings.Name;
 
       if (_localCourse == null)
       {
@@ -61,46 +65,54 @@ public class CoursePlanner
         return;
       }
 
-      _debounceTimer?.Dispose();
-      _debounceTimer = new Timer(
-        async (_) => await saveCourseToFile(verifiedCourse),
-        null,
-        _debounceInterval,
-        Timeout.Infinite
-      );
+      saveCourseToFile(verifiedCourse);
 
       _localCourse = verifiedCourse;
       StateHasChanged?.Invoke();
     }
   }
 
-  private async Task saveCourseToFile(LocalCourse courseAsOfDebounce)
+  public async Task LoadCourseByName(string courseName)
+  {
+
+  }
+
+  private void saveCourseToFile(LocalCourse courseAsOfDebounce)
   {
     _debounceTimer?.Dispose();
+    _debounceTimer = new Timer(
+        async (_) =>
+        {
+          _debounceTimer?.Dispose();
 
-    // ignore initial load of course
-    if (LocalCourse == null)
-    {
-      logger.Trace("saving course as of debounce call time");
-      await fileStorageManager.SaveCourseAsync(courseAsOfDebounce, null);
-      _lastSavedCourse = courseAsOfDebounce;
-    }
-    else
-    {
-      if (_lastSavedCourse == null)
-      {
-        logger.Trace("not saving course, no prevous saved course");
-        _lastSavedCourse = LocalCourse ?? courseAsOfDebounce;
-        return;
-      }
+          // ignore initial load of course
+          if (LocalCourse == null)
+          {
+            logger.Trace("saving course as of debounce call time");
+            await fileStorageManager.SaveCourseAsync(courseAsOfDebounce, null);
+            _lastSavedCourse = courseAsOfDebounce;
+          }
+          else
+          {
+            if (_lastSavedCourse == null)
+            {
+              logger.Trace("not saving course, no prevous saved course");
+              _lastSavedCourse = LocalCourse ?? courseAsOfDebounce;
+              return;
+            }
 
 
-      logger.Trace("Saving latest version of file");
-      var courseToSave = LocalCourse;
-      await fileStorageManager.SaveCourseAsync(courseToSave, _lastSavedCourse);
-      _lastSavedCourse = courseToSave;
+            logger.Trace("Saving latest version of file");
+            var courseToSave = LocalCourse;
+            await fileStorageManager.SaveCourseAsync(courseToSave, _lastSavedCourse);
+            _lastSavedCourse = courseToSave;
 
-    }
+          }
+        },
+        null,
+        _debounceInterval,
+        Timeout.Infinite
+      );
   }
 
   public event Action? StateHasChanged;

Management/Services/Files/FileStorageManager.cs

@@ -1,14 +1,6 @@
 using LocalModels;
 using Management.Services;
 
-public interface IFileStorageManager
-{
-  Task SaveCourseAsync(LocalCourse course, LocalCourse? previouslyStoredCourse);
-  Task<IEnumerable<LocalCourse>> LoadSavedCourses();
-  Task<IEnumerable<LocalCourse>> LoadSavedMarkdownCourses();
-  IEnumerable<string> GetEmptyDirectories();
-}
-
 public class FileStorageManager : IFileStorageManager
 {
   private readonly MyLogger<FileStorageManager> logger;
@@ -44,13 +36,7 @@ public class FileStorageManager : IFileStorageManager
 
   public async Task<IEnumerable<LocalCourse>> LoadSavedCourses()
   {
-    return await LoadSavedMarkdownCourses();
-  }
-
-  public async Task<IEnumerable<LocalCourse>> LoadSavedMarkdownCourses()
-  {
-
-    return await _courseMarkdownLoader.LoadSavedMarkdownCourses();
+    return await _courseMarkdownLoader.LoadSavedCourses();
   }
 
   public IEnumerable<string> GetEmptyDirectories()

Management/Services/Files/FileStorageManagerCached.cs

@@ -0,0 +1,50 @@
+
+using System.Diagnostics.CodeAnalysis;
+using LocalModels;
+
+public class FileStorageManagerCached : IFileStorageManager
+{
+  private readonly FileStorageManager manager;
+
+  private readonly object cacheLock = new object();  // Lock object for synchronization
+
+
+  private DateTime? cacheTime { get; set; } = null;
+  private IEnumerable<LocalCourse>? cachedCourses { get; set; } = null;
+  private ILogger<FileStorageManagerCached> logger { get; }
+
+  private readonly int cacheSeconds = 2;
+  public FileStorageManagerCached(FileStorageManager manager, ILogger<FileStorageManagerCached> logger)
+  {
+    this.manager = manager;
+    this.logger = logger;
+  }
+  public IEnumerable<string> GetEmptyDirectories()
+  {
+    return manager.GetEmptyDirectories();
+  }
+
+  public async Task<IEnumerable<LocalCourse>> LoadSavedCourses()
+  {
+
+    var secondsFromLastLoad = (DateTime.Now - cacheTime)?.Seconds;
+
+    if (cachedCourses != null && secondsFromLastLoad < cacheSeconds)
+    {
+      logger.LogInformation("returning cached courses from file");
+      return cachedCourses;
+    }
+
+    cachedCourses = await manager.LoadSavedCourses();
+    cacheTime = DateTime.Now;
+    return cachedCourses;
+  }
+
+  public async Task SaveCourseAsync(LocalCourse course, LocalCourse? previouslyStoredCourse)
+  {
+    // race condition...
+    cacheTime = null;
+    cachedCourses = null;
+    await manager.SaveCourseAsync(course, previouslyStoredCourse);
+  }
+}

Management/Services/Files/IFileStorageManager.cs

@@ -0,0 +1,8 @@
+using LocalModels;
+
+public interface IFileStorageManager
+{
+  Task SaveCourseAsync(LocalCourse course, LocalCourse? previouslyStoredCourse);
+  Task<IEnumerable<LocalCourse>> LoadSavedCourses();
+  IEnumerable<string> GetEmptyDirectories();
+}

Management/Services/Files/LoadMarkdownCourse.cs

@@ -12,7 +12,7 @@ public class CourseMarkdownLoader
     _basePath = fileConfig.GetBasePath();
   }
 
-  public async Task<IEnumerable<LocalCourse>> LoadSavedMarkdownCourses()
+  public async Task<IEnumerable<LocalCourse>> LoadSavedCourses()
   {
     var courseDirectories = Directory.GetDirectories(_basePath);