Add enumeration cache components

Author: Stedra Kristóf

src/AutSoft.AspNetCore.Blazor/Enumeration/Enumeration.cs

@@ -0,0 +1,38 @@
+namespace AutSoft.AspNetCore.Blazor.Enumeration;
+
+/// <summary>
+/// Enumeration type items.
+/// </summary>
+/// <typeparam name="TEnum">Collection of the enumeration types.</typeparam>
+public class Enumeration<TEnum> where TEnum : Enum
+{
+    /// <summary>
+    /// Default constructor of the Enumeration.
+    /// </summary>
+    public Enumeration()
+    {
+        Type = default!;
+        Items = new List<EnumerationItem>();
+    }
+
+    /// <summary>
+    /// Default constructor of the Enumeration.
+    /// </summary>
+    /// <param name="type">Enumeration type.</param>
+    /// <param name="items">Items of the enumerations.</param>
+    public Enumeration(TEnum type, List<EnumerationItem> items)
+    {
+        Type = type;
+        Items = items;
+    }
+
+    /// <summary>
+    /// Enumeration type.
+    /// </summary>
+    public TEnum Type { get; set; }
+
+    /// <summary>
+    /// Items of the enumeration.
+    /// </summary>
+    public List<EnumerationItem> Items { get; set; }
+}

src/AutSoft.AspNetCore.Blazor/Enumeration/EnumerationCache.cs

@@ -0,0 +1,87 @@
+using AutSoft.Common.Concurrency;
+
+using Microsoft.Extensions.Logging;
+
+namespace AutSoft.AspNetCore.Blazor.Enumeration;
+
+/// <inheritdoc />
+public class EnumerationCache<TEnum> : IEnumerationCache<TEnum>, IDisposable where TEnum : Enum
+{
+    private readonly Dictionary<TEnum, List<EnumerationItem>> _enumerations = new();
+
+    private readonly AsyncLock _downloadLock = new();
+
+    private readonly IEnumerationService<TEnum> _enumerationClient;
+    private readonly ILogger<EnumerationCache<TEnum>> _logger;
+
+    /// <summary>
+    /// Constructor of the EnumerationCache.
+    /// </summary>
+    /// <param name="enumerationService">Enumeration service.</param>
+    /// <param name="logger">Logger of the enumeration cache.</param>
+    public EnumerationCache(IEnumerationService<TEnum> enumerationService, ILogger<EnumerationCache<TEnum>> logger)
+    {
+        _enumerationClient = enumerationService;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public async Task EnsureHasCachedEnumerationAsync(params TEnum[] enumerationTypes)
+    {
+        using (await AsyncLockContext.CreateAsync(_downloadLock))
+        {
+            var enumerationTypesToDownload = enumerationTypes.Where(t => !_enumerations.Any(m => m.Key.Equals(t))).ToList();
+            if (enumerationTypesToDownload.Count == 0)
+                return;
+
+            var result = await _enumerationClient.ListEnumerationsAsync(enumerationTypesToDownload);
+
+            foreach (var enumerationItem in result)
+            {
+                if (!_enumerations.ContainsKey(enumerationItem.Type))
+                    _enumerations.Add(enumerationItem.Type, enumerationItem.Items);
+            }
+        }
+    }
+
+    private async Task TryEnsureHasCachedEnumerationAsync(params TEnum[] enumerationTypes)
+    {
+        try
+        {
+            await EnsureHasCachedEnumerationAsync(enumerationTypes);
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Failed to load enumerations.");
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<string?> ResolveDisplayNameAsync(TEnum type, int key)
+    {
+        await TryEnsureHasCachedEnumerationAsync(type);
+
+        if (!_enumerations.ContainsKey(type))
+            return null;
+
+        return _enumerations[type].SingleOrDefault(i => i.Id == key)?.DisplayName;
+    }
+
+    /// <inheritdoc />
+    public async Task<List<EnumerationItem>> ResolveEnumerationItemsAsync(TEnum type)
+    {
+        await TryEnsureHasCachedEnumerationAsync(type);
+
+        if (!_enumerations.ContainsKey(type))
+            return new List<EnumerationItem>();
+
+        return _enumerations[type];
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        _downloadLock.Dispose();
+        GC.SuppressFinalize(this);
+    }
+}

src/AutSoft.AspNetCore.Blazor/Enumeration/EnumerationItem.cs

@@ -0,0 +1,35 @@
+namespace AutSoft.AspNetCore.Blazor.Enumeration;
+
+/// <summary>
+/// Enumeration item data.
+/// </summary>
+public class EnumerationItem
+{
+    /// <summary>
+    /// Default constructor of the EnumerationItem.
+    /// </summary>
+    public EnumerationItem()
+    {
+    }
+
+    /// <summary>
+    /// Constructor of the EnumerationItem.
+    /// </summary>
+    /// <param name="key">Key of the enum item.</param>
+    /// <param name="value">Value of the enum item.</param>
+    public EnumerationItem(int key, string value)
+    {
+        Id = key;
+        DisplayName = value;
+    }
+
+    /// <summary>
+    /// Enumeration item id.
+    /// </summary>
+    public int Id { get; set; }
+
+    /// <summary>
+    /// Enumeration diplay name.
+    /// </summary>
+    public string DisplayName { get; set; } = null!;
+}

src/AutSoft.AspNetCore.Blazor/Enumeration/IEnumerationCache.cs

@@ -0,0 +1,29 @@
+namespace AutSoft.AspNetCore.Blazor.Enumeration;
+
+/// <summary>
+/// Cache for enumeration types.
+/// </summary>
+/// <typeparam name="TEnum">Collection of the enumeration types.</typeparam>
+public interface IEnumerationCache<TEnum> where TEnum : Enum
+{
+    /// <summary>
+    /// Resolves the display name of the specified enumeration type with id.
+    /// </summary>
+    /// <param name="type">Enumeration type.</param>
+    /// <param name="id">Id of the enumeration type.</param>
+    /// <returns>Display name.</returns>
+    Task<string?> ResolveDisplayNameAsync(TEnum type, int id);
+
+    /// <summary>
+    /// Resolves enumeration items of the specified enumeration type.
+    /// </summary>
+    /// <param name="type">Enumeration type.</param>
+    /// <returns>Enumeration items.</returns>
+    Task<List<EnumerationItem>> ResolveEnumerationItemsAsync(TEnum type);
+
+    /// <summary>
+    /// Caches the specified enumeration types if they are not in the cache.
+    /// </summary>
+    /// <param name="enumerationTypes">Enumeration types.</param>
+    Task EnsureHasCachedEnumerationAsync(params TEnum[] enumerationTypes);
+}

src/AutSoft.AspNetCore.Blazor/Enumeration/IEnumerationService.cs

@@ -0,0 +1,15 @@
+namespace AutSoft.AspNetCore.Blazor.Enumeration;
+
+/// <summary>
+/// Enumeration service that is used by the cache to get the values of enumeration types.
+/// </summary>
+/// <typeparam name="TEnum">Collection of the enumeration types.</typeparam>
+public interface IEnumerationService<TEnum> where TEnum : Enum
+{
+    /// <summary>
+    /// Lists the specified enumeration types.
+    /// </summary>
+    /// <param name="enumerationTypes">Enumeration types.</param>
+    /// <returns>Values of the enumeration types.</returns>
+    Task<List<Enumeration<TEnum>>> ListEnumerationsAsync(List<TEnum> enumerationTypes);
+}

src/AutSoft.AspNetCore.Blazor/ServiceCollectionExtensions.cs

@@ -1,6 +1,5 @@
 using AutSoft.AspNetCore.Blazor.Clipboard;
 using AutSoft.AspNetCore.Blazor.ComponentState;
-using AutSoft.AspNetCore.Blazor.Enumeration;
 using AutSoft.AspNetCore.Blazor.ErrorHandling;
 using AutSoft.AspNetCore.Blazor.Localization;
 

src/AutSoft.Mud.Blazor/Enumeration/EnumerationAutocomplete.cs

@@ -0,0 +1,63 @@
+using AutSoft.AspNetCore.Blazor.Enumeration;
+
+using Microsoft.AspNetCore.Components;
+
+using MudBlazor;
+
+namespace AutSoft.Mud.Blazor.Enumeration;
+
+/// <summary>
+/// Enumeration autocomplete.
+/// </summary>
+/// <typeparam name="T">Enumeration type.</typeparam>
+/// <typeparam name="TEnum">Collection of the enumeration types.</typeparam>
+public class EnumerationAutocomplete<T, TEnum> : MudAutocomplete<T> where TEnum : Enum
+{
+    /// <summary>
+    /// Items number to show.
+    /// </summary>
+    [Parameter]
+    public int Take { get; set; } = 10;
+
+    /// <summary>
+    /// Enumeration type.
+    /// </summary>
+    [Parameter]
+    public TEnum Type { get; set; } = default!;
+
+    [Inject]
+    private IEnumerationCache<TEnum> EnumerationCache { get; set; } = null!;
+
+    private List<EnumerationItem> _enumerationItems = new();
+
+    /// <summary>
+    /// Default constructor of the EnumerationAutocomplete.
+    /// </summary>
+    public EnumerationAutocomplete()
+    {
+        var enumType = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
+        if (!enumType.IsEnum && enumType != typeof(int))
+            throw new NotSupportedException("Only enum/int or nullable enum/int types are supported!");
+
+        ToStringFunc = (t) => t == null ? null : _enumerationItems.SingleOrDefault(d => d.Id == (int)(object)t!)?.DisplayName;
+
+        SearchFunc = (filter) => Task.FromResult(
+            _enumerationItems
+            .Where(c => string.IsNullOrEmpty(filter) || c.DisplayName.Contains(filter, StringComparison.InvariantCultureIgnoreCase))
+            .Take(Take)
+            .Select(c => enumType.IsEnum ? (T)Enum.ToObject(enumType, c.Id) : (T)(object)c.Id));
+    }
+
+    /// <inheritdoc />
+    public override async Task SetParametersAsync(ParameterView parameters)
+    {
+        await base.SetParametersAsync(parameters);
+
+        if (!Type.Equals(default(TEnum)))
+        {
+            _enumerationItems = await EnumerationCache.ResolveEnumerationItemsAsync(Type);
+            await UpdateTextPropertyAsync(false);
+            StateHasChanged();
+        }
+    }
+}

src/AutSoft.Mud.Blazor/Enumeration/EnumerationDisplay.razor

@@ -0,0 +1,3 @@
+@typeparam TEnum where TEnum : Enum
+@inherits MudComponentBase
+@_displayName

src/AutSoft.Mud.Blazor/Enumeration/EnumerationDisplay.razor.cs

@@ -0,0 +1,44 @@
+using AutSoft.AspNetCore.Blazor.Enumeration;
+
+using Microsoft.AspNetCore.Components;
+
+using MudBlazor;
+
+namespace AutSoft.Mud.Blazor.Enumeration;
+
+/// <summary>
+/// Enumeration display.
+/// </summary>
+/// <typeparam name="TEnum">Collection of the enumeration types.</typeparam>
+public partial class EnumerationDisplay<TEnum> : MudComponentBase where TEnum : Enum
+{
+    /// <summary>
+    /// Enumeration type.
+    /// </summary>
+    [Parameter]
+    public TEnum Type { get; set; } = default!;
+
+    /// <summary>
+    /// Enumeration type id.
+    /// </summary>
+    [Parameter]
+    public int? Id { get; set; }
+
+    [Inject]
+    private IEnumerationCache<TEnum> EnumerationCache { get; set; } = null!;
+
+    private string? _displayName;
+
+    /// <inheritdoc />
+    protected override async Task OnParametersSetAsync()
+    {
+        await base.OnParametersSetAsync();
+
+        if (Type.Equals(default(TEnum)) && Id.HasValue && Id.Value != default)
+            _displayName = await EnumerationCache.ResolveDisplayNameAsync(Type, Id.Value);
+        else
+        {
+            _displayName = null;
+        }
+    }
+}