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

testing markdown storage and retrieval

Browse Source
This commit is contained in:
Alex Mickelson
2023-12-04 12:27:06 -07:00
parent 69f0b322b2
commit c6ce528ba1
23 changed files with 467 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
Management/Services/Files/FileConfiguration.cs Normal file
View File

@@ -0,0 +1,17 @@
using Management.Services;
public class FileConfiguration
{
public static string GetBasePath()
{
string? storageDirectory = Environment.GetEnvironmentVariable("storageDirectory");
var basePath = storageDirectory ?? Path.GetFullPath("../storage");
if (!Directory.Exists(basePath))
throw new Exception("storage folder not found");
return basePath;
}
}

84
Management/Services/FileStorageManager.cs → Management/Services/Files/FileStorageManager.cs
View File

@@ -5,14 +5,22 @@ using YamlDotNet.Serialization;
public class FileStorageManager
{
private readonly MyLogger<FileStorageManager> logger;
private static readonly string _basePath = "../storage";
private readonly CourseMarkdownLoader _courseMarkdownLoader;
private readonly string _basePath;
public FileStorageManager(MyLogger<FileStorageManager> logger)
public FileStorageManager(
MyLogger<FileStorageManager> logger,
CourseMarkdownLoader courseMarkdownLoader
)
{
if (!Directory.Exists(_basePath))
throw new Exception("storage folder not found");
this.logger = logger;
_courseMarkdownLoader = courseMarkdownLoader;
_basePath = FileConfiguration.GetBasePath();
logger.Log("Using storage directory: " + _basePath);
}
public string CourseToYaml(LocalCourse course)
{
var serializer = new SerializerBuilder().DisableAliases().Build();
@@ -131,6 +139,7 @@ public class FileStorageManager
}
removeOldAssignments(assignmentsDirectory, module);
}
private void removeOldAssignments(string path, LocalModule module)
{
var existingFiles = Directory.EnumerateFiles(path);
@@ -166,68 +175,9 @@ public class FileStorageManager
return courses;
}
// public async Task<LocalCourse> LoadCourseByName(string courseName)
// {
// var courseDirectory = $"{_basePath}/{courseName}";
// if (!Directory.Exists(courseDirectory))
// {
// var errorMessage = $"error loading course by name, could not find folder {courseDirectory}";
// logger.Log(errorMessage);
// throw new LoadCourseFromFileException(errorMessage);
// }
// var settingsPath = $"{courseDirectory}/settings.yml";
// if (!Directory.Exists(settingsPath))
// {
// var errorMessage = $"error loading course by name, settings file {settingsPath}";
// logger.Log(errorMessage);
// throw new LoadCourseFromFileException(errorMessage);
// }
public async Task<IEnumerable<LocalCourse>> LoadSavedMarkdownCourses()
{
return await _courseMarkdownLoader.LoadSavedMarkdownCourses();
}
// var settingsString = await File.ReadAllTextAsync(settingsPath);
// var settings = LocalCourseSettings.ParseYaml(settingsString);
// var modulePaths = Directory.GetDirectories(courseDirectory);
// var modules = modulePaths
// .Select(LoadModuleFromPath)
// .ToArray();
// }
// public async Task<LocalModule> LoadModuleFromPath(string modulePath)
// {
// var assignmentsPath = $"{modulePath}/assignments";
// if (!Directory.Exists(assignmentsPath))
// {
// var errorMessage = $"error loading course by name, assignments folder does not exist in {modulePath}";
// logger.Log(errorMessage);
// throw new LoadCourseFromFileException(errorMessage);
// }
// var quizzesPath = $"{modulePath}/quizzes";
// if (!Directory.Exists(quizzesPath))
// {
// var errorMessage = $"error loading course by name, quizzes folder does not exist in {modulePath}";
// logger.Log(errorMessage);
// throw new LoadCourseFromFileException(errorMessage);
// }
// var assignments = LoadAssignmentsFromPath(assignmentsPath);
// var quizzes = LoadQuizzesFromPath(quizzesPath);
// }
// public async Task<IEnumerable<LocalAssignment>> LoadAssignmentsFromPath(string assignmentsFolder)
// {
// }
// public async Task<IEnumerable<LocalAssignment>> LoadQuizzesFromPath(string quizzesFolder)
// {
// }
}
public class LoadCourseFromFileException(string message) : Exception(message)
{
}

3
Management/Services/Files/LoadCourseFromFileException.cs Normal file
View File

@@ -0,0 +1,3 @@
public class LoadCourseFromFileException(string message) : Exception(message)
{
}

127
Management/Services/Files/LoadMarkdownCourse.cs Normal file
View File

@@ -0,0 +1,127 @@
using System.Reflection.Metadata.Ecma335;
using LocalModels;
using Management.Services;
using YamlDotNet.Serialization;
public class CourseMarkdownLoader
{
private readonly MyLogger<CourseMarkdownLoader> logger;
private readonly string _basePath;
public CourseMarkdownLoader(MyLogger<CourseMarkdownLoader> logger)
{
this.logger = logger;
_basePath = FileConfiguration.GetBasePath();
}
public async Task<IEnumerable<LocalCourse>> LoadSavedMarkdownCourses()
{
var courseDirectories = Directory.GetDirectories(_basePath);
var courses = await Task.WhenAll(
courseDirectories.Select(async n => await LoadCourseByPath(n))
);
return courses;
}
public async Task<LocalCourse> LoadCourseByPath(string courseDirectory)
{
if (!Directory.Exists(courseDirectory))
{
var errorMessage = $"error loading course by name, could not find folder {courseDirectory}";
logger.Log(errorMessage);
throw new LoadCourseFromFileException(errorMessage);
}
LocalCourseSettings settings = await loadCourseSettings(courseDirectory);
var modules = await loadCourseModules(courseDirectory);
return new()
{
Settings = settings,
Modules = modules
};
}
private async Task<LocalCourseSettings> loadCourseSettings(string courseDirectory)
{
var settingsPath = $"{courseDirectory}/settings.yml";
if (!File.Exists(settingsPath))
{
var errorMessage = $"error loading course by name, settings file {settingsPath}";
logger.Log(errorMessage);
throw new LoadCourseFromFileException(errorMessage);
}
var settingsString = await File.ReadAllTextAsync(settingsPath);
var settings = LocalCourseSettings.ParseYaml(settingsString);
return settings;
}
private async Task<IEnumerable<LocalModule>> loadCourseModules(string courseDirectory)
{
var modulePaths = Directory.GetDirectories(courseDirectory);
var modules = await Task.WhenAll(
modulePaths
.Select(loadModuleFromPath)
);
return modules;
}
private async Task<LocalModule> loadModuleFromPath(string modulePath)
{
var moduleName = Path.GetFileName(modulePath);
var assignments = await loadAssignmentsFromPath(modulePath);
var quizzes = await loadQuizzesFromPath(modulePath);
return new LocalModule()
{
Name = moduleName,
Assignments = assignments,
Quizzes = quizzes,
};
}
private async Task<IEnumerable<LocalAssignment>> loadAssignmentsFromPath(string modulePath)
{
var assignmentsPath = $"{modulePath}/assignments";
if (!Directory.Exists(assignmentsPath))
{
var errorMessage = $"error loading course by name, assignments folder does not exist in {modulePath}";
logger.Log(errorMessage);
throw new LoadCourseFromFileException(errorMessage);
}
var assignmentFiles = Directory.GetFiles(assignmentsPath);
var assignmentPromises = assignmentFiles
.Select(async filePath =>
{
var rawFile = await File.ReadAllTextAsync(filePath);
return LocalAssignment.ParseMarkdown(rawFile);
})
.ToArray();
return await Task.WhenAll(assignmentPromises);
}
private async Task<IEnumerable<LocalQuiz>> loadQuizzesFromPath(string modulePath)
{
var quizzesPath = $"{modulePath}/quizzes";
if (!Directory.Exists(quizzesPath))
{
var errorMessage = $"error loading course by name, quizzes folder does not exist in {modulePath}";
logger.Log(errorMessage);
throw new LoadCourseFromFileException(errorMessage);
}
var quizFiles = Directory.GetFiles(quizzesPath);
var quizPromises = quizFiles
.Select(async path =>
{
var rawQuiz = await File.ReadAllTextAsync(path);
return LocalQuiz.ParseMarkdown(rawQuiz);
});
return await Task.WhenAll(quizPromises);
}
}