lux/EgwCoreLib.Lux.Data/Services/Production/ProductionItemService.cs

namespace EgwCoreLib.Lux.Data.Services.Production
{
    public class ProductionItemService : BaseServ, IProductionItemService
    {
        #region Public Constructors

        public ProductionItemService(
            IConfiguration config,
            IConnectionMultiplexer redis,
            IProductionItemRepository repo) : base(config, redis)
        {
            _className = "ProdItem";
            _repo = repo;
        }

        #endregion Public Constructors

        #region Public Methods

        /// <inheritdoc />
        public async Task<int> BulkAssignProdBatchAsync(int orderRowId, int prodBatchId)
        {
            return await TraceAsync($"{_className}.BulkAssignProdBatch", async (activity) =>
            {
                var success = await _repo.BulkAssignProdBatchAsync(orderRowId, prodBatchId);

                await FullCacheReset();

                return success;
            });
        }

        /// <inheritdoc />
        public async Task<int> BulkAssignProdGroupAsync(int orderRowId, int prodAssignId, Dictionary<string, double> itemsToAssign)
        {
            return await TraceAsync($"{_className}.BulkAssignProdGroup", async (activity) =>
            {
                var success = await _repo.BulkAssignProdGroupAsync(orderRowId, prodAssignId, itemsToAssign);

                await FullCacheReset();

                return success;
            });
        }

        /// <inheritdoc />
        public async Task<List<ProductionItemModel>> GetByOrderRowAsync(int orderRowId)
        {
            return await TraceAsync($"{_className}.GetByOrderRow", async (activity) =>
            {
                return await GetOrSetCacheAsync(
                    $"{_redisBaseKey}:{_className}:GetByOrderRow:{orderRowId}",
                    async () => await _repo.GetByOrderRowAsync(orderRowId),
                    UltraLongCache
                );
            });
        }

        /// <inheritdoc />
        public async Task<int> ResetAssignAsync(int orderRowID)
        {
            return await TraceAsync($"{_className}.ResetAssign", async (activity) =>
            {
                var success = await _repo.ResetAssignAsync(orderRowID);
                await FullCacheReset();

                return success;
            });
        }

        #endregion Public Methods

        #region Private Fields

        private readonly string _className;

        private readonly IProductionItemRepository _repo;

        #endregion Private Fields

        #region Private Methods

        private async Task FullCacheReset()
        {
            await ClearCacheAsync($"{_redisBaseKey}:{_className}:*");
            await ClearCacheAsync($"{_redisBaseKey}:ProdItems:OrdRowId:*");
            await ClearCacheAsync($"{_redisBaseKey}:ProdGroup:OrdRowId:*");
            await ClearCacheAsync($"{_redisBaseKey}:ProdAssign:OrdRowId:*");
            await ClearCacheAsync($"{_redisBaseKey}:OrderRows:*");
            await ClearCacheAsync($"{_redisBaseKey}:OrderRowsByState:*");
        }

        #endregion Private Methods
    }
}