Core.Thalos.DAL.API/Core.Thalos.Provider/Providers/Onboarding/ModuleProvider.cs

// ***********************************************************************
// <copyright file="ModuleService.cs">
//     AgileWebs
// </copyright>
// ***********************************************************************
using Core.Thalos.Adapters;
using Core.Blueprint.Mongo;
using Core.Blueprint.Redis;
using Core.Blueprint.Redis.Helpers;
using Mapster;
using Microsoft.Extensions.Options;
using MongoDB.Driver;
using Core.Thalos.Provider.Contracts;
using Core.Thalos.Domain.Contexts.Onboarding.Request;

namespace Core.Thalos.Provider.Providers.Onboarding
{
    /// <summary>
    /// Handles all services and business rules related to <see cref="ModuleAdapter"/>.
    /// </summary>
    public class ModuleProvider : IModuleProvider
    {
        private readonly CollectionRepository<ModuleAdapter> repository;
        private readonly CacheSettings cacheSettings;
        private readonly IRedisCacheProvider cacheProvider;

        public ModuleProvider(CollectionRepository<ModuleAdapter> repository,
        IRedisCacheProvider cacheProvider, IOptions<CacheSettings> cacheSettings)
        {
            this.repository = repository;
            this.repository.CollectionInitialization();
            this.cacheSettings = cacheSettings.Value;
            this.cacheProvider = cacheProvider;
        }

        /// <summary>
        /// Creates a new Module.
        /// </summary>
        /// <param name="entity">The Module to be created.</param>
        /// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
        /// the asynchronous execution of the service.</returns>
        public async ValueTask<ModuleAdapter> CreateModule(ModuleRequest newModule, CancellationToken cancellationToken)
        {
            var moduleCollection = newModule.Adapt<ModuleAdapter>();

            await repository.InsertOneAsync(moduleCollection);

            return moduleCollection;
        }

        /// <summary>
        /// Gets an Module by identifier.
        /// </summary>
        /// <param name="id">The Module identifier.</param>
        /// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
        /// the asynchronous execution of the service.</returns>0
        public async ValueTask<ModuleAdapter> GetModuleById(string _id, CancellationToken cancellationToken)
        {
            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetModuleById", _id);
            var cachedData = await cacheProvider.GetAsync<ModuleAdapter>(cacheKey);

            if (cachedData is not null) { return cachedData; }

            var module = await repository.FindByIdAsync(_id);

            await cacheProvider.SetAsync(cacheKey, module);

            return module;
        }

        /// <summary>
        /// Gets all the modules.
        /// </summary>
        /// <returns>A <see cref="{Task{IEnumerbale{ModuleAdapter}}}"/> representing
        /// the asynchronous execution of the service.</returns>
        public async ValueTask<IEnumerable<ModuleAdapter>> GetAllModules(CancellationToken cancellationToken)
        {
            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetModules");
            var cachedData = await cacheProvider.GetAsync<IEnumerable<ModuleAdapter>>(cacheKey) ?? [];

            if (cachedData.Any()) return cachedData;

            var modules = await repository.AsQueryable();

            await cacheProvider.SetAsync(cacheKey, modules);

            return modules;
        }

        /// <summary>
        /// Gets all the modules by modules identifier list.
        /// </summary>
        /// <param name="modules">The list of modules identifiers.</param>
        /// <returns>A <see cref="Task{IEnumerable{ModuleAdapter}}"/> representing
        /// the asynchronous execution of the service.</returns>
        public async ValueTask<IEnumerable<ModuleAdapter>> GetAllModulesByList(string[] modules, CancellationToken cancellationToken)
        {
            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllModulesByList", modules);

            var cachedData = await cacheProvider.GetAsync<IEnumerable<ModuleAdapter>>(cacheKey) ?? [];

            if (cachedData.Any()) return cachedData;

            var builder = Builders<ModuleAdapter>.Filter;
            var filters = new List<FilterDefinition<ModuleAdapter>>();

            if (modules == null || !modules.Any())
            {
                filters.Add(builder.In(x => x.Id, modules));
            }

            var finalFilter = filters.Any() ? builder.And(filters) : builder.Empty;

            var modulesList = await repository.FilterByMongoFilterAsync(finalFilter);

            await cacheProvider.SetAsync(cacheKey, modulesList);

            return modulesList;
        }


        /// <summary>
        /// Changes the status of the module.
        /// </summary>
        /// <param name="id">The module identifier.</param>
        /// <param name="newStatus">The new status of the module.</param>
        /// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
        /// the asynchronous execution of the service.</returns>
        public async ValueTask<ModuleAdapter> ChangeModuleStatus(string id, Core.Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken)
        {
            var entity = await repository.FindByIdAsync(id);
            entity.Status = newStatus;

            await repository.ReplaceOneAsync(entity);

            return entity;
        }

        /// <summary>
        /// Updates a Module by id.
        /// </summary>
        /// <param name="entity">The Module to be updated.</param>
        /// <param name="id">The Module identifier.</param>
        /// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
        /// the asynchronous execution of the service.</returns>
        public async ValueTask<ModuleAdapter> UpdateModule(ModuleAdapter entity, CancellationToken cancellationToken)
        {
            await repository.ReplaceOneAsync(entity);

            return entity;
        }
    }
}