daniel/deepdrft
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 13 Wiki Activity

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

Browse Source
This commit is contained in:
daniel-c-harvey
2025-09-07 12:56:52 -04:00
parent a5b7ab041e
commit b16bcfc6cd
47 changed files with 153 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files
DeepDrftContent/FileDatabase/Models/IIndex.cs
-60
View File
@@ -1,60 +0,0 @@
namespace DeepDrftContent.FileDatabase.Models;
/// <summary>
/// Base interface for all index types - minimal contract
/// </summary>
public interface IIndex
{
/// <summary>
/// Gets the key identifier for this index
/// </summary>
string GetKey();
}
/// <summary>
/// Interface for indexes that support entry queries
/// </summary>
public interface IEntryQueryable : IIndex
{
/// <summary>
/// Gets all entry IDs in this index
/// </summary>
IReadOnlyList<string> GetEntries();
/// <summary>
/// Gets the number of entries in this index
/// </summary>
int GetEntriesSize();
/// <summary>
/// Checks if the index contains the specified entry ID
/// </summary>
bool HasEntry(string entryId);
}
/// <summary>
/// Interface for indexes that support directory operations
/// </summary>
public interface IDirectoryIndex : IEntryQueryable
{
/// <summary>
/// Adds an entry to the directory index
/// </summary>
void PutEntry(string entryId);
}
/// <summary>
/// Interface for indexes that support vault operations with metadata
/// </summary>
public interface IVaultIndex : IEntryQueryable
{
/// <summary>
/// Gets metadata for a specific entry
/// </summary>
MetaData? GetEntry(string entryId);
/// <summary>
/// Adds an entry with metadata to the vault index
/// </summary>
void PutEntry(string entryId, MetaData metaData);
}
DeepDrftContent/FileDatabase/Models/IndexData.cs
-134
View File
@@ -1,134 +0,0 @@
using DeepDrftContent.FileDatabase.Utils;
using System.Text.Json.Serialization;
namespace DeepDrftContent.FileDatabase.Models;
/// <summary>
/// Base class for index data used in serialization
/// </summary>
public abstract class IndexData
{
public string IndexKey { get; }
protected IndexData(string indexKey)
{
IndexKey = indexKey;
}
}
/// <summary>
/// Serializable data for directory indexes
/// </summary>
public class DirectoryIndexData : IndexData
{
public List<string> Entries { get; set; } = new();
public DirectoryIndexData(string indexKey) : base(indexKey) { }
public static DirectoryIndexData FromIndex(DirectoryIndex index)
{
var data = new DirectoryIndexData(index.GetKey())
{
Entries = index.GetEntries().ToList()
};
return data;
}
}
/// <summary>
/// Entry data for vault index serialization
/// </summary>
public class VaultEntryData
{
public string Key { get; set; } = null!;
public MetaData Value { get; set; } = null!;
}
/// <summary>
/// Serializable data for vault indexes
/// </summary>
public class VaultIndexData : IndexData
{
public List<VaultEntryData> Entries { get; set; } = new();
public MediaVaultType VaultType { get; set; }
public VaultIndexData(string indexKey) : base(indexKey)
{
VaultType = MediaVaultType.Media; // Default vault type for legacy compatibility
}
[JsonConstructor]
public VaultIndexData(string indexKey, MediaVaultType vaultType) : base(indexKey)
{
VaultType = vaultType;
}
public static VaultIndexData FromIndex(VaultIndex index)
{
var data = new VaultIndexData(index.GetKey(), index.VaultType)
{
Entries = index.Entries.Select(kvp => new VaultEntryData { Key = kvp.Key, Value = kvp.Value }).ToList()
};
return data;
}
}
/// <summary>
/// Directory index implementation using StructuralSet for entries
/// </summary>
public class DirectoryIndex : IndexData, IDirectoryIndex
{
public StructuralSet<string> Entries { get; }
public DirectoryIndex(DirectoryIndexData indexData) : base(indexData.IndexKey)
{
Entries = new StructuralSet<string>();
// Load entries from data
foreach (var entry in indexData.Entries)
{
Entries.Add(entry);
}
}
public string GetKey() => IndexKey;
public IReadOnlyList<string> GetEntries() => Entries.ToList().AsReadOnly();
public int GetEntriesSize() => Entries.Size;
public bool HasEntry(string entryId) => Entries.Has(entryId);
public void PutEntry(string entryId) => Entries.Add(entryId);
}
/// <summary>
/// Vault index implementation using StructuralMap for entries with metadata
/// </summary>
public class VaultIndex : IndexData, IVaultIndex
{
public StructuralMap<string, MetaData> Entries { get; }
public MediaVaultType VaultType { get; }
public VaultIndex(VaultIndexData indexData) : base(indexData.IndexKey)
{
Entries = new StructuralMap<string, MetaData>();
VaultType = indexData.VaultType;
// Load entries from data
foreach (var entry in indexData.Entries)
{
Entries.Set(entry.Key, entry.Value);
}
}
public string GetKey() => IndexKey;
public IReadOnlyList<string> GetEntries() => Entries.Keys.ToList().AsReadOnly();
public int GetEntriesSize() => Entries.Size;
public bool HasEntry(string entryId) => Entries.Has(entryId);
public MetaData? GetEntry(string entryId) => Entries.Get(entryId);
public void PutEntry(string entryId, MetaData metaData) => Entries.Set(entryId, metaData);
}
DeepDrftContent/FileDatabase/Models/MediaFactories.cs
-142
View File
@@ -1,142 +0,0 @@
using DeepDrftContent.FileDatabase.Abstractions;
using DeepDrftContent.FileDatabase.Services;
namespace DeepDrftContent.FileDatabase.Models;
/// <summary>
/// Type mappings for media vault types - simple dictionary-based approach
/// </summary>
public static class MediaVaultTypeMap
{
private static readonly IMediaTypeRegistry _registry = new SimpleMediaTypeRegistry();
public static Type GetBinaryType(MediaVaultType vaultType) => _registry.GetBinaryType(vaultType);
public static Type GetDtoType(MediaVaultType vaultType) => _registry.GetDtoType(vaultType);
public static Type GetParamsType(MediaVaultType vaultType) => _registry.GetParamsType(vaultType);
public static Type GetMetaDataType(MediaVaultType vaultType) => _registry.GetMetaDataType(vaultType);
/// <summary>
/// Get the vault type for a binary type (reverse mapping)
/// </summary>
public static MediaVaultType GetVaultType(Type binaryType) => _registry.GetVaultType(binaryType);
/// <summary>
/// Get the vault type for a binary type using generics (reverse mapping)
/// </summary>
public static MediaVaultType GetVaultType<T>() where T : FileBinary => _registry.GetVaultType<T>();
}
/// <summary>
/// Factory for creating metadata objects based on vault type
/// </summary>
public static class MetaDataFactory
{
public static MetaData Create(MediaVaultType type, string entryKey, string extension)
{
return type switch
{
MediaVaultType.Media => new MetaData(entryKey, extension),
MediaVaultType.Image => throw new ArgumentException("Image metadata requires aspect ratio. Use CreateImageMetaData instead."),
MediaVaultType.Audio => throw new ArgumentException("Audio metadata requires duration and bitrate. Use CreateAudioMetaData instead."),
_ => throw new ArgumentException($"Unknown vault type: {type}")
};
}
public static ImageMetaData CreateImageMetaData(string entryKey, string extension, double aspectRatio)
{
return new ImageMetaData(entryKey, extension, aspectRatio);
}
public static AudioMetaData CreateAudioMetaData(string entryKey, string extension, double duration, int bitrate)
{
return new AudioMetaData(entryKey, extension, duration, bitrate);
}
private static readonly IMediaTypeRegistry _metaDataRegistry = new SimpleMediaTypeRegistry();
public static MetaData CreateFromMedia(MediaVaultType type, string entryKey, string extension, object media)
{
return _metaDataRegistry.CreateMetaDataFromMedia(type, entryKey, extension, media);
}
public static T Create<T>(MediaVaultType type, string entryKey, string extension)
where T : MetaData
{
var metaData = Create(type, entryKey, extension);
return (T)metaData;
}
}
/// <summary>
/// Factory for creating media parameter objects - simple dictionary-based approach
/// </summary>
public static class MediaParamsFactory
{
private static readonly IMediaTypeRegistry _registry = new SimpleMediaTypeRegistry();
public static object Create(MediaVaultType type, FileBinary fileBinary, MetaData metaData)
{
return _registry.CreateParams(type, fileBinary, metaData);
}
public static T Create<T>(MediaVaultType type, FileBinary fileBinary, MetaData metaData)
{
var parameters = Create(type, fileBinary, metaData);
return (T)parameters;
}
}
/// <summary>
/// Factory for creating media binary objects - simple dictionary-based approach
/// </summary>
public static class FileBinaryFactory
{
private static readonly IMediaTypeRegistry _registry = new SimpleMediaTypeRegistry();
public static object Create(MediaVaultType vaultType, object parameters)
{
return _registry.CreateBinary(vaultType, parameters);
}
public static T Create<T>(MediaVaultType vaultType, object parameters) where T : FileBinary
{
var binary = Create(vaultType, parameters);
return (T)binary;
}
public static object From(MediaVaultType type, object mediaBinaryDto)
{
return _registry.CreateBinaryFromDto(type, mediaBinaryDto);
}
public static T From<T>(MediaVaultType type, object mediaBinaryDto) where T : FileBinary
{
var binary = From(type, mediaBinaryDto);
return (T)binary;
}
}
/// <summary>
/// Factory for creating DTO objects from media binaries - simple dictionary-based approach
/// </summary>
public static class FileBinaryDtoFactory
{
private static readonly IMediaTypeRegistry _registry = new SimpleMediaTypeRegistry();
public static object From(MediaVaultType type, object mediaBinary)
{
if (mediaBinary is not FileBinary fileBinary)
throw new ArgumentException($"Expected FileBinary but got {mediaBinary.GetType()}");
return _registry.CreateDto(type, fileBinary);
}
public static T From<T>(MediaVaultType type, object mediaBinary)
{
var dto = From(type, mediaBinary);
return (T)dto;
}
}
DeepDrftContent/FileDatabase/Models/MediaModels.cs
-251
View File
@@ -1,251 +0,0 @@
namespace DeepDrftContent.FileDatabase.Models;
/// <summary>
/// Parameters for creating a FileBinary
/// </summary>
/// <param name="Buffer">The binary data</param>
/// <param name="Size">The size of the data in bytes</param>
public record FileBinaryParams(byte[] Buffer, int Size);
/// <summary>
/// Base class for file binary data
/// </summary>
public class FileBinary
{
public byte[] Buffer { get; }
public int Size { get; }
public FileBinary(FileBinaryParams parameters)
{
Buffer = parameters.Buffer;
Size = parameters.Size;
}
public static FileBinary From(FileBinaryDto dto)
{
var buffer = Convert.FromBase64String(dto.Base64);
return new FileBinary(new FileBinaryParams(buffer, dto.Size));
}
}
/// <summary>
/// DTO for FileBinary serialization
/// </summary>
/// <param name="Base64">Base64 encoded binary data</param>
/// <param name="Size">Size of the original data</param>
public record FileBinaryDto(string Base64, int Size)
{
public FileBinaryDto(FileBinary fileBinary) : this(
Convert.ToBase64String(fileBinary.Buffer),
fileBinary.Size) { }
}
/// <summary>
/// Parameters for creating a MediaBinary
/// </summary>
/// <param name="Buffer">The binary data</param>
/// <param name="Size">The size of the data in bytes</param>
/// <param name="Extension">The file extension</param>
public record MediaBinaryParams(byte[] Buffer, int Size, string Extension)
: FileBinaryParams(Buffer, Size);
/// <summary>
/// Media binary with extension information
/// </summary>
public class MediaBinary : FileBinary
{
public string Extension { get; }
public MediaBinary(MediaBinaryParams parameters) : base(parameters)
{
Extension = parameters.Extension;
}
public static MediaBinary From(MediaBinaryDto dto)
{
var buffer = Convert.FromBase64String(dto.Base64);
var extension = GetExtensionType(dto.Mime);
return new MediaBinary(new MediaBinaryParams(buffer, dto.Size, extension));
}
private static string GetExtensionType(string mime)
{
return MimeTypeExtensions.GetExtension(mime);
}
}
/// <summary>
/// DTO for MediaBinary serialization
/// </summary>
/// <param name="Base64">Base64 encoded binary data</param>
/// <param name="Size">Size of the original data</param>
/// <param name="Mime">MIME type of the media</param>
public record MediaBinaryDto(string Base64, int Size, string Mime) : FileBinaryDto(Base64, Size)
{
public MediaBinaryDto(MediaBinary mediaBinary) : this(
Convert.ToBase64String(mediaBinary.Buffer),
mediaBinary.Size,
MimeTypeExtensions.GetMimeType(mediaBinary.Extension)) { }
}
/// <summary>
/// Parameters for creating an ImageBinary
/// </summary>
/// <param name="Buffer">The binary data</param>
/// <param name="Size">The size of the data in bytes</param>
/// <param name="Extension">The file extension</param>
/// <param name="AspectRatio">The aspect ratio of the image</param>
public record ImageBinaryParams(byte[] Buffer, int Size, string Extension, double AspectRatio)
: MediaBinaryParams(Buffer, Size, Extension);
/// <summary>
/// Image binary with aspect ratio information
/// </summary>
public class ImageBinary : MediaBinary
{
public double AspectRatio { get; }
public ImageBinary(ImageBinaryParams parameters) : base(parameters)
{
AspectRatio = parameters.AspectRatio;
}
public static ImageBinary From(ImageBinaryDto dto)
{
var buffer = Convert.FromBase64String(dto.Base64);
var extension = GetExtensionType(dto.Mime);
return new ImageBinary(new ImageBinaryParams(buffer, dto.Size, extension, dto.AspectRatio));
}
private static string GetExtensionType(string mime)
{
return MimeTypeExtensions.GetExtension(mime);
}
}
/// <summary>
/// DTO for ImageBinary serialization
/// </summary>
/// <param name="Base64">Base64 encoded binary data</param>
/// <param name="Size">Size of the original data</param>
/// <param name="Mime">MIME type of the media</param>
/// <param name="AspectRatio">The aspect ratio of the image</param>
public record ImageBinaryDto(string Base64, int Size, string Mime, double AspectRatio)
: MediaBinaryDto(Base64, Size, Mime)
{
public ImageBinaryDto(ImageBinary imageBinary) : this(
Convert.ToBase64String(imageBinary.Buffer),
imageBinary.Size,
MimeTypeExtensions.GetMimeType(imageBinary.Extension),
imageBinary.AspectRatio) { }
}
/// <summary>
/// Parameters for creating an AudioBinary
/// </summary>
/// <param name="Buffer">The binary data</param>
/// <param name="Size">The size of the data in bytes</param>
/// <param name="Extension">The file extension</param>
/// <param name="Duration">The duration of the audio in seconds</param>
/// <param name="Bitrate">The bitrate of the audio in kbps</param>
public record AudioBinaryParams(byte[] Buffer, int Size, string Extension, double Duration, int Bitrate)
: MediaBinaryParams(Buffer, Size, Extension);
/// <summary>
/// Audio binary with duration and bitrate information
/// </summary>
public class AudioBinary : MediaBinary
{
public double Duration { get; }
public int Bitrate { get; }
public AudioBinary(AudioBinaryParams parameters) : base(parameters)
{
Duration = parameters.Duration;
Bitrate = parameters.Bitrate;
}
public static AudioBinary From(AudioBinaryDto dto)
{
var buffer = Convert.FromBase64String(dto.Base64);
var extension = GetExtensionType(dto.Mime);
return new AudioBinary(new AudioBinaryParams(buffer, dto.Size, extension, dto.Duration, dto.Bitrate));
}
private static string GetExtensionType(string mime)
{
return MimeTypeExtensions.GetExtension(mime);
}
}
/// <summary>
/// DTO for AudioBinary serialization
/// </summary>
/// <param name="Base64">Base64 encoded binary data</param>
/// <param name="Size">Size of the original data</param>
/// <param name="Mime">MIME type of the media</param>
/// <param name="Duration">The duration of the audio in seconds</param>
/// <param name="Bitrate">The bitrate of the audio in kbps</param>
public record AudioBinaryDto(string Base64, int Size, string Mime, double Duration, int Bitrate)
: MediaBinaryDto(Base64, Size, Mime)
{
public AudioBinaryDto(AudioBinary audioBinary) : this(
Convert.ToBase64String(audioBinary.Buffer),
audioBinary.Size,
MimeTypeExtensions.GetMimeType(audioBinary.Extension),
audioBinary.Duration,
audioBinary.Bitrate) { }
}
/// <summary>
/// Utility class for MIME type and extension conversions
/// </summary>
public static class MimeTypeExtensions
{
private static readonly Dictionary<string, string> MimeTypes = new()
{
{ ".jpg", "image/jpeg" },
{ ".jpeg", "image/jpeg" },
{ ".png", "image/png" },
{ ".gif", "image/gif" },
{ ".webp", "image/webp" },
{ ".svg", "image/svg+xml" },
{ ".bmp", "image/bmp" },
{ ".mp3", "audio/mpeg" },
{ ".wav", "audio/wav" },
{ ".flac", "audio/flac" },
{ ".aac", "audio/aac" },
{ ".ogg", "audio/ogg" },
{ ".m4a", "audio/mp4" }
};
private static readonly Dictionary<string, string> Extensions = new()
{
{ "image/jpeg", ".jpg" },
{ "image/png", ".png" },
{ "image/gif", ".gif" },
{ "image/webp", ".webp" },
{ "image/svg+xml", ".svg" },
{ "image/bmp", ".bmp" },
{ "audio/mpeg", ".mp3" },
{ "audio/wav", ".wav" },
{ "audio/flac", ".flac" },
{ "audio/aac", ".aac" },
{ "audio/ogg", ".ogg" },
{ "audio/mp4", ".m4a" }
};
public static string GetMimeType(string extension)
{
return MimeTypes.TryGetValue(extension.ToLowerInvariant(), out var mime)
? mime
: "application/octet-stream";
}
public static string GetExtension(string mime)
{
return Extensions.TryGetValue(mime.ToLowerInvariant(), out var extension)
? extension
: ".bin";
}
}
DeepDrftContent/FileDatabase/Models/MediaVaultType.cs
-11
View File
@@ -1,11 +0,0 @@
namespace DeepDrftContent.FileDatabase.Models;
/// <summary>
/// Enum representing different types of media vaults
/// </summary>
public enum MediaVaultType
{
Media,
Image,
Audio
}
DeepDrftContent/FileDatabase/Models/MetaData.cs
-33
View File
@@ -1,33 +0,0 @@
using System.Text.Json.Serialization;
namespace DeepDrftContent.FileDatabase.Models;
/// <summary>
/// Base metadata for media entries
/// </summary>
/// <param name="MediaKey">The key used to identify the media file</param>
/// <param name="Extension">The file extension of the media</param>
[JsonPolymorphic(TypeDiscriminatorPropertyName = "$type")]
[JsonDerivedType(typeof(MetaData), typeDiscriminator: "media")]
[JsonDerivedType(typeof(ImageMetaData), typeDiscriminator: "image")]
[JsonDerivedType(typeof(AudioMetaData), typeDiscriminator: "audio")]
public record MetaData(string MediaKey, string Extension);
/// <summary>
/// Extended metadata for image entries, including aspect ratio
/// </summary>
/// <param name="MediaKey">The key used to identify the media file</param>
/// <param name="Extension">The file extension of the media</param>
/// <param name="AspectRatio">The aspect ratio of the image</param>
public record ImageMetaData(string MediaKey, string Extension, double AspectRatio)
: MetaData(MediaKey, Extension);
/// <summary>
/// Extended metadata for audio entries, including duration and bitrate
/// </summary>
/// <param name="MediaKey">The key used to identify the media file</param>
/// <param name="Extension">The file extension of the media</param>
/// <param name="Duration">The duration of the audio in seconds</param>
/// <param name="Bitrate">The bitrate of the audio in kbps</param>
public record AudioMetaData(string MediaKey, string Extension, double Duration, int Bitrate)
: MetaData(MediaKey, Extension);