Add project files.

Core.Cerberos.Provider/Contracts/IModuleService.cs

@@ -0,0 +1,64 @@
+// ***********************************************************************
+// <copyright file="IModuleService.cs">
+//     Heath
+// </copyright>
+// ***********************************************************************
+using Core.Cerberos.Adapters;
+using Core.Cerberos.Adapters.Common.Enums;
+using Core.Cerberos.Domain.Contexts.Onboarding.Request;
+
+namespace Core.Cerberos.Provider.Contracts
+{
+    public interface IModuleService
+    {
+        /// <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>
+        Task<ModuleAdapter> CreateModuleService(ModuleRequest newModule);
+
+        /// <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>
+        Task<ModuleAdapter> GetModuleByIdService(string id);
+
+        /// <summary>
+        /// Gets all the roles.
+        /// </summary>
+        /// <returns>A <see cref="{Task{IEnumerbale{ModuleAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<IEnumerable<ModuleAdapter>> GetAllModulesService();
+
+        /// <summary>
+        /// Gets all the permissions by permissions identifier list.
+        /// </summary>
+        /// <param name="permissions">The list of permissions identifiers.</param>
+        /// <returns>A <see cref="Task{IEnumerable{ModuleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<IEnumerable<ModuleAdapter>> GetAllModulesByListService(string[] permissions);
+
+        /// <summary>
+        /// Changes the status of the permission.
+        /// </summary>
+        /// <param name="id">The permission identifier.</param>
+        /// <param name="newStatus">The new status of the permission.</param>
+        /// <returns>The <see cref="ModuleAdapter"/> updated entity.</returns>
+        /// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<ModuleAdapter> ChangeModuleStatusService(string id, StatusEnum newStatus);
+
+        /// <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>
+        Task<ModuleAdapter> UpdateModuleService(ModuleAdapter entity, string id);
+    }
+}

Core.Cerberos.Provider/Contracts/IPermissionService.cs

@@ -0,0 +1,64 @@
+// ***********************************************************************
+// <copyright file="IPermissionService.cs">
+//     Heath
+// </copyright>
+// ***********************************************************************
+using Core.Cerberos.Adapters;
+using Core.Cerberos.Adapters.Common.Enums;
+using Core.Cerberos.Domain.Contexts.Onboarding.Request;
+
+namespace Core.Cerberos.Provider.Contracts
+{
+    public interface IPermissionService
+    {
+        /// <summary>
+        /// Creates a new Permission.
+        /// </summary>
+        /// <param name="entity">The Permission to be created.</param>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<PermissionAdapter> CreatePermissionService(PermissionRequest newPermission);
+
+        /// <summary>
+        /// Gets an Permission by identifier.
+        /// </summary>
+        /// <param name="id">The Permission identifier.</param>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<PermissionAdapter> GetPermissionByIdService(string id);
+
+        /// <summary>
+        /// Gets all the roles.
+        /// </summary>
+        /// <returns>A <see cref="{Task{IEnumerbale{PermissionAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<IEnumerable<PermissionAdapter>> GetAllPermissionsService();
+
+        /// <summary>
+        /// Gets all the permissions by permissions identifier list.
+        /// </summary>
+        /// <param name="permissions">The list of permissions identifiers.</param>
+        /// <returns>A <see cref="Task{IEnumerable{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<IEnumerable<PermissionAdapter>> GetAllPermissionsByListService(string[] permissions);
+
+        /// <summary>
+        /// Changes the status of the permission.
+        /// </summary>
+        /// <param name="id">The permission identifier.</param>
+        /// <param name="newStatus">The new status of the permission.</param>
+        /// <returns>The <see cref="PermissionAdapter"/> updated entity.</returns>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<PermissionAdapter> ChangePermissionStatusService(string id, StatusEnum newStatus);
+
+        /// <summary>
+        /// Updates a Permission by id.
+        /// </summary>
+        /// <param name="entity">The Permission to be updated.</param>
+        /// <param name="id">The Permission identifier.</param>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<PermissionAdapter> UpdatePermissionService(PermissionAdapter entity, string id);
+    }
+}

Core.Cerberos.Provider/Contracts/IRoleService.cs

@@ -0,0 +1,72 @@
+// ***********************************************************************
+// <copyright file="IRoleService.cs">
+//     Heath
+// </copyright>
+// ***********************************************************************
+using Core.Cerberos.Adapters;
+using Core.Cerberos.Adapters.Common.Enums;
+using Core.Cerberos.Domain.Contexts.Onboarding.Request;
+
+namespace Core.Cerberos.Provider.Contracts
+{
+    public interface IRoleService
+    {
+        /// <summary>
+        /// Creates a new Role.
+        /// </summary>
+        /// <param name="entity">The Role to be created.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<RoleAdapter> CreateRoleService(RoleRequest newRole);
+
+        /// <summary>
+        /// Gets an Role by identifier.
+        /// </summary>
+        /// <param name="id">The Role identifier.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<RoleAdapter> GetRoleByIdService(string id);
+
+        /// <summary>
+        /// Gets all the roles.
+        /// </summary>
+        /// <returns>A <see cref="{Task{IEnumerbale{RoleAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<IEnumerable<RoleAdapter>> GetAllRolesService();
+
+        /// <summary>
+        /// Changes the status of the role.
+        /// </summary>
+        /// <param name="id">The role identifier.</param>
+        /// <param name="newStatus">The new status of the role.</param>
+        /// <returns>The <see cref="RoleAdapter"/> updated entity.</returns>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<RoleAdapter> ChangeRoleStatusService(string id, StatusEnum newStatus);
+
+        /// <summary>
+        /// Updates a Role by id.
+        /// </summary>
+        /// <param name="entity">The Role to be updated.</param>
+        /// <param name="id">The Role identifier.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<RoleAdapter> UpdateRoleService(RoleAdapter entity, string id);
+
+        /// <summary>
+        /// Adds an application to the role's list of applications.
+        /// </summary>
+        /// <param name="roleId">The identifier of the role to which the application will be added.</param>
+        /// <param name="application">The application enum value to add.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</returns>
+        Task<RoleAdapter> AddApplicationToRoleService(string roleId, ApplicationsEnum application);
+
+        /// <summary>
+        /// Removes an application from the role's list of applications.
+        /// </summary>
+        /// <param name="roleId">The identifier of the role from which the application will be removed.</param>
+        /// <param name="application">The application enum value to remove.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</returns>
+        Task<RoleAdapter> RemoveApplicationFromRoleService(string roleId, ApplicationsEnum application);
+    }
+}

Core.Cerberos.Provider/Contracts/IUserService.cs

@@ -0,0 +1,143 @@
+// ***********************************************************************
+// <copyright file="IUserService.cs">
+//     Heath
+// </copyright>
+// ***********************************************************************
+using Core.Blueprint.Storage.Adapters;
+using Core.Cerberos.Adapters;
+using Core.Cerberos.Adapters.Common.Enums;
+using Core.Cerberos.Domain.Contexts.Onboarding.Request;
+
+namespace Core.Cerberos.Provider.Contracts
+{
+    public interface IUserService
+    {
+        /// <summary>
+        /// Creates a new User.
+        /// </summary>
+        /// <param name="entity">The User to be created.</param>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<UserAdapter> CreateUserService(UserRequest newUser);
+
+        /// <summary>
+        /// Gets an User by identifier.
+        /// </summary>
+        /// <param name="id">The User identifier.</param>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<UserAdapter> GetUserByIdService(string id);
+
+
+        /// <summary>
+        /// Gets all the users.
+        /// </summary>
+        /// <returns>A <see cref="{Task{IEnumerable{UserAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<IEnumerable<UserAdapter>> GetAllUsersService();
+
+        /// <summary>
+        /// Gets an User by email.
+        /// </summary>
+        /// <param name="email">The User email.</param>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<UserAdapter> GetUserByEmailService(string? email);
+
+        /// <summary>
+        /// Validates if a users exists by email.
+        /// </summary>
+        /// <param name="eamil">The User email.</param>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<UserAdapter> ValidateUserExistenceService(string? email);
+
+        /// <summary>
+        /// Changes the status of the user.
+        /// </summary>
+        /// <param name="id">The user identifier.</param>
+        /// <param name="newStatus">The new status of the user.</param>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<UserAdapter> ChangeUserStatusService(string id, StatusEnum newStatus);
+
+        /// <summary>
+        /// Updates a User by id.
+        /// </summary>
+        /// <param name="entity">The User to be updated.</param>
+        /// <param name="id">The User identifier.</param>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<UserAdapter> UpdateUserService(UserAdapter entity, string id);
+
+        /// <summary>
+        /// Logs in the user.
+        /// </summary>
+        /// <param name="email">The User's email.</param>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<UserAdapter?> LogInUserService(string email);
+
+        /// <summary>
+        /// Logs out the user's session.
+        /// </summary>
+        /// <param name="email">The User's email.</param>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<UserAdapter> LogOutUserSessionService(string email);
+
+        /// <summary>
+        /// Adds a company to the user's list of companies.
+        /// </summary>
+        /// <param name="userId">The identifier of the user to whom the company will be added.</param>
+        /// <param name="companyId">The identifier of the company to add.</param>
+        /// <returns>A <see cref="Task{UserAdapter}"/> representing the asynchronous operation, with the updated user object.</returns>
+        Task<UserAdapter> AddCompanyToUserService(string userId, string companyId);
+
+        /// <summary>
+        /// Removes a company from the user's list of companies.
+        /// </summary>
+        /// <param name="userId">The identifier of the user from whom the company will be removed.</param>
+        /// <param name="companyId">The identifier of the company to remove.</param>
+        /// <returns>A <see cref="Task{UserAdapter}"/> representing the asynchronous operation, with the updated user object.</returns>
+        Task<UserAdapter> RemoveCompanyFromUserService(string userId, string companyId);
+
+        /// <summary>
+        /// Adds a project to the user's list of projects.
+        /// </summary>
+        /// <param name="userId">The identifier of the user to whom the project will be added.</param>
+        /// <param name="projectId">The identifier of the project to add.</param>
+        /// <returns>A <see cref="Task{UserAdapter}"/> representing the asynchronous operation, with the updated user object.</returns>
+        Task<UserAdapter> AddProjectToUserService(string userId, string projectId);
+
+
+        /// <summary>
+        /// Removes a project from the user's list of projects.
+        /// </summary>
+        /// <param name="userId">The identifier of the user from whom the project will be removed.</param>
+        /// <param name="projectId">The identifier of the project to remove.</param>
+        /// <returns>A <see cref="Task{UserAdapter}"/> representing the asynchronous operation, with the updated user object.</returns>
+        Task<UserAdapter> RemoveProjectFromUserService(string userId, string projectId);
+
+        /// <summary>
+        /// Gets the token adapter for a user.
+        /// </summary>
+        /// <param name="email">The user's email.</param>
+        /// <returns>A <see cref="{Task{TokenAdapter}}"/> representing the asynchronous execution of the service.</returns>
+        Task<TokenAdapter?> GetTokenAdapter(string email);
+
+        /// <summary>
+        /// Get Consent Form PDF.
+        /// </summary>
+        /// <returns>A <see cref="{Task{BlobDownloadUriAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<BlobDownloadUriAdapter> GetConsentFormPDFService();
+
+        /// <summary>
+        /// Accept user consent form.
+        /// </summary>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        Task<UserAdapter?> AcceptUserConsentFormService();
+    }
+}

Core.Cerberos.Provider/Core.Cerberos.Provider.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Providers\Onboarding\UserService - Copy.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Core.Blueprint.Storage" Version="0.3.0-alpha0049" />
+    <PackageReference Include="Core.Cerberos.Adapters" Version="0.3.0-alpha0042" />
+    <PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" Version="2.2.0" />
+    <PackageReference Include="MongoDB.Driver" Version="3.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Core.Cerberos.Domain\Core.Cerberos.Domain.csproj" />
+    <ProjectReference Include="..\Core.Cerberos.Infraestructure\Core.Cerberos.Infrastructure.csproj" />
+  </ItemGroup>
+
+</Project>

Core.Cerberos.Provider/Providers/BaseProvider.cs

@@ -0,0 +1,16 @@
+using MongoDB.Driver;
+
+namespace Core.Cerberos.Provider.Providers
+{
+    public class BaseProvider
+    {
+        private readonly IMongoDatabase _database;
+
+        public BaseProvider(IMongoDatabase database)
+        {
+            _database = database ?? throw new ArgumentNullException(nameof(database));
+        }
+
+        protected IMongoDatabase Database => _database;
+    }
+}

Core.Cerberos.Provider/Providers/HeathOidcCallback.cs

@@ -0,0 +1,99 @@
+using Azure.Core;
+using Azure.Identity;
+using Core.Cerberos.Adapters.Common.Constants;
+using MongoDB.Driver.Authentication.Oidc;
+
+namespace Core.Cerberos.Provider.Providers
+{
+    public class HeathOidcCallback : IOidcCallback
+    {
+        private readonly string _audience;
+        private readonly string _environment;
+        public HeathOidcCallback(string audience)
+        {
+            _audience = audience;
+            _environment = Environment.GetEnvironmentVariable(EnvironmentVariables.Stage) ?? string.Empty;
+        }
+
+        public OidcAccessToken GetOidcAccessToken(OidcCallbackParameters parameters, CancellationToken cancellationToken)
+        {
+            try
+            {
+                AccessToken token;
+
+                TokenRequestContext tokenRequestContext =
+                    new TokenRequestContext(
+                        new[] { _audience }
+                    );
+
+                if (_environment == "Local")
+                {
+                    token =
+                    new ChainedTokenCredential(
+                        new ManagedIdentityCredential(),
+                        new VisualStudioCredential(),
+                        new VisualStudioCodeCredential(),
+                        new SharedTokenCacheCredential()
+                    )
+                    .GetToken(
+                        tokenRequestContext
+                    );
+                }
+                else
+                {
+                    token =
+                    new ManagedIdentityCredential()
+                    .GetToken(
+                        tokenRequestContext
+                    );
+                }
+
+                return new(token.Token, expiresIn: null);
+            }
+            catch (Exception ex)
+            {
+
+                throw new Exception($"An error ocurred while trying to get the OIDC token to connect to the database, ERROR: {ex.Message}");
+            }
+        }
+
+        public async Task<OidcAccessToken> GetOidcAccessTokenAsync(OidcCallbackParameters parameters, CancellationToken cancellationToken)
+        {
+            try
+            {
+                TokenRequestContext tokenRequestContext =
+                    new TokenRequestContext(
+                        new[] { _audience }
+                    );
+
+                AccessToken token;
+
+                if (_environment == "Local")
+                {
+                    token = await new ChainedTokenCredential(
+                        new ManagedIdentityCredential(),
+                        new VisualStudioCredential(),
+                        new VisualStudioCodeCredential(),
+                        new SharedTokenCacheCredential()
+                    )
+                    .GetTokenAsync(
+                        tokenRequestContext, cancellationToken
+                    ).ConfigureAwait(false);
+                }
+                else
+                {
+                    token = await new ManagedIdentityCredential()
+                    .GetTokenAsync(
+                        tokenRequestContext, cancellationToken
+                    ).ConfigureAwait(false);
+                }
+
+                return new(token.Token, expiresIn: null);
+            }
+            catch (Exception ex)
+            {
+                throw new Exception($"An error ocurred while trying to get the OIDC token to connect to the database, ERROR: {ex.Message}");
+            }
+        }
+    }
+}

Core.Cerberos.Provider/Providers/Helper.cs

@@ -0,0 +1,27 @@
+// ***********************************************************************
+// <copyright file="Helper.cs">
+//     Heath
+// </copyright>
+// ***********************************************************************
+
+using Microsoft.AspNetCore.Http;
+using System.Security.Claims;
+
+namespace Core.Cerberos.Provider.Providers
+{
+    /// <summary>
+    /// Provides helper methods for common operations.
+    /// </summary>
+    public static class Helper
+    {
+        /// <summary>
+        /// Retrieves the email address of the authenticated user from the HTTP context.
+        /// </summary>
+        /// <param name="httpContextAccessor">The IHttpContextAccessor instance to access the current HTTP context.</param>
+        /// <returns>The email address of the authenticated user, or an empty string if not available.</returns>
+        public static string GetEmail(IHttpContextAccessor httpContextAccessor)
+        {
+            return httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.Email)?.Value ?? "";
+        }
+    }
+}

Core.Cerberos.Provider/Providers/Onboarding/ModuleService.cs

@@ -0,0 +1,256 @@
+// ***********************************************************************
+// <copyright file="ModuleService.cs">
+//     Heath
+// </copyright>
+// ***********************************************************************
+using Core.Cerberos.Adapters;
+using Core.Cerberos.Adapters.Common.Constants;
+using Core.Cerberos.Adapters.Common.Enums;
+using Core.Cerberos.Domain.Contexts.Onboarding.Mappers;
+using Core.Cerberos.Domain.Contexts.Onboarding.Request;
+using Core.Cerberos.Infraestructure.Caching.Configs;
+using Core.Cerberos.Infraestructure.Caching.Contracts;
+using Core.Cerberos.Provider.Contracts;
+using LSA.Core.Dapper.Service.Caching;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using MongoDB.Bson;
+using MongoDB.Driver;
+
+namespace Core.Cerberos.Provider.Providers.Onboarding
+{
+    /// <summary>
+    /// Handles all services and business rules related to <see cref="ModuleAdapter"/>.
+    /// </summary>
+    public class ModuleService(ILogger<ModuleService> logger, IHttpContextAccessor httpContextAccessor, ICacheService cacheService,
+        IOptions<CacheSettings> cacheSettings, IMongoDatabase database) : IModuleService
+    {
+        private readonly CacheSettings _cacheSettings = cacheSettings.Value;
+
+        /// <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 Task<ModuleAdapter> CreateModuleService(ModuleRequest newModule)
+        {
+            try
+            {
+                var entity = newModule.ToAdapter(httpContextAccessor);
+                entity.Order = (entity.Order is not null) ? entity.Order : await GetLastOrderModule(newModule);
+                await database.GetCollection<ModuleAdapter>(CollectionNames.Module).InsertOneAsync(entity);
+                entity.Id = (entity as dynamic ?? "").Id.ToString();
+
+                return entity;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"CreateModuleService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <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 Task<ModuleAdapter> GetModuleByIdService(string id)
+        {
+            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetModuleByIdService", id);
+            var cachedData = await cacheService.GetAsync<ModuleAdapter>(cacheKey);
+
+            if (cachedData is not null) { return cachedData; }
+
+            try
+            {
+                var filter = Builders<ModuleAdapter>.Filter.And(
+                    Builders<ModuleAdapter>.Filter.Eq("_id", ObjectId.Parse(id)),
+                    Builders<ModuleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString())
+                );
+
+                var module = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
+                                    .Find(filter)
+                                    .FirstOrDefaultAsync();
+
+                var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
+
+                await cacheService.SetAsync(cacheKey, module, cacheDuration);
+
+                return module;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"GetModuleByIdService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets all the modules.
+        /// </summary>
+        /// <returns>A <see cref="{Task{IEnumerbale{ModuleAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        public async Task<IEnumerable<ModuleAdapter>> GetAllModulesService()
+        {
+            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllModulesService");
+            var cachedData = await cacheService.GetAsync<IEnumerable<ModuleAdapter>>(cacheKey) ?? [];
+
+            if (cachedData.Any()) return cachedData;
+
+            try
+            {
+                var filter = Builders<ModuleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString());
+
+                var roles = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
+                                    .Find(filter)
+                                    .SortBy(m => m.Application)
+                                    .ThenBy(m => m.Order)
+                                    .ToListAsync();
+
+                var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
+
+                await cacheService.SetAsync(cacheKey, roles, cacheDuration);
+
+                return roles;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"GetAllModulesService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <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 Task<IEnumerable<ModuleAdapter>> GetAllModulesByListService(string[] modules)
+        {
+            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllModulesByListService", modules);
+
+            var cachedData = await cacheService.GetAsync<IEnumerable<ModuleAdapter>>(cacheKey);
+
+            if (cachedData != null && cachedData.Any()) return cachedData;
+
+            try
+            {
+                var objectIds = modules.Select(id => ObjectId.Parse(id)).ToArray();
+
+                var filter = Builders<ModuleAdapter>.Filter.In("_id", objectIds)
+                                & Builders<ModuleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString());
+
+                var roles = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
+                                          .Find(filter)
+                                          .SortBy(m => m.Application)
+                                          .ThenBy(m => m.Order)
+                                          .ToListAsync();
+
+                var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
+
+                await cacheService.SetAsync(cacheKey, roles, cacheDuration);
+
+                return roles;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"GetAllModulesByListService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+
+        /// <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 Task<ModuleAdapter> ChangeModuleStatusService(string id, StatusEnum newStatus)
+        {
+            try
+            {
+                var filter = Builders<ModuleAdapter>.Filter
+                    .Eq("_id", ObjectId.Parse(id));
+
+                var update = Builders<ModuleAdapter>.Update
+                            .Set(v => v.Status, newStatus)
+                            .Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
+                            .Set(v => v.UpdatedAt, DateTime.UtcNow);
+
+                await database.GetCollection<ModuleAdapter>(CollectionNames.Module).UpdateOneAsync(filter, update);
+
+                var updatedModule = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
+                                    .Find(filter)
+                                    .FirstOrDefaultAsync();
+
+                return updatedModule;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"ChangeModuleStatusService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <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 Task<ModuleAdapter> UpdateModuleService(ModuleAdapter entity, string id)
+        {
+            try
+            {
+                var filter = Builders<ModuleAdapter>.Filter
+                    .Eq("_id", ObjectId.Parse(id));
+
+                var update = Builders<ModuleAdapter>.Update
+                            .Set(v => v.Name, entity.Name)
+                            .Set(v => v.Description, entity.Description)
+                            .Set(v => v.Icon, entity.Icon)
+                            .Set(v => v.Route, entity.Route)
+                            .Set(v => v.Order, entity.Order)
+                            .Set(v => v.Application, entity.Application)
+                            .Set(v => v.Status, entity.Status)
+                            .Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
+                            .Set(v => v.UpdatedAt, DateTime.UtcNow);
+
+                await database.GetCollection<ModuleAdapter>(CollectionNames.Module).UpdateOneAsync(filter, update);
+
+                var updatedModule = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
+                                            .Find(filter)
+                                            .FirstOrDefaultAsync();
+
+                return updatedModule;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"UpdateModuleService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        private async Task<int?> GetLastOrderModule(ModuleRequest newModule)
+        {
+            var filter = Builders<ModuleAdapter>.Filter.And(
+                Builders<ModuleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString()),
+                Builders<ModuleAdapter>.Filter.Eq("application", newModule.Application.ToString()));
+
+            var maxOrderModule = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
+                                               .Find(filter)
+                                               .SortByDescending(m => m.Order)
+                                               .FirstOrDefaultAsync();
+
+            return (maxOrderModule is not null && maxOrderModule.Order is not null) ? maxOrderModule.Order : 0;
+        }
+    }
+}

Core.Cerberos.Provider/Providers/Onboarding/PermissionService.cs

@@ -0,0 +1,234 @@
+// ***********************************************************************
+// <copyright file="PermissionService.cs">
+//     Heath
+// </copyright>
+// ***********************************************************************
+using Core.Cerberos.Adapters;
+using Core.Cerberos.Adapters.Common.Constants;
+using Core.Cerberos.Adapters.Common.Enums;
+using Core.Cerberos.Domain.Contexts.Onboarding.Mappers;
+using Core.Cerberos.Domain.Contexts.Onboarding.Request;
+using Core.Cerberos.Infraestructure.Caching.Configs;
+using Core.Cerberos.Infraestructure.Caching.Contracts;
+using Core.Cerberos.Provider.Contracts;
+using LSA.Core.Dapper.Service.Caching;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using MongoDB.Bson;
+using MongoDB.Driver;
+
+namespace Core.Cerberos.Provider.Providers.Onboarding
+{
+    /// <summary>
+    /// Handles all services and business rules related to <see cref="PermissionAdapter"/>.
+    /// </summary>
+    public class PermissionService(ILogger<PermissionService> logger, IHttpContextAccessor httpContextAccessor, ICacheService cacheService,
+        IOptions<CacheSettings> cacheSettings, IMongoDatabase database) : IPermissionService
+    {
+        private readonly CacheSettings _cacheSettings = cacheSettings.Value;
+
+        /// <summary>
+        /// Creates a new Permission.
+        /// </summary>
+        /// <param name="entity">The Permission to be created.</param>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        public async Task<PermissionAdapter> CreatePermissionService(PermissionRequest newPermission)
+        {
+            try
+            {
+                var entity = newPermission.ToAdapter(httpContextAccessor);
+                await database.GetCollection<PermissionAdapter>(CollectionNames.Permission).InsertOneAsync(entity);
+                entity.Id = (entity as dynamic ?? "").Id.ToString();
+
+                return entity;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"CreatePermissionService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets an Permission by identifier.
+        /// </summary>
+        /// <param name="id">The Permission identifier.</param>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>0
+        public async Task<PermissionAdapter> GetPermissionByIdService(string id)
+        {
+            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetPermissionByIdService", id);
+            var cachedData = await cacheService.GetAsync<PermissionAdapter>(cacheKey);
+
+            if (cachedData is not null) { return cachedData; }
+
+            try
+            {
+                var filter = Builders<PermissionAdapter>.Filter.And(
+                    Builders<PermissionAdapter>.Filter.Eq("_id", ObjectId.Parse(id)),
+                    Builders<PermissionAdapter>.Filter.Eq("status", StatusEnum.Active.ToString())
+                );
+
+                var permission = await database.GetCollection<PermissionAdapter>(CollectionNames.Permission)
+                                    .Find(filter)
+                                    .FirstOrDefaultAsync();
+
+                var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
+
+                await cacheService.SetAsync(cacheKey, permission, cacheDuration);
+
+                return permission;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"GetPermissionByIdService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets all the permissions.
+        /// </summary>
+        /// <returns>A <see cref="{Task{IEnumerbale{PermissionAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        public async Task<IEnumerable<PermissionAdapter>> GetAllPermissionsService()
+        {
+            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllPermissionsService");
+            var cachedData = await cacheService.GetAsync<IEnumerable<PermissionAdapter>>(cacheKey) ?? [];
+
+            if (cachedData.Any()) return cachedData;
+
+            try
+            {
+                var filter = Builders<PermissionAdapter>.Filter.Eq("status", StatusEnum.Active.ToString());
+
+                var roles = await database.GetCollection<PermissionAdapter>(CollectionNames.Permission)
+                                    .Find(filter)
+                                    .ToListAsync();
+
+                var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
+
+                await cacheService.SetAsync(cacheKey, roles, cacheDuration);
+
+                return roles;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"GetAllPermissionsService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets all the permissions by permissions identifier list.
+        /// </summary>
+        /// <param name="permissions">The list of permissions identifiers.</param>
+        /// <returns>A <see cref="Task{IEnumerable{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        public async Task<IEnumerable<PermissionAdapter>> GetAllPermissionsByListService(string[] permissions)
+        {
+            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllPermissionsByListService", permissions);
+
+            var cachedData = await cacheService.GetAsync<IEnumerable<PermissionAdapter>>(cacheKey);
+
+            if (cachedData != null && cachedData.Any()) return cachedData;
+
+            try
+            {
+                var objectIds = permissions.Select(id => ObjectId.Parse(id)).ToArray();
+
+                var filter = Builders<PermissionAdapter>.Filter.In("_id", objectIds)
+                                & Builders<PermissionAdapter>.Filter.Eq("status", StatusEnum.Active.ToString());
+
+                var roles = await database.GetCollection<PermissionAdapter>(CollectionNames.Permission)
+                                          .Find(filter)
+                                          .ToListAsync();
+
+                var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
+
+                await cacheService.SetAsync(cacheKey, roles, cacheDuration);
+
+                return roles;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"GetAllPermissionsByListService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+
+        /// <summary>
+        /// Changes the status of the permission.
+        /// </summary>
+        /// <param name="id">The permission identifier.</param>
+        /// <param name="newStatus">The new status of the permission.</param>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        public async Task<PermissionAdapter> ChangePermissionStatusService(string id, StatusEnum newStatus)
+        {
+            try
+            {
+                var filter = Builders<PermissionAdapter>.Filter
+                    .Eq("_id", ObjectId.Parse(id));
+
+                var update = Builders<PermissionAdapter>.Update
+                            .Set(v => v.Status, newStatus)
+                            .Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
+                            .Set(v => v.UpdatedAt, DateTime.UtcNow);
+
+                await database.GetCollection<PermissionAdapter>(CollectionNames.Permission).UpdateOneAsync(filter, update);
+
+                var updatedPermission = await database.GetCollection<PermissionAdapter>(CollectionNames.Permission)
+                                    .Find(filter)
+                                    .FirstOrDefaultAsync();
+
+                return updatedPermission;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"ChangePermissionStatusService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <summary>
+        /// Updates a Permission by id.
+        /// </summary>
+        /// <param name="entity">The Permission to be updated.</param>
+        /// <param name="id">The Permission identifier.</param>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        public async Task<PermissionAdapter> UpdatePermissionService(PermissionAdapter entity, string id)
+        {
+            try
+            {
+                var filter = Builders<PermissionAdapter>.Filter
+                    .Eq("_id", ObjectId.Parse(id));
+
+                var update = Builders<PermissionAdapter>.Update
+                            .Set(v => v.Name, entity.Name)
+                            .Set(v => v.Description, entity.Description)
+                            .Set(v => v.AccessLevel, entity.AccessLevel)
+                            .Set(v => v.Status, entity.Status)
+                            .Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
+                            .Set(v => v.UpdatedAt, DateTime.UtcNow);
+
+                await database.GetCollection<PermissionAdapter>(CollectionNames.Permission).UpdateOneAsync(filter, update);
+
+                var updatedPermission = await database.GetCollection<PermissionAdapter>(CollectionNames.Permission)
+                                            .Find(filter)
+                                            .FirstOrDefaultAsync();
+
+                return updatedPermission;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"UpdatePermissionService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+    }
+}

Core.Cerberos.Provider/Providers/Onboarding/RoleService.cs

@@ -0,0 +1,251 @@
+// ***********************************************************************
+// <copyright file="RoleService.cs">
+//     Heath
+// </copyright>
+// ***********************************************************************
+using Core.Cerberos.Adapters;
+using Core.Cerberos.Adapters.Common.Constants;
+using Core.Cerberos.Adapters.Common.Enums;
+using Core.Cerberos.Domain.Contexts.Onboarding.Mappers;
+using Core.Cerberos.Domain.Contexts.Onboarding.Request;
+using Core.Cerberos.Infraestructure.Caching.Configs;
+using Core.Cerberos.Infraestructure.Caching.Contracts;
+using Core.Cerberos.Provider.Contracts;
+using LSA.Core.Dapper.Service.Caching;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using MongoDB.Bson;
+using MongoDB.Driver;
+
+namespace Core.Cerberos.Provider.Providers.Onboarding
+{
+    /// <summary>
+    /// Handles all services and business rules related to <see cref="RoleAdapter"/>.
+    /// </summary>
+    public class RoleService(ILogger<RoleService> logger, IHttpContextAccessor httpContextAccessor, ICacheService cacheService,
+        IOptions<CacheSettings> cacheSettings, IMongoDatabase database) : IRoleService
+    {
+        private readonly CacheSettings _cacheSettings = cacheSettings.Value;
+
+        /// <summary>
+        /// Creates a new Role.
+        /// </summary>
+        /// <param name="entity">The Role to be created.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        public async Task<RoleAdapter> CreateRoleService(RoleRequest newRole)
+        {
+            try
+            {
+                var entity = newRole.ToAdapter(httpContextAccessor);
+                await database.GetCollection<RoleAdapter>(CollectionNames.Role).InsertOneAsync(entity);
+                entity.Id = (entity as dynamic ?? "").Id.ToString();
+
+                return entity;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"CreateRoleService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets an Role by identifier.
+        /// </summary>
+        /// <param name="id">The Role identifier.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        public async Task<RoleAdapter> GetRoleByIdService(string id)
+        {
+            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetRoleByIdService", id);
+            var cachedData = await cacheService.GetAsync<RoleAdapter>(cacheKey);
+
+            if (cachedData is not null) { return cachedData; }
+            try
+            {
+                var filter = Builders<RoleAdapter>.Filter.And(
+                        Builders<RoleAdapter>.Filter.Eq("_id", ObjectId.Parse(id)),
+                        Builders<RoleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString())
+                    );
+
+                var role = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
+                .Find(filter)
+                            .FirstOrDefaultAsync();
+
+                var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
+
+                await cacheService.SetAsync(cacheKey, role, cacheDuration);
+
+                return role;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"GetRoleByIdService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <summary>
+        /// Gets all the roles.
+        /// </summary>
+        /// <returns>A <see cref="{Task{IEnumerbale{RoleAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        public async Task<IEnumerable<RoleAdapter>> GetAllRolesService()
+        {
+            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllRolesService");
+            var cachedData = await cacheService.GetAsync<IEnumerable<RoleAdapter>>(cacheKey) ?? [];
+
+            if (cachedData.Any()) return cachedData;
+            try
+            {
+                var filter = Builders<RoleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString());
+
+                var roles = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
+                                .Find(filter)
+                                .ToListAsync();
+
+                var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
+
+                await cacheService.SetAsync(cacheKey, roles, cacheDuration);
+
+                return roles;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"GetAllRolesService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <summary>
+        /// Changes the status of the role.
+        /// </summary>
+        /// <param name="id">The role identifier.</param>
+        /// <param name="newStatus">The new status of the role.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        public async Task<RoleAdapter> ChangeRoleStatusService(string id, StatusEnum newStatus)
+        {
+            try
+            {
+                var filter = Builders<RoleAdapter>.Filter
+                    .Eq("_id", ObjectId.Parse(id));
+
+                var update = Builders<RoleAdapter>.Update
+                            .Set(v => v.Status, newStatus)
+                            .Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
+                            .Set(v => v.UpdatedAt, DateTime.UtcNow);
+
+                await database.GetCollection<RoleAdapter>(CollectionNames.Role).UpdateOneAsync(filter, update);
+
+                var updatedRole = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
+                                    .Find(filter)
+                                    .FirstOrDefaultAsync();
+
+                return updatedRole;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"ChangeRoleStatusService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+
+        /// <summary>
+        /// Updates a Role by id.
+        /// </summary>
+        /// <param name="entity">The Role to be updated.</param>
+        /// <param name="id">The Role identifier.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        public async Task<RoleAdapter> UpdateRoleService(RoleAdapter entity, string id)
+        {
+            try
+            {
+                var filter = Builders<RoleAdapter>.Filter
+                    .Eq("_id", ObjectId.Parse(id));
+
+                var update = Builders<RoleAdapter>.Update
+                            .Set(v => v.Name, entity.Name)
+                            .Set(v => v.Description, entity.Description)
+                            .Set(v => v.Applications, entity.Applications)
+                            .Set(v => v.Modules, entity.Modules)
+                            .Set(v => v.Permissions, entity.Permissions)
+                            .Set(v => v.Status, entity.Status)
+                            .Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
+                            .Set(v => v.UpdatedAt, DateTime.UtcNow);
+
+                await database.GetCollection<RoleAdapter>(CollectionNames.Role).UpdateOneAsync(filter, update);
+
+                var updatedRole = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
+                                    .Find(filter)
+                                    .FirstOrDefaultAsync();
+
+                return updatedRole;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"UpdateRoleService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+
+        }
+
+        /// <summary>
+        /// Adds an application to the role's list of applications.
+        /// </summary>
+        /// <param name="roleId">The identifier of the role to which the application will be added.</param>
+        /// <param name="application">The application enum value to add.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</returns>
+        public async Task<RoleAdapter> AddApplicationToRoleService(string roleId, ApplicationsEnum application)
+        {
+            try
+            {
+                var filter = Builders<RoleAdapter>.Filter.Eq("_id", ObjectId.Parse(roleId));
+                var update = Builders<RoleAdapter>.Update.AddToSet(r => r.Applications, application);
+
+                await database.GetCollection<RoleAdapter>(CollectionNames.Role).UpdateOneAsync(filter, update);
+
+                var updatedRole = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
+                                    .Find(filter)
+                                    .FirstOrDefaultAsync();
+                return updatedRole;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"AddApplicationToRoleService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+
+        }
+
+        /// <summary>
+        /// Removes an application from the role's list of applications.
+        /// </summary>
+        /// <param name="roleId">The identifier of the role from which the application will be removed.</param>
+        /// <param name="application">The application enum value to remove.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</returns>
+        public async Task<RoleAdapter> RemoveApplicationFromRoleService(string roleId, ApplicationsEnum application)
+        {
+            try
+            {
+                var filter = Builders<RoleAdapter>.Filter.Eq("_id", ObjectId.Parse(roleId));
+                var update = Builders<RoleAdapter>.Update.Pull(r => r.Applications, application);
+
+                await database.GetCollection<RoleAdapter>(CollectionNames.Role).UpdateOneAsync(filter, update);
+
+                var updatedRole = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
+                                    .Find(filter)
+                                    .FirstOrDefaultAsync();
+                return updatedRole;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"RemoveApplicationFromRoleService: Error in getting data - {ex.Message}");
+                throw new Exception(ex.Message, ex);
+            }
+        }
+    }
+}

Core.Cerberos.Provider/ServiceCollectionExtensions.cs

@@ -0,0 +1,104 @@
+using Core.Blueprint.Storage.Configuration;
+using Core.Cerberos.Infraestructure.Caching.Contracts;
+using Core.Cerberos.Infraestructure.Contexts.Mongo;
+using Core.Cerberos.Provider.Contracts;
+using Core.Cerberos.Provider.Providers;
+using Core.Cerberos.Provider.Providers.Onboarding;
+using LSA.Core.Dapper.Service.Caching;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using MongoDB.Driver;
+
+namespace Core.Cerberos.Provider
+{
+    public static class ServiceCollectionExtensions
+    {
+        public static IServiceCollection AddDALLayer(this IServiceCollection services, IConfiguration configuration)
+        {
+            var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? string.Empty;
+
+            var connectionString = configuration.GetSection("ConnectionStrings:MongoDB").Value ?? string.Empty;
+            var databaseName = configuration.GetSection("MongoDB:DatabaseName").Value ?? string.Empty;
+            var audience = (environment == "Local")
+                ? configuration.GetSection("MongoDB:LocalAudience").Value
+                : configuration.GetSection("MongoDB:Audience").Value;
+
+            if (string.IsNullOrEmpty(connectionString) || string.IsNullOrEmpty(databaseName) || string.IsNullOrEmpty(audience))
+            {
+                throw new InvalidOperationException("Mongo connection is not configured correctly.");
+            }
+
+            services.Configure<MongoConnSettings>(options =>
+            {
+                options.ConnectionString = connectionString;
+                options.Databasename = databaseName;
+                options.Audience = audience ?? string.Empty;
+            });
+
+            services.AddSingleton<IMongoClient>(serviceProvider =>
+            {
+                var settings = serviceProvider.GetRequiredService<IOptions<MongoConnSettings>>().Value;
+                var mongoClientSettings = MongoClientSettings.FromConnectionString(settings.ConnectionString);
+                mongoClientSettings.Credential = MongoCredential.CreateOidcCredential(new HeathOidcCallback(settings.Audience));
+                return new MongoClient(mongoClientSettings);
+            });
+
+            services.AddSingleton<IMongoDatabase>(serviceProvider =>
+            {
+                var settings = serviceProvider.GetRequiredService<IOptions<MongoConnSettings>>().Value;
+                var client = serviceProvider.GetRequiredService<IMongoClient>();
+                return client.GetDatabase(settings.Databasename);
+            });
+
+            services.AddDALConfigurationLayer();
+            services.AddLogs();
+            services.AddRedisCacheService(configuration);
+            services.AddBlobStorage(configuration);
+
+            return services;
+        }
+
+
+        private static IServiceCollection AddDALConfigurationLayer(this IServiceCollection services)
+        {
+            services.AddHttpContextAccessor();
+
+            services.AddScoped<IUserService, UserService>();
+            services.AddScoped<IRoleService, RoleService>();
+            services.AddScoped<IPermissionService, PermissionService>();
+            services.AddScoped<IPermissionService, PermissionService>();
+            services.AddScoped<IModuleService, ModuleService>();
+            return services;
+        }
+
+        private static IServiceCollection AddLogs(this IServiceCollection services)
+        {
+            services.AddLogging();
+            var serviceProvider = services.BuildServiceProvider();
+            //var logger = serviceProvider.GetService<ILogger<DashboardDALService>>(); //Add for Markup class later TODO
+
+            //services.AddSingleton(typeof(ILogger), logger);
+
+            return services;
+        }
+
+        private static IServiceCollection AddRedisCacheService(this IServiceCollection services, IConfiguration configuration)
+        {
+            var source = configuration.GetSection("ConnectionStrings");
+
+            var redisConnectionString = source["Redis"]?.ToString();
+
+            if (string.IsNullOrEmpty(redisConnectionString))
+            {
+                throw new InvalidOperationException("Redis connection string is not configured.");
+            }
+
+            services.AddSingleton<ICacheService>(provider =>
+                new CacheService(redisConnectionString, provider.GetRequiredService<ILogger<CacheService>>()));
+
+            return services;
+        }
+    }
+}