Backend Services Split into separate projects for reference from other front ends

DeepDrftContent.Services/FileDatabase/Services/MediaVault.cs

@@ -0,0 +1,144 @@
+using System.Text.RegularExpressions;
+using DeepDrftContent.Services.FileDatabase.Models;
+using DeepDrftContent.Services.FileDatabase.Utils;
+
+namespace DeepDrftContent.Services.FileDatabase.Services;
+
+/// <summary>
+/// Abstract base class for media vaults that store and manage media files
+/// </summary>
+public abstract class MediaVault : VaultIndexDirectory
+{
+    protected MediaVault(string rootPath, VaultIndex index) : base(rootPath, index) { }
+
+    /// <summary>
+    /// Generates a media key from an entry key by sanitizing special characters
+    /// </summary>
+    protected string GetMediaKey(string entryKey, string extension)
+    {
+        var sanitized = Regex.Replace(entryKey, @"[^a-zA-Z0-9]", "-");
+        return $"{sanitized}{extension}";
+    }
+
+    /// <summary>
+    /// Gets the full file path for a media file from an entry key
+    /// </summary>
+    protected string GetMediaPathFromEntryKey(string entryKey, string extension)
+    {
+        return Path.Combine(RootPath, GetMediaKey(entryKey, extension));
+    }
+
+    /// <summary>
+    /// Gets the full file path for a media file from a media key
+    /// </summary>
+    protected string GetMediaPathFromMediaKey(string mediaKey)
+    {
+        return Path.Combine(RootPath, mediaKey);
+    }
+
+    /// <summary>
+    /// Adds a new entry to the vault with the specified media data (MediaVaultType inferred from media type)
+    /// </summary>
+    public async Task AddEntryAsync(string entryId, FileBinary media)
+    {
+        // Extract properties from media object based on type
+        var (buffer, extension) = ExtractMediaProperties(media);
+        
+        // Infer MediaVaultType from the media object type
+        var vaultType = MediaVaultTypeMap.GetVaultType(media.GetType());
+        
+        var mediaPath = GetMediaPathFromEntryKey(entryId, extension);
+        var metaData = MetaDataFactory.CreateFromMedia(vaultType, entryId, extension, media);
+        
+        // Use string-based index operations
+        await AddToIndexAsync(entryId, metaData);
+        await FileUtils.PutFileAsync(mediaPath, buffer);
+    }
+
+    /// <summary>
+    /// Retrieves an entry from the vault (MediaVaultType inferred from T)
+    /// </summary>
+    public async Task<T?> GetEntryAsync<T>(string entryId) where T : FileBinary
+    {
+        // Infer MediaVaultType from the generic type T
+        var vaultType = MediaVaultTypeMap.GetVaultType<T>();
+        
+        if (!HasIndexEntry(entryId))
+            return null;
+
+        if (Index is not VaultIndex vaultIndex)
+            return null;
+
+        var metaData = vaultIndex.GetEntry(entryId);
+        if (metaData == null)
+            return null;
+
+        var mediaPath = GetMediaPathFromEntryKey(metaData.MediaKey, metaData.Extension);
+        
+        if (!FileUtils.FileExists(mediaPath))
+            return null;
+
+        var fileBinary = await FileUtils.FetchFileAsync(mediaPath);
+        var parameters = MediaParamsFactory.Create(vaultType, fileBinary, metaData);
+        
+        var result = FileBinaryFactory.Create(vaultType, parameters);
+        return (T)result;
+    }
+
+    /// <summary>
+    /// Extracts buffer and extension from a media binary
+    /// </summary>
+    private static (byte[] buffer, string extension) ExtractMediaProperties(FileBinary media)
+    {
+        return media switch
+        {
+            ImageBinary imageBinary => (imageBinary.Buffer, imageBinary.Extension),
+            AudioBinary audioBinary => (audioBinary.Buffer, audioBinary.Extension),
+            MediaBinary mediaBinary => (mediaBinary.Buffer, mediaBinary.Extension),
+            FileBinary fileBinary => throw new ArgumentException($"FileBinary must be a specific media type (ImageBinary, AudioBinary, or MediaBinary), not base FileBinary"),
+            _ => throw new ArgumentException($"Unsupported media type: {media.GetType()}")
+        };
+    }
+}
+
+/// <summary>
+/// Concrete implementation of MediaVault for image storage
+/// </summary>
+public class ImageVault : MediaVault
+{
+    private ImageVault(string rootPath, VaultIndex index) : base(rootPath, index) { }
+
+    /// <summary>
+    /// Factory method to create an ImageVault instance
+    /// </summary>
+    public static async Task<ImageVault?> FromAsync(string rootPath)
+    {
+        var factoryService = new IndexFactoryService();
+        var index = await factoryService.LoadOrCreateVaultIndexAsync(rootPath, MediaVaultType.Image);
+
+        if (index != null)
+        {
+            return new ImageVault(rootPath, (VaultIndex)index);
+        }
+
+        return null;
+    }
+}
+
+public class AudioVault : MediaVault
+{
+    private AudioVault(string rootPath, VaultIndex index) : base(rootPath, index) { }
+    
+    public static async Task<AudioVault?> FromAsync(string rootPath)
+    {
+        var factoryService = new IndexFactoryService();
+        var index = await factoryService.LoadOrCreateVaultIndexAsync(rootPath, MediaVaultType.Audio);
+
+        if (index != null)
+        {
+            return new AudioVault(rootPath, (VaultIndex)index);
+        }
+
+        return null;
+    }
+}