Add project files.

JSMR.Application/Common/Caching/CacheEntryOptions.cs

@@ -0,0 +1,69 @@
+namespace JSMR.Application.Common.Caching;
+
+public class CacheEntryOptions
+{
+    private DateTimeOffset? _absoluteExpiration;
+    private TimeSpan? _absoluteExpirationRelativeToNow;
+    private TimeSpan? _slidingExpiration;
+
+    /// <summary>
+    /// Gets or sets an absolute expiration date for the cache entry.
+    /// </summary>
+    public DateTimeOffset? AbsoluteExpiration
+    {
+        get
+        {
+            return _absoluteExpiration;
+        }
+        set
+        {
+            _absoluteExpiration = value;
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets an absolute expiration time, relative to now.
+    /// </summary>
+    public TimeSpan? AbsoluteExpirationRelativeToNow
+    {
+        get
+        {
+            return _absoluteExpirationRelativeToNow;
+        }
+        set
+        {
+            if (value <= TimeSpan.Zero)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(AbsoluteExpirationRelativeToNow),
+                    value,
+                    "The relative expiration value must be positive.");
+            }
+
+            _absoluteExpirationRelativeToNow = value;
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets how long a cache entry can be inactive (e.g. not accessed) before it will be removed.
+    /// This will not extend the entry lifetime beyond the absolute expiration (if set).
+    /// </summary>
+    public TimeSpan? SlidingExpiration
+    {
+        get
+        {
+            return _slidingExpiration;
+        }
+        set
+        {
+            if (value <= TimeSpan.Zero)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(SlidingExpiration),
+                    value,
+                    "The sliding expiration value must be positive.");
+            }
+            _slidingExpiration = value;
+        }
+    }
+}

JSMR.Application/Common/Caching/ICache.cs

@@ -0,0 +1,7 @@
+namespace JSMR.Application.Common.Caching;
+
+public interface ICache
+{
+    ValueTask<T?> GetAsync<T>(string key, CancellationToken cancellationToken = default);
+    ValueTask SetAsync<T>(string key, T value, CacheEntryOptions options, CancellationToken cancellationToken = default);
+}

JSMR.Application/Common/Language.cs

@@ -0,0 +1,11 @@
+namespace JSMR.Application.Common;
+
+public enum Language
+{
+    Unknown,
+    Japanese,
+    English,
+    ChineseSimplified,
+    ChineseTraditional,
+    Korean
+}

JSMR.Application/Common/Search/ISearchProvider.cs

@@ -0,0 +1,8 @@
+namespace JSMR.Application.Common.Search;
+
+public interface ISearchProvider<TItem, TCriteria, TSortField>
+    where TCriteria : new()
+    where TSortField : struct, Enum
+{
+    Task<SearchResult<TItem>> SearchAsync(SearchOptions<TCriteria, TSortField> options, CancellationToken cancellationToken = default);
+}

JSMR.Application/Common/Search/ISearchQueryHandler.cs

@@ -0,0 +1,8 @@
+namespace JSMR.Application.Common.Search;
+
+public interface ISearchQueryHandler<TItem, TCriteria, TSortField>
+    where TCriteria : new()
+    where TSortField : struct, Enum
+{
+    Task<SearchResult<TItem>> HandleAsync(SearchOptions<TCriteria, TSortField> options, CancellationToken cancellationToken = default);
+}

JSMR.Application/Common/Search/SearchOptions.cs

@@ -0,0 +1,11 @@
+namespace JSMR.Application.Common.Search;
+
+public sealed record SearchOptions<TCriteria, TSortField>
+    where TCriteria : new()
+    where TSortField : struct, Enum
+{
+    public int PageNumber { get; set; } = 1;
+    public int PageSize { get; set; } = 100;
+    public TCriteria Criteria { get; set; } = new();
+    public SortOption<TSortField>[] SortOptions { get; set; } = [];
+}

JSMR.Application/Common/Search/SearchReader.cs

@@ -0,0 +1,71 @@
+using JSMR.Application.Tags.Queries.Search.Contracts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JSMR.Application.Common.Search;
+
+
+
+
+//public abstract class SearchReader2<TItem, TCriteria, TSortField> : ISearchReader<TItem, TCriteria, TSortField>
+//    where TSortField : struct, Enum
+//{
+//    public Task<SearchResult<TItem>> SearchAsync(SearchOptions<TCriteria, TSortField> options, CancellationToken cancellationToken = default)
+//    {
+//        throw new NotImplementedException();
+//    }
+//}
+
+//public abstract class SearchReader<TSearchResultItem, TCriteria, TSortField> where TSortField : struct, Enum
+//{
+//    public async Task<SearchResult<TSearchResultItem>> SearchAsync(SearchOptions<TCriteria, TSortField> options, CancellationToken cancellationToken = default)
+//    {
+//        IQueryable<TSearchResultItem> baseQuery = GetBaseQuery();
+//        IQueryable<TSearchResultItem> filteredQuery = ApplyFilters(baseQuery, options);
+
+//        int total = await filteredQuery.CountAsync(cancellationToken);
+
+//        IOrderedQueryable<TSearchResultItem> orderedQuery = ApplySorting(filteredQuery, options);
+
+//        TSearchResultItem[] items = await orderedQuery
+//            .Skip((options.PageNumber - 1) * options.PageSize)
+//            .Take(options.PageSize)
+//            .ToArrayAsync(cancellationToken);
+
+//        return new SearchResult<TSearchResultItem>()
+//        {
+//            Items = items,
+//            TotalItems = total
+//        };
+//    }
+
+//    protected abstract IQueryable<TSearchResultItem> GetBaseQuery();
+//    protected abstract IQueryable<TSearchResultItem> ApplyFilters(IQueryable<TSearchResultItem> query, SearchOptions<TCriteria, TSortField> options);
+
+//    private IOrderedQueryable<TSearchResultItem> ApplySorting(IQueryable<TSearchResultItem> query, SearchOptions<TCriteria, TSortField> options)
+//    {
+//        IOrderedQueryable<TSearchResultItem>? ordered = null;
+
+//        for (int i = 0; i < options.SortOptions.Length; i++)
+//        {
+//            var (field, direction) = (options.SortOptions[i].Field, options.SortOptions[i].Direction);
+//            bool isDescending = direction == SortDirection.Descending;
+
+//            IOrderedQueryable<TSearchResultItem> applyFirst(Expression<Func<TSearchResultItem, object>> selector) => isDescending ? query.OrderByDescending(selector) : query.OrderBy(selector);
+//            IOrderedQueryable<TSearchResultItem> applyNext(Expression<Func<TSearchResultItem, object>> selector) => isDescending ? ordered!.ThenByDescending(selector) : ordered!.ThenBy(selector);
+
+//            Expression<Func<TSearchResultItem, object>> selector = GetSortExpression(field);
+
+//            ordered = (i == 0) ? applyFirst(selector) : applyNext(selector);
+//        }
+
+//        return ordered ?? GetDefaultSortExpression(query);
+//    }
+
+//    protected abstract Expression<Func<TSearchResultItem, object>> GetSortExpression(TSortField field);
+//    protected abstract IOrderedQueryable<TSearchResultItem> GetDefaultSortExpression(IQueryable<TSearchResultItem> query);
+//}

JSMR.Application/Common/Search/SearchResult.cs

@@ -0,0 +1,7 @@
+namespace JSMR.Application.Common.Search;
+
+public record SearchResult<T>
+{
+    public T[] Items { get; set; } = [];
+    public int TotalItems { get; set; }
+}

JSMR.Application/Common/Search/SortDirection.cs

@@ -0,0 +1,7 @@
+namespace JSMR.Application.Common.Search;
+
+public enum SortDirection
+{
+    Ascending = 0,
+    Descending = 1
+}

JSMR.Application/Common/Search/SortOption.cs

@@ -0,0 +1,3 @@
+namespace JSMR.Application.Common.Search;
+
+public record SortOption<TSortField>(TSortField Field, SortDirection Direction) where TSortField : struct, Enum;