Merge pull request 'Update the Thalos.BuildingBlocks library to retrieve the idToken instead of accessToken from google authentication' (#12) from feature/use-id-token into development

Reviewed-on: #12
Reviewed-by: efrain_marin <efrain.marin@agilewebs.com>
Reviewed-by: Sergio Matías <sergio.matias@agilewebs.com>

Core.Thalos.DAL.API.sln

@@ -9,8 +9,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Application", "Application"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Core.Thalos.Domain", "Core.Thalos.Domain\Core.Thalos.Domain.csproj", "{BE8E05D6-05B2-4317-B619-21853B7D21DB}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Core.Thalos.Infrastructure", "Core.Thalos.Infraestructure\Core.Thalos.Infrastructure.csproj", "{43BD5F47-132F-4E78-83F1-A1FEED01A502}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Core.Thalos.Provider", "Core.Thalos.Provider\Core.Thalos.Provider.csproj", "{8CAE8380-475F-46B8-AF90-C495AAC58606}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Presentation", "Presentation", "{36839283-6407-476A-BB33-F0EE90383E2B}"
@@ -29,10 +27,6 @@ Global
 		{BE8E05D6-05B2-4317-B619-21853B7D21DB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{BE8E05D6-05B2-4317-B619-21853B7D21DB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{BE8E05D6-05B2-4317-B619-21853B7D21DB}.Release|Any CPU.Build.0 = Release|Any CPU
-		{43BD5F47-132F-4E78-83F1-A1FEED01A502}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{43BD5F47-132F-4E78-83F1-A1FEED01A502}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{43BD5F47-132F-4E78-83F1-A1FEED01A502}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{43BD5F47-132F-4E78-83F1-A1FEED01A502}.Release|Any CPU.Build.0 = Release|Any CPU
 		{8CAE8380-475F-46B8-AF90-C495AAC58606}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{8CAE8380-475F-46B8-AF90-C495AAC58606}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8CAE8380-475F-46B8-AF90-C495AAC58606}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -44,7 +38,6 @@ Global
 	GlobalSection(NestedProjects) = preSolution
 		{F00B4683-03B3-487A-9608-4B30675AA278} = {36839283-6407-476A-BB33-F0EE90383E2B}
 		{BE8E05D6-05B2-4317-B619-21853B7D21DB} = {2E7D918E-AB9F-44BF-A334-FD675C9B626E}
-		{43BD5F47-132F-4E78-83F1-A1FEED01A502} = {2E7D918E-AB9F-44BF-A334-FD675C9B626E}
 		{8CAE8380-475F-46B8-AF90-C495AAC58606} = {2E7D918E-AB9F-44BF-A334-FD675C9B626E}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution

Core.Thalos.DAL.API/Controllers/ModuleController.cs

@@ -5,97 +5,67 @@
 // ***********************************************************************
 
 using Asp.Versioning;
-using Core.Blueprint.Mongo;
-using Core.Thalos.Adapters;
-using Core.Thalos.Adapters.Attributes;
-using Core.Thalos.Adapters.Common.Constants;
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.Provider.Contracts;
-using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.Graph;
 using ModuleRequest = Core.Thalos.Domain.Contexts.Onboarding.Request.ModuleRequest;
+using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
 
-namespace LSA.Core.Kerberos.API.Controllers
+namespace LSA.Core.Thalos.API.Controllers
 {
     /// <summary>
-    /// Handles all requests for module authentication.
+    /// Handles all requests for module management.
     /// </summary>
     [ApiVersion(MimeTypes.ApplicationVersion)]
     [Route("api/v{api-version:apiVersion}/[controller]")]
     [Produces(MimeTypes.ApplicationJson)]
     [Consumes(MimeTypes.ApplicationJson)]
     [ApiController]
+    //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
     public class ModuleController(IModuleProvider service) : ControllerBase
     {
         /// <summary>
-        /// Gets all the modules.
+        /// Gets all modules.
         /// </summary>
-        /// <returns>The <see cref="IEnumerable{ModuleAdapter}"/> found entities.</returns>
-        /// <response code="200">The roles found.</response>
-        /// <response code="404">The roles not found error.</response>
-        /// <response code="500">The service internal error.</response>
         [HttpGet]
-        [Consumes(MimeTypes.ApplicationJson)]
-        [Produces(MimeTypes.ApplicationJson)]
         [ProducesResponseType(typeof(IEnumerable<ModuleAdapter>), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("ModuleManagement.Read, RoleManagement.Read")]
+        //[Permission("ModuleManagement.Read, RoleManagement.Read")]
         public async Task<IActionResult> GetAllModulesAsync(CancellationToken cancellationToken)
         {
-            var result = await service.GetAllModules(cancellationToken).ConfigureAwait(false);
+            var result = await service.GetAllModules(cancellationToken);
             return Ok(result);
         }
 
         /// <summary>
         /// Gets all the modules by module identifiers.
         /// </summary>
-        /// <param name="modules">The list of module identifiers.</param>
-        /// <returns>The <see cref="IEnumerable{ModuleAdapter}"/> found entities.</returns>
-        /// <response code="200">The modules found.</response>
-        /// <response code="404">The modules not found error.</response>
-        /// <response code="500">The service internal error.</response>
         [HttpPost]
         [Route(Routes.GetModuleList)]
-        [Consumes(MimeTypes.ApplicationJson)]
-        [Produces(MimeTypes.ApplicationJson)]
         [ProducesResponseType(typeof(IEnumerable<ModuleAdapter>), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("ModuleManagement.Read")]
+        //[Permission("ModuleManagement.Read")]
         public async Task<IActionResult> GetAllModulesByList([FromBody] string[] modules, CancellationToken cancellationToken)
         {
             if (modules == null || !modules.Any())
-            {
                 return BadRequest("Module identifiers are required.");
-            }
 
-            var result = await service.GetAllModulesByList(modules, cancellationToken).ConfigureAwait(false);
+            var result = await service.GetAllModulesByList(modules, cancellationToken);
             return Ok(result);
         }
 
-
         /// <summary>
-        /// Gets the module by identifier.
+        /// Gets the module by mongo identifier.
         /// </summary>
-        /// <param name="id">The module identifier.</param>
-        /// <returns>The <see cref="ModuleAdapter"/> found entity.</returns>
-        /// <response code="200">The module found.</response>
-        /// <response code="404">The module not found error.</response>
-        /// <response code="500">The service internal error.</response>
         [HttpGet]
         [Route(Routes.Id)]
-        [Consumes(MimeTypes.ApplicationJson)]
-        [Produces(MimeTypes.ApplicationJson)]
         [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("ModuleManagement.Read")]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        //[Permission("ModuleManagement.Read")]
         public async Task<IActionResult> GetModuleByIdAsync([FromRoute] string _id, CancellationToken cancellationToken)
         {
-            var result = await service.GetModuleById(_id, cancellationToken).ConfigureAwait(false);
+            var result = await service.GetModuleById(_id, cancellationToken);
 
             if (result == null)
-            {
-                return NotFound("Entity not found");
-            }
+                return NotFound("Module not found");
 
             return Ok(result);
         }
@@ -103,70 +73,71 @@ namespace LSA.Core.Kerberos.API.Controllers
         /// <summary>
         /// Creates a new module.
         /// </summary>
-        /// <param name="newModule">The module to be added.</param>
-        /// <returns>The <see cref="ModuleAdapter"/> created entity.</returns>
-        /// <response code="201">The module created.</response>
-        /// <response code="422">The module could not be created.</response>
-        /// <response code="500">The service internal e|ror.</response>
         [HttpPost]
         [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status201Created)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("ModuleManagement.Write")]
+        [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+        //[Permission("ModuleManagement.Write")]
         public async Task<IActionResult> CreateModuleAsync([FromBody] ModuleRequest newModule, CancellationToken cancellationToken)
         {
-            var result = await service.CreateModule(newModule, cancellationToken).ConfigureAwait(false);
+            var result = await service.CreateModule(newModule, cancellationToken);
             return Created("CreatedWithIdAsync", result);
         }
 
         /// <summary>
-        /// Updates a full module by identifier.
+        /// Updates a full module by mongo identifier.
         /// </summary>
-        /// <param name="entity">The module to update.</param>
-        /// <param name="id">The module identifier.</param>
-        /// <returns>The <see cref="ModuleAdapter"/> updated entity.</returns>
-        /// <response code="200">The module updated.</response>
-        /// <response code="404">The module not found.</response>
-        /// <response code="422">The module could not be updated.</response>
-        /// <response code="500">The service internal error.</response>
         [HttpPut]
         [Route(Routes.Id)]
-        [Consumes(MimeTypes.ApplicationJson)]
-        [Produces(MimeTypes.ApplicationJson)]
         [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("ModuleManagement.Write")]
-        public async Task<IActionResult> UpdateModuleAsync([FromRoute] string _id, ModuleAdapter entity, CancellationToken cancellationToken)
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+        //[Permission("ModuleManagement.Write")]
+        public async Task<IActionResult> UpdateModuleAsync([FromRoute] string _id, [FromBody] ModuleAdapter entity, CancellationToken cancellationToken)
         {
-            if (_id != entity._Id?.ToString())
-            {
+            if (_id != entity._Id)
                 return BadRequest("Module ID mismatch");
-            }
-
-            var result = await service.UpdateModule(entity, cancellationToken).ConfigureAwait(false);
 
+            var result = await service.UpdateModule(entity, cancellationToken);
             return Ok(result);
         }
 
         /// <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>The <see cref="ModuleAdapter"/> updated entity.</returns>
-        /// <response code="200">The module updates.</response>
-        /// <response code="404">The module not found.</response>
-        /// <response code="422">The module could not be deleted.</response>
-        /// <response code="500">The service internal error.</response>
         [HttpPatch]
         [Route(Routes.ChangeStatus)]
-        [Consumes(MimeTypes.ApplicationJson)]
-        [Produces(MimeTypes.ApplicationJson)]
         [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("ModuleManagement.Write")]
-        public async Task<IActionResult> ChangeModuleStatus([FromRoute] string id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
+        //[Permission("ModuleManagement.Write")]
+        public async Task<IActionResult> ChangeModuleStatus([FromRoute] string _id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
         {
-            var result = await service.ChangeModuleStatus(id, newStatus, cancellationToken).ConfigureAwait(false);
+            var result = await service.ChangeModuleStatus(_id, newStatus, cancellationToken);
+
+            if (result == null)
+                return NotFound("Module not found");
+
+            return Ok(result);
+        }
+
+        /// <summary>
+        /// Deletes a module by mongo identifier.
+        /// </summary>
+        /// <param name="_id">The module Mongo mongo identifier.</param>
+        /// <param name="cancellationToken">Cancellation token for async operation.</param>
+        /// <returns>The deleted <see cref="ModuleAdapter"/> if found.</returns>
+        /// <response code="200">The module was successfully deleted.</response>
+        /// <response code="404">The module was not found.</response>
+        /// <response code="500">Internal server error.</response>
+        [HttpDelete]
+        [Route(Routes.Id)]
+        [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        //[Permission("ModuleManagement.Write")]
+        public async Task<IActionResult> DeleteModuleAsync([FromRoute] string _id, CancellationToken cancellationToken)
+        {
+            var result = await service.DeleteModule(_id, cancellationToken);
+            if (result == null)
+                return NotFound("Module not found");
+
             return Ok(result);
         }
     }

Core.Thalos.DAL.API/Controllers/PermissionController.cs

@@ -5,17 +5,14 @@
 // ***********************************************************************
 
 using Asp.Versioning;
-using Core.Blueprint.Mongo;
-using Core.Thalos.Adapters;
-using Core.Thalos.Adapters.Attributes;
-using Core.Thalos.Adapters.Common.Constants;
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.Provider.Contracts;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.Graph;
 using PermissionRequest = Core.Thalos.Domain.Contexts.Onboarding.Request.PermissionRequest;
+using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
 
-namespace LSA.Core.Kerberos.API.Controllers
+namespace LSA.Core.Thalos.API.Controllers
 {
     /// <summary>
     /// Handles all requests for permission authentication.
@@ -25,21 +22,21 @@ namespace LSA.Core.Kerberos.API.Controllers
     [Produces(MimeTypes.ApplicationJson)]
     [Consumes(MimeTypes.ApplicationJson)]
     [ApiController]
+    //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
     public class PermissionController(IPermissionProvider service) : ControllerBase
     {
         /// <summary>
-        /// Gets all the permissions.
+        /// Gets all permissions.
         /// </summary>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="IEnumerable{PermissionAdapter}"/> found entities.</returns>
-        /// <response code="200">The roles found.</response>
-        /// <response code="404">The roles not found error.</response>
+        /// <response code="200">The permissions found.</response>
         /// <response code="500">The service internal error.</response>
         [HttpGet]
         [Consumes(MimeTypes.ApplicationJson)]
         [Produces(MimeTypes.ApplicationJson)]
         [ProducesResponseType(typeof(IEnumerable<PermissionAdapter>), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("PermissionManagement.Read, RoleManagement.Read")]
+        //[Permission("PermissionManagement.Read, RoleManagement.Read")]
         public async Task<IActionResult> GetAllPermissionsAsync(CancellationToken cancellationToken)
         {
             var result = await service.GetAllPermissions(cancellationToken).ConfigureAwait(false);
@@ -50,22 +47,22 @@ namespace LSA.Core.Kerberos.API.Controllers
         /// Gets all the permissions by permission identifiers.
         /// </summary>
         /// <param name="permissions">The list of permission identifiers.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="IEnumerable{PermissionAdapter}"/> found entities.</returns>
         /// <response code="200">The permissions found.</response>
-        /// <response code="404">The permissions not found error.</response>
+        /// <response code="400">Bad request if list is null or empty.</response>
         /// <response code="500">The service internal error.</response>
         [HttpPost]
         [Route(Routes.GetPermissionList)]
         [Consumes(MimeTypes.ApplicationJson)]
         [Produces(MimeTypes.ApplicationJson)]
         [ProducesResponseType(typeof(IEnumerable<PermissionAdapter>), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("PermissionManagement.Read")]
+        //[Permission("PermissionManagement.Read")]
         public async Task<IActionResult> GetAllPermissionsByList([FromBody] string[] permissions, CancellationToken cancellationToken)
         {
             if (permissions == null || !permissions.Any())
             {
-                return BadRequest("Module identifiers are required.");
+                return BadRequest("Permissions identifiers are required.");
             }
 
             var result = await service.GetAllPermissionsByList(permissions, cancellationToken).ConfigureAwait(false);
@@ -73,27 +70,27 @@ namespace LSA.Core.Kerberos.API.Controllers
         }
 
         /// <summary>
-        /// Gets the permission by identifier.
+        /// Gets the permission by mongo identifier.
         /// </summary>
-        /// <param name="id">The permission identifier.</param>
+        /// <param name="_id">The permission mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="PermissionAdapter"/> found entity.</returns>
         /// <response code="200">The permission found.</response>
-        /// <response code="404">The permission not found error.</response>
+        /// <response code="404">The permission not found.</response>
         /// <response code="500">The service internal error.</response>
         [HttpGet]
         [Route(Routes.Id)]
         [Consumes(MimeTypes.ApplicationJson)]
         [Produces(MimeTypes.ApplicationJson)]
         [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("PermissionManagement.Read")]
+        //[Permission("PermissionManagement.Read")]
         public async Task<IActionResult> GetPermissionByIdAsync([FromRoute] string _id, CancellationToken cancellationToken)
         {
             var result = await service.GetPermissionById(_id, cancellationToken).ConfigureAwait(false);
 
             if (result == null)
             {
-                return NotFound("Entity not found");
+                return NotFound("Permission not found");
             }
 
             return Ok(result);
@@ -103,14 +100,14 @@ namespace LSA.Core.Kerberos.API.Controllers
         /// Creates a new permission.
         /// </summary>
         /// <param name="newPermission">The permission to be added.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="PermissionAdapter"/> created entity.</returns>
         /// <response code="201">The permission created.</response>
         /// <response code="422">The permission could not be created.</response>
-        /// <response code="500">The service internal e|ror.</response>
+        /// <response code="500">Internal server error.</response>
         [HttpPost]
         [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status201Created)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("PermissionManagement.Write")]
+        //[Permission("PermissionManagement.Write")]
         public async Task<IActionResult> CreatePermissionAsync([FromBody] PermissionRequest newPermission, CancellationToken cancellationToken)
         {
             var result = await service.CreatePermission(newPermission, cancellationToken).ConfigureAwait(false);
@@ -118,25 +115,25 @@ namespace LSA.Core.Kerberos.API.Controllers
         }
 
         /// <summary>
-        /// Updates a full permission by identifier.
+        /// Updates a full permission by mongo identifier.
         /// </summary>
+        /// <param name="_id">The permission mongo identifier.</param>
         /// <param name="entity">The permission to update.</param>
-        /// <param name="id">The permission identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="PermissionAdapter"/> updated entity.</returns>
         /// <response code="200">The permission updated.</response>
-        /// <response code="404">The permission not found.</response>
+        /// <response code="400">Bad request if ID mismatch.</response>
         /// <response code="422">The permission could not be updated.</response>
-        /// <response code="500">The service internal error.</response>
+        /// <response code="500">Internal server error.</response>
         [HttpPut]
         [Route(Routes.Id)]
         [Consumes(MimeTypes.ApplicationJson)]
         [Produces(MimeTypes.ApplicationJson)]
         [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("PermissionManagement.Write")]
-        public async Task<IActionResult> UpdatePermissionAsync([FromRoute] string _id, PermissionAdapter entity, CancellationToken cancellationToken)
+        //[Permission("PermissionManagement.Write")]
+        public async Task<IActionResult> UpdatePermissionAsync([FromRoute] string _id, [FromBody] PermissionAdapter entity, CancellationToken cancellationToken)
         {
-            if (_id != entity._Id?.ToString())
+            if (_id != entity._Id)
             {
                 return BadRequest("Permission ID mismatch");
             }
@@ -149,23 +146,48 @@ namespace LSA.Core.Kerberos.API.Controllers
         /// <summary>
         /// Changes the status of the permission.
         /// </summary>
-        /// <param name="id">The permission identifier.</param>
+        /// <param name="_id">The permission mongo identifier.</param>
         /// <param name="newStatus">The new status of the permission.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="PermissionAdapter"/> updated entity.</returns>
-        /// <response code="200">The permission updates.</response>
-        /// <response code="404">The permission not found.</response>
-        /// <response code="422">The permission could not be deleted.</response>
-        /// <response code="500">The service internal error.</response>
+        /// <response code="200">The permission status was updated.</response>
+        /// <response code="500">Internal server error.</response>
         [HttpPatch]
         [Route(Routes.ChangeStatus)]
         [Consumes(MimeTypes.ApplicationJson)]
         [Produces(MimeTypes.ApplicationJson)]
         [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("PermissionManagement.Write")]
-        public async Task<IActionResult> ChangePermissionStatus([FromRoute] string id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
+        //[Permission("PermissionManagement.Write")]
+        public async Task<IActionResult> ChangePermissionStatus([FromRoute] string _id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
         {
-            var result = await service.ChangePermissionStatus(id, newStatus, cancellationToken).ConfigureAwait(false);
+            var result = await service.ChangePermissionStatus(_id, newStatus, cancellationToken).ConfigureAwait(false);
+
+            if (result == null)
+                return NotFound("Permission not found");
+
+            return Ok(result);
+        }
+
+        /// <summary>
+        /// Deletes a permission by its mongo identifier.
+        /// </summary>
+        /// <param name="_id">The permission mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The deleted <see cref="PermissionAdapter"/> entity.</returns>
+        /// <response code="200">The permission was successfully deleted.</response>
+        /// <response code="404">The permission was not found.</response>
+        /// <response code="500">Internal server error occurred.</response>
+        [HttpDelete]
+        [Route(Routes.Id)]
+        [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
+        //[Permission("PermissionManagement.Write")]
+        public async Task<IActionResult> DeletePermissionAsync([FromRoute] string _id, CancellationToken cancellationToken)
+        {
+            var result = await service.DeletePermission(_id, cancellationToken).ConfigureAwait(false);
+
+            if (result is null)
+                return NotFound("Permission not found.");
+
             return Ok(result);
         }
     }

Core.Thalos.DAL.API/Controllers/RoleController.cs

@@ -3,18 +3,16 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
+
 using Asp.Versioning;
-using Core.Thalos.Adapters;
-using Core.Thalos.Adapters.Attributes;
-using Core.Thalos.Adapters.Common.Constants;
-using Core.Thalos.Adapters.Common.Enums;
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.Domain.Contexts.Onboarding.Request;
 using Core.Thalos.Provider.Contracts;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
 
-namespace LSA.Core.Kerberos.API.Controllers
+namespace LSA.Core.Thalos.API.Controllers
 {
     /// <summary>
     /// Handles all requests for role authentication.
@@ -24,19 +22,19 @@ namespace LSA.Core.Kerberos.API.Controllers
     [Produces(MimeTypes.ApplicationJson)]
     [Consumes(MimeTypes.ApplicationJson)]
     [ApiController]
+    //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
     public class RoleController(IRoleProvider service) : ControllerBase
     {
         /// <summary>
-        /// Gets all the roles.
+        /// Gets all roles.
         /// </summary>
-        /// <returns>The rol found entities.</returns>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The <see cref="IEnumerable{RoleAdapter}"/> found entities.</returns>
         /// <response code="200">The roles found.</response>
-        /// <response code="404">The roles not found error.</response>
         /// <response code="500">The service internal error.</response>
         [HttpGet]
         [ProducesResponseType(typeof(IEnumerable<RoleAdapter>), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("RoleManagement.Read")]
+        //[Permission("RoleManagement.Read")]
         public async Task<IActionResult> GetAllRolesAsync(CancellationToken cancellationToken)
         {
             var result = await service.GetAllRoles(cancellationToken).ConfigureAwait(false);
@@ -44,25 +42,25 @@ namespace LSA.Core.Kerberos.API.Controllers
         }
 
         /// <summary>
-        /// Gets the role by identifier.
+        /// Gets the role by mongo identifier.
         /// </summary>
-        /// <param name="id">The role identifier.</param>
+        /// <param name="_id">The role mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="RoleAdapter"/> found entity.</returns>
         /// <response code="200">The role found.</response>
-        /// <response code="404">The role not found error.</response>
+        /// <response code="404">The role not found.</response>
         /// <response code="500">The service internal error.</response>
         [HttpGet]
         [Route(Routes.Id)]
         [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("RoleManagement.Read")]
+        //[Permission("RoleManagement.Read")]
         public async Task<IActionResult> GetRoleByIdAsync([FromRoute] string _id, CancellationToken cancellationToken)
         {
             var result = await service.GetRoleById(_id, cancellationToken).ConfigureAwait(false);
 
             if (result == null)
             {
-                return NotFound("Entity not found");
+                return NotFound("Role not found");
             }
 
             return Ok(result);
@@ -72,14 +70,14 @@ namespace LSA.Core.Kerberos.API.Controllers
         /// Creates a new role.
         /// </summary>
         /// <param name="newRole">The role to be added.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="RoleAdapter"/> created entity.</returns>
         /// <response code="201">The role created.</response>
         /// <response code="422">The role could not be created.</response>
         /// <response code="500">The service internal error.</response>
         [HttpPost]
         [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status201Created)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("RoleManagement.Write")]
+        //[Permission("RoleManagement.Write")]
         public async Task<IActionResult> CreateRoleAsync([FromBody] RoleRequest newRole, CancellationToken cancellationToken)
         {
             var result = await service.CreateRole(newRole, cancellationToken).ConfigureAwait(false);
@@ -87,67 +85,66 @@ namespace LSA.Core.Kerberos.API.Controllers
         }
 
         /// <summary>
-        /// Updates a full role by identifier.
+        /// Updates a full role by mongo identifier.
         /// </summary>
+        /// <param name="_id">The role mongo identifier.</param>
         /// <param name="entity">The role to update.</param>
-        /// <param name="id">The role identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="RoleAdapter"/> updated entity.</returns>
         /// <response code="200">The role updated.</response>
-        /// <response code="404">The role not found.</response>
+        /// <response code="400">Bad request if role ID mismatches.</response>
         /// <response code="422">The role could not be updated.</response>
         /// <response code="500">The service internal error.</response>
         [HttpPut]
         [Route(Routes.Id)]
         [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("RoleManagement.Write")]
+        //[Permission("RoleManagement.Write")]
         public async Task<IActionResult> UpdateRoleAsync([FromRoute] string _id, [FromBody] RoleAdapter entity, CancellationToken cancellationToken)
         {
-            if (_id != entity._Id?.ToString())
+            if (_id != entity._Id)
             {
                 return BadRequest("Role ID mismatch");
             }
 
             var result = await service.UpdateRole(entity, cancellationToken).ConfigureAwait(false);
-
             return Ok(result);
         }
 
         /// <summary>
         /// Changes the status of the role.
         /// </summary>
-        /// <param name="id">The role identifier.</param>
+        /// <param name="_id">The role mongo identifier.</param>
         /// <param name="newStatus">The new status of the role.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="RoleAdapter"/> updated entity.</returns>
-        /// <response code="200">The role updates.</response>
-        /// <response code="404">The role not found.</response>
-        /// <response code="422">The role could not be deleted.</response>
+        /// <response code="200">The role status updated.</response>
         /// <response code="500">The service internal error.</response>
         [HttpPatch]
         [Route(Routes.ChangeStatus)]
         [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("RoleManagement.Write")]
-        public async Task<IActionResult> ChangeRoleStatus([FromRoute] string id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
+        //[Permission("RoleManagement.Write")]
+        public async Task<IActionResult> ChangeRoleStatus([FromRoute] string _id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
         {
-            var result = await service.ChangeRoleStatus(id, newStatus, cancellationToken).ConfigureAwait(false);
+            var result = await service.ChangeRoleStatus(_id, newStatus, cancellationToken).ConfigureAwait(false);
+
+            if (result == null)
+                return NotFound("Role not found");
+
             return Ok(result);
         }
 
         /// <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="roleId">The mongo 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>
-        /// <response code="200">The role updates.</response>
-        /// <response code="404">The role not found.</response>
-        /// <response code="422">The role could not be deleted.</response>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The updated <see cref="RoleAdapter"/> object.</returns>
+        /// <response code="200">The application was added to the role.</response>
         /// <response code="500">The service internal error.</response>
         [HttpPost(Routes.AddApplication)]
         [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("RoleManagement.Write")]
+        //[Permission("RoleManagement.Write")]
         public async Task<IActionResult> AddApplicationToRoleAsync([FromRoute] string roleId, [FromRoute] ApplicationsEnum application, CancellationToken cancellationToken)
         {
             var result = await service.AddApplicationToRole(roleId, application, cancellationToken).ConfigureAwait(false);
@@ -157,21 +154,42 @@ namespace LSA.Core.Kerberos.API.Controllers
         /// <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="roleId">The mongo 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>
-        /// <response code="200">The role updates.</response>
-        /// <response code="404">The role not found.</response>
-        /// <response code="422">The role could not be deleted.</response>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The updated <see cref="RoleAdapter"/> object.</returns>
+        /// <response code="200">The application was removed from the role.</response>
         /// <response code="500">The service internal error.</response>
         [HttpDelete(Routes.RemoveApplication)]
         [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("RoleManagement.Write")]
+        //[Permission("RoleManagement.Write")]
         public async Task<IActionResult> RemoveApplicationFromRoleAsync([FromRoute] string roleId, [FromRoute] ApplicationsEnum application, CancellationToken cancellationToken)
         {
             var result = await service.RemoveApplicationFromRole(roleId, application, cancellationToken).ConfigureAwait(false);
             return Ok(result);
         }
+
+        /// <summary>
+        /// Deletes a role by its mongo identifier.
+        /// </summary>
+        /// <param name="_id">The role mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The deleted <see cref="RoleAdapter"/> entity.</returns>
+        /// <response code="200">The role was deleted successfully.</response>
+        /// <response code="404">The role was not found.</response>
+        /// <response code="500">The service internal error.</response>
+        [HttpDelete]
+        [Route(Routes.Id)]
+        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
+        //[Permission("RoleManagement.Write")]
+        public async Task<IActionResult> DeleteRoleAsync([FromRoute] string _id, CancellationToken cancellationToken)
+        {
+            var result = await service.DeleteRole(_id, cancellationToken).ConfigureAwait(false);
+
+            if (result is null)
+                return NotFound("Role not found.");
+
+            return Ok(result);
+        }
     }
 }

Core.Thalos.DAL.API/Controllers/TenantController.cs

@@ -0,0 +1,169 @@
+// ***********************************************************************
+// <copyright file="TenantController.cs">
+//     AgileWebs
+// </copyright>
+// ***********************************************************************
+
+using Asp.Versioning;
+using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Provider.Contracts;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
+using TenantRequest = Core.Thalos.Domain.Contexts.Onboarding.Request.TenantRequest;
+
+namespace LSA.Core.Thalos.API.Controllers
+{
+    /// <summary>
+    /// Handles all requests for Tenant authentication.
+    /// </summary>
+    [ApiVersion(MimeTypes.ApplicationVersion)]
+    [Route("api/v{api-version:apiVersion}/[controller]")]
+    [Produces(MimeTypes.ApplicationJson)]
+    [Consumes(MimeTypes.ApplicationJson)]
+    [ApiController]
+    //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+    public class TenantController(ITenantProvider service) : ControllerBase
+    {
+        /// <summary>
+        /// Gets all Tenants.
+        /// </summary>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The <see cref="IEnumerable{TenantAdapter}"/> found entities.</returns>
+        /// <response code="200">The tenants found.</response>
+        /// <response code="500">The service internal error.</response>
+        [HttpGet]
+        [Consumes(MimeTypes.ApplicationJson)]
+        [Produces(MimeTypes.ApplicationJson)]
+        [ProducesResponseType(typeof(IEnumerable<TenantAdapter>), StatusCodes.Status200OK)]
+        //[Permission("TenantManagement.Read, RoleManagement.Read")]
+        public async Task<IActionResult> GetAllTenantsAsync(CancellationToken cancellationToken)
+        {
+            var result = await service.GetAllTenants(cancellationToken).ConfigureAwait(false);
+            return Ok(result);
+        }
+
+        /// <summary>
+        /// Gets the Tenant by mongo identifier.
+        /// </summary>
+        /// <param name="_id">The Tenant mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The <see cref="TenantAdapter"/> found entity.</returns>
+        /// <response code="200">The tenant found.</response>
+        /// <response code="404">The tenant not found error.</response>
+        /// <response code="500">The service internal error.</response>
+        [HttpGet]
+        [Route(Routes.Id)]
+        [Consumes(MimeTypes.ApplicationJson)]
+        [Produces(MimeTypes.ApplicationJson)]
+        [ProducesResponseType(typeof(TenantAdapter), StatusCodes.Status200OK)]
+        //[Permission("TenantManagement.Read")]
+        public async Task<IActionResult> GetTenantByIdAsync([FromRoute] string _id, CancellationToken cancellationToken)
+        {
+            var result = await service.GetTenantById(_id, cancellationToken).ConfigureAwait(false);
+
+            if (result == null)
+            {
+                return NotFound("Tenant not found");
+            }
+
+            return Ok(result);
+        }
+
+        /// <summary>
+        /// Creates a new Tenant.
+        /// </summary>
+        /// <param name="newTenant">The Tenant to be added.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The <see cref="TenantAdapter"/> created entity.</returns>
+        /// <response code="201">The tenant was created.</response>
+        /// <response code="422">The tenant could not be created.</response>
+        /// <response code="500">The service internal error.</response>
+        [HttpPost]
+        [ProducesResponseType(typeof(TenantAdapter), StatusCodes.Status201Created)]
+        //[Permission("TenantManagement.Write")]
+        public async Task<IActionResult> CreateTenantAsync([FromBody] TenantRequest newTenant, CancellationToken cancellationToken)
+        {
+            var result = await service.CreateTenant(newTenant, cancellationToken).ConfigureAwait(false);
+            return Created("CreatedWithIdAsync", result);
+        }
+
+        /// <summary>
+        /// Updates a full Tenant by mongo identifier.
+        /// </summary>
+        /// <param name="_id">The Tenant mongo identifier.</param>
+        /// <param name="entity">The Tenant to update.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The <see cref="TenantAdapter"/> updated entity.</returns>
+        /// <response code="200">The tenant was updated.</response>
+        /// <response code="400">Tenant ID mismatch.</response>
+        /// <response code="422">The tenant could not be updated.</response>
+        /// <response code="500">The service internal error.</response>
+        [HttpPut]
+        [Route(Routes.Id)]
+        [Consumes(MimeTypes.ApplicationJson)]
+        [Produces(MimeTypes.ApplicationJson)]
+        [ProducesResponseType(typeof(TenantAdapter), StatusCodes.Status200OK)]
+        //[Permission("TenantManagement.Write")]
+        public async Task<IActionResult> UpdateTenantAsync([FromRoute] string _id, [FromBody] TenantAdapter entity, CancellationToken cancellationToken)
+        {
+            if (_id != entity._Id)
+            {
+                return BadRequest("Tenant ID mismatch");
+            }
+
+            var result = await service.UpdateTenant(entity, cancellationToken).ConfigureAwait(false);
+
+            if (result is not null) return Ok(result);
+            else return NotFound("Tenant not found");
+        }
+
+        /// <summary>
+        /// Changes the status of the Tenant.
+        /// </summary>
+        /// <param name="_id">The Tenant mongo identifier.</param>
+        /// <param name="newStatus">The new status of the Tenant.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The <see cref="TenantAdapter"/> updated entity.</returns>
+        /// <response code="200">The tenant status was updated.</response>
+        /// <response code="500">The service internal error.</response>
+        [HttpPatch]
+        [Route(Routes.ChangeStatus)]
+        [Consumes(MimeTypes.ApplicationJson)]
+        [Produces(MimeTypes.ApplicationJson)]
+        [ProducesResponseType(typeof(TenantAdapter), StatusCodes.Status200OK)]
+        //[Permission("TenantManagement.Write")]
+        public async Task<IActionResult> ChangeTenantStatus([FromRoute] string _id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
+        {
+            var result = await service.ChangeTenantStatus(_id, newStatus, cancellationToken).ConfigureAwait(false);
+
+            if (result == null)
+                return NotFound("Tenant not found");
+
+            return Ok(result);
+        }
+
+        /// <summary>
+        /// Deletes a Tenant by mongo identifier.
+        /// </summary>
+        /// <param name="_id">The Tenant mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The deleted <see cref="TenantAdapter"/> entity if found.</returns>
+        /// <response code="200">The tenant was deleted.</response>
+        /// <response code="404">The tenant was not found.</response>
+        /// <response code="500">The service internal error.</response>
+        [HttpDelete]
+        [Route(Routes.Id)]
+        [ProducesResponseType(typeof(TenantAdapter), StatusCodes.Status200OK)]
+        //[Permission("TenantManagement.Write")]
+        public async Task<IActionResult> DeleteTenantAsync([FromRoute] string _id, CancellationToken cancellationToken)
+        {
+            var result = await service.DeleteTenant(_id, cancellationToken).ConfigureAwait(false);
+
+            if (result is null)
+                return NotFound("Tenant not found.");
+
+            return Ok(result);
+        }
+    }
+}

Core.Thalos.DAL.API/Controllers/UserController.cs

@@ -3,18 +3,16 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
+
 using Asp.Versioning;
-using Core.Blueprint.Mongo;
-using Core.Thalos.Adapters;
-using Core.Thalos.Adapters.Attributes;
-using Core.Thalos.Adapters.Common.Constants;
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.Provider.Contracts;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.Graph;
+using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
 using UserRequest = Core.Thalos.Domain.Contexts.Onboarding.Request.UserRequest;
 
-namespace LSA.Core.Kerberos.API.Controllers
+namespace LSA.Core.Thalos.API.Controllers
 {
     /// <summary>
     /// Handles all requests for user authentication.
@@ -27,16 +25,14 @@ namespace LSA.Core.Kerberos.API.Controllers
     public class UserController(IUserProvider service) : ControllerBase
     {
         /// <summary>
-        /// Gets all the users.
-        /// </summary>  
+        /// Gets all users.
+        /// </summary>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="IEnumerable{UserAdapter}"/> found entity.</returns>
-        /// <response code="200">The users found.</response>
-        /// <response code="404">The users not found error.</response>
-        /// <response code="500">The service internal error.</response>
         [HttpGet]
         [ProducesResponseType(typeof(IEnumerable<UserAdapter>), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("UserManagement.Read")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("UserManagement.Read")]
         public async Task<IActionResult> GetAllUsers(CancellationToken cancellationToken)
         {
             var result = await service.GetAllUsers(cancellationToken).ConfigureAwait(false);
@@ -44,62 +40,44 @@ namespace LSA.Core.Kerberos.API.Controllers
         }
 
         /// <summary>
-        /// Gets the user by identifier.
+        /// Gets the user by mongo identifier.
         /// </summary>
-        /// <param name="id">The user identifier.</param>
+        /// <param name="_id">The user Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="UserAdapter"/> found entity.</returns>
-        /// <response code="200">The user found.</response>
-        /// <response code="404">The user not found error.</response>
-        /// <response code="500">The service internal error.</response>
         [HttpGet]
         [Route(Routes.Id)]
         [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("UserManagement.Read")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("UserManagement.Read")]
         public async Task<IActionResult> GetUserById([FromRoute] string _id, CancellationToken cancellationToken)
         {
             var result = await service.GetUserById(_id, cancellationToken).ConfigureAwait(false);
-
-            if (result == null)
-            {
-                return NotFound("Entity not found");
-            }
-
-            return Ok(result);
+            return result == null ? NotFound("User not found") : Ok(result);
         }
 
         /// <summary>
         /// Gets the user by email.
         /// </summary>
         /// <param name="email">The user's email.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="UserAdapter"/> found entity.</returns>
-        /// <response code="200">The user found.</response>
-        /// <response code="404">The user not found error.</response>
-        /// <response code="500">The service internal error.</response>
         [HttpGet]
         [Route(Routes.Email)]
         [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.AzureScheme}")]
+        //[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
         public async Task<IActionResult> GetUserByEmail([FromRoute] string email, CancellationToken cancellationToken)
         {
             var result = await service.GetUserByEmail(email, cancellationToken).ConfigureAwait(false);
-
-            if (result == null)
-            {
-                return NotFound("User not found");
-            }
-
-            return Ok(result);
+            return result == null ? NotFound("User not found") : Ok(result);
         }
 
         /// <summary>
         /// Validates if a user exists on the database.
         /// </summary>
         /// <param name="email">The user's email.</param>
-        /// <returns>The <see cref="UserExistenceAdapter"/> found entity.</returns>
-        /// <response code="200">The user found.</response>
-        /// <response code="404">The user not found error.</response>
-        /// <response code="500">The service internal error.</response>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The <see cref="UserExistenceAdapter"/> indicating existence.</returns>
         [HttpGet]
         [Route("{email}/ValidateExistence")]
         [ProducesResponseType(typeof(UserExistenceAdapter), StatusCodes.Status200OK)]
@@ -107,28 +85,19 @@ namespace LSA.Core.Kerberos.API.Controllers
         public async Task<IActionResult> ValidateUserExistence([FromRoute] string email, CancellationToken cancellationToken)
         {
             var result = await service.ValidateUserExistence(email, cancellationToken).ConfigureAwait(false);
-
-            if (result == null)
-            {
-                return NotFound("User not found");
-            }
-
-            return Ok(result);
+            return result == null ? NotFound("User not found") : Ok(result);
         }
 
         /// <summary>
         /// Creates a new user.
         /// </summary>
         /// <param name="newUser">The user to be added.</param>
-        /// <param name="sendInvitation">Sends an invitation in case of third party access.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="UserAdapter"/> created entity.</returns>
-        /// <response code="201">The user created.</response>
-        /// <response code="422">The user could not be created.</response>
-        /// <response code="500">The service internal error.</response>
         [HttpPost(Routes.Register)]
         [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status201Created)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("UserManagement.Write")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("UserManagement.Write")]
         public async Task<IActionResult> CreateUserAsync([FromBody] UserRequest newUser, CancellationToken cancellationToken)
         {
             var result = await service.CreateUser(newUser, cancellationToken).ConfigureAwait(false);
@@ -136,171 +105,75 @@ namespace LSA.Core.Kerberos.API.Controllers
         }
 
         /// <summary>
-        /// Updates a full user by identifier.
+        /// Updates a full user by mongo identifier.
         /// </summary>
+        /// <param name="_id">The user Mongo identifier.</param>
         /// <param name="entity">The user to update.</param>
-        /// <param name="id">The user identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="UserAdapter"/> updated entity.</returns>
-        /// <response code="200">The user updated.</response>
-        /// <response code="404">The user not found.</response>
-        /// <response code="422">The user could not be updated.</response>
-        /// <response code="500">The service internal error.</response>
         [HttpPut]
         [Route(Routes.Id)]
         [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("UserManagement.Write")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("UserManagement.Write")]
         public async Task<IActionResult> UpdateUserAsync([FromRoute] string _id, [FromBody] UserAdapter entity, CancellationToken cancellationToken)
         {
-            if (_id != entity._Id?.ToString())
-            {
+            if (_id != entity._Id)
                 return BadRequest("User ID mismatch");
-            }
 
             var result = await service.UpdateUser(entity, cancellationToken).ConfigureAwait(false);
-
             return Ok(result);
         }
 
         /// <summary>
         /// Logs in the user.
         /// </summary>
-        /// <param name="email">The User's email.</param>
-        /// <returns>A <see cref="UserAdapter"/> representing
-        /// the asynchronous execution of the service.</returns>
-        /// <response code="200">The User found.</response>
-        /// <response code="404">The User not found.</response>
-        /// <response code="500">The service internal error.</response>
+        /// <param name="email">The user's email.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The <see cref="UserAdapter"/> found entity.</returns>
         [HttpPatch(Routes.LogIn)]
         [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.AzureScheme}")]
+        //[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
         public async Task<IActionResult> LoginUserAsync([FromRoute] string email, CancellationToken cancellationToken)
         {
             var result = await service.LogInUser(email, cancellationToken).ConfigureAwait(false);
-
-            if (result is null)
-                return new NotFoundObjectResult($"The user with email: '{email}' was not found");
-
-            return Ok(result);
+            return result == null ? NotFound($"The user with email: '{email}' was not found") : Ok(result);
         }
 
         /// <summary>
         /// Logs out the user.
         /// </summary>
-        /// <param name="email">The User's email.</param>
-        /// <returns>A <see cref="UserAdapter"/> representing
-        /// the asynchronous execution of the service.</returns>
-        /// <response code="200">The User updated.</response>
-        /// <response code="500">The service internal error.</response>
+        /// <param name="email">The user's email.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The <see cref="UserAdapter"/> updated entity.</returns>
         [HttpPatch(Routes.LogOut)]
         [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.AzureScheme}")]
+        //[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
         public async Task<IActionResult> LogOutUserSessionAsync([FromRoute] string email, CancellationToken cancellationToken)
         {
             var result = await service.LogOutUserSession(email, cancellationToken).ConfigureAwait(false);
-
             return Ok(result);
-
         }
 
         /// <summary>
         /// Changes the status of the user.
         /// </summary>
-        /// <param name="id">The user identifier.</param>
+        /// <param name="_id">The user Mongo identifier.</param>
         /// <param name="newStatus">The new status of the user.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
         /// <returns>The <see cref="UserAdapter"/> updated entity.</returns>
-        /// <response code="200">The user updates.</response>
-        /// <response code="404">The user not found.</response>
-        /// <response code="422">The user could not be deleted.</response>
-        /// <response code="500">The service internal error.</response>
         [HttpPatch]
         [Route(Routes.ChangeStatus)]
         [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("UserManagement.Write")]
-        public async Task<IActionResult> ChangeUserStatus([FromRoute] string id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("UserManagement.Write")]
+        public async Task<IActionResult> ChangeUserStatus([FromRoute] string _id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
         {
-            var result = await service.ChangeUserStatus(id, newStatus, cancellationToken).ConfigureAwait(false);
-            return Ok(result);
-        }
+            var result = await service.ChangeUserStatus(_id, newStatus, cancellationToken).ConfigureAwait(false);
 
-        /// <summary>
-        /// Adds a company to the user's list of companies.
-        /// </summary>
-        /// <param name="userId">The user identifier.</param>
-        /// <param name="companyId">The company identifier to add.</param>
-        /// <returns>The updated <see cref="UserAdapter"/> entity.</returns>
-        /// <response code="200">The user with the updated companies.</response>
-        /// <response code="404">The user or company not found.</response>
-        /// <response code="500">The service internal error.</response>
-        [HttpPost]
-        [Route(Routes.AddCompany)]
-        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("UserManagement.Write")]
-        public async Task<IActionResult> AddCompanyToUserAsync([FromRoute] string userId, [FromRoute] string companyId, CancellationToken cancellationToken)
-        {
-            var result = await service.AddCompanyToUser(userId, companyId, cancellationToken).ConfigureAwait(false);
-            return Ok(result);
-        }
+            if (result == null)
+                return NotFound("User not found");
 
-        /// <summary>
-        /// Removes a company from the user's list of companies.
-        /// </summary>
-        /// <param name="userId">The user identifier.</param>
-        /// <param name="companyId">The company identifier to remove.</param>
-        /// <returns>The updated <see cref="UserAdapter"/> entity.</returns>
-        /// <response code="200">The user with the updated companies.</response>
-        /// <response code="404">The user or company not found.</response>
-        /// <response code="500">The service internal error.</response>
-        [HttpDelete]
-        [Route(Routes.RemoveCompany)]
-        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("UserManagement.Write")]
-        public async Task<IActionResult> RemoveCompanyFromUserAsync([FromRoute] string userId, [FromRoute] string companyId, CancellationToken cancellationToken)
-        {
-            var result = await service.RemoveCompanyFromUser(userId, companyId, cancellationToken).ConfigureAwait(false); ;
-            return Ok(result);
-        }
-
-        /// <summary>
-        /// Adds a project to the user's list of projects.
-        /// </summary>
-        /// <param name="userId">The user identifier.</param>
-        /// <param name="projectId">The project identifier to add.</param>
-        /// <returns>The updated <see cref="UserAdapter"/> entity.</returns>
-        /// <response code="200">The user with the updated projects.</response>
-        /// <response code="404">The user or project not found.</response>
-        /// <response code="500">The service internal error.</response>
-        [HttpPost]
-        [Route(Routes.AddProject)]
-        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("UserManagement.Write")]
-        public async Task<IActionResult> AddProjectToUserAsync([FromRoute] string userId, [FromRoute] string projectId, CancellationToken cancellationToken)
-        {
-            var result = await service.AddProjectToUser(userId, projectId, cancellationToken).ConfigureAwait(false);
-            return Ok(result);
-        }
-
-        /// <summary>
-        /// Removes a project from the user's list of projects.
-        /// </summary>
-        /// <param name="userId">The user identifier.</param>
-        /// <param name="projectId">The project identifier to remove.</param>
-        /// <returns>The updated <see cref="UserAdapter"/> entity.</returns>
-        /// <response code="200">The user with the updated projects.</response>
-        /// <response code="404">The user or project not found.</response>
-        /// <response code="500">The service internal error.</response>
-        [HttpDelete]
-        [Route(Routes.RemoveProject)]
-        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        [Permission("UserManagement.Write")]
-        public async Task<IActionResult> RemoveProjectFromUserAsync([FromRoute] string userId, [FromRoute] string projectId, CancellationToken cancellationToken)
-        {
-            var result = await service.RemoveCompanyFromUser(userId, projectId, cancellationToken).ConfigureAwait(false);
             return Ok(result);
         }
 
@@ -308,21 +181,35 @@ namespace LSA.Core.Kerberos.API.Controllers
         /// Gets a token for the user, including roles, permissions, and modules.
         /// </summary>
         /// <param name="email">The user's email.</param>
-        /// <returns>The token adapter with user details, role, permissions, and modules.</returns>
-        /// <response code="200">The token adapter with user details.</response>
-        /// <response code="404">The user not found.</response>
-        /// <response code="500">The service internal error.</response>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The <see cref="TokenAdapter"/> with user details.</returns>
         [HttpGet]
         [Route("{email}/GetTokenAdapter")]
         [ProducesResponseType(typeof(TokenAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.AzureScheme}")]
+        //[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
         public async Task<IActionResult> GetTokenAdapter([FromRoute] string email, CancellationToken cancellationToken)
         {
             var tokenAdapter = await service.GetToken(email, cancellationToken).ConfigureAwait(false);
+            return tokenAdapter == null ? NotFound($"User with email: {email} not found") : Ok(tokenAdapter);
+        }
 
-            if (tokenAdapter == null) return NotFound($"User with email: {email} not found");
-
-            return Ok(tokenAdapter);
+        /// <summary>
+        /// Deletes a user by mongo identifier.
+        /// </summary>
+        /// <param name="_id">The user Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>The deleted <see cref="UserAdapter"/> entity.</returns>
+        /// <response code="200">The user deleted.</response>
+        /// <response code="404">The user not found.</response>
+        [HttpDelete]
+        [Route(Routes.Id)]
+        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("UserManagement.Write")]
+        public async Task<IActionResult> DeleteUserAsync([FromRoute] string _id, CancellationToken cancellationToken)
+        {
+            var result = await service.DeleteUser(_id, cancellationToken).ConfigureAwait(false);
+            return result == null ? NotFound("User not found") : Ok(result);
         }
     }
 }

Core.Thalos.DAL.API/Core.Thalos.DAL.API.csproj

@@ -15,7 +15,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Blueprint.Logging" Version="0.0.1" />
+    <PackageReference Include="Core.Blueprint.Logging" Version="1.0.1" />
   </ItemGroup>
 
   <ItemGroup>

Core.Thalos.DAL.API/Program.cs

@@ -1,90 +1,87 @@
+using Core.Blueprint.DAL.Mongo.Configuration;
+using Core.Blueprint.KeyVault.Configuration;
 using Core.Blueprint.Logging.Configuration;
-using Core.Thalos.Adapters.Extensions;
-using Core.Thalos.Adapters.Helpers;
+using Core.Blueprint.Redis.Configuration;
+using Core.Thalos.BuildingBlocks;
+using Core.Thalos.BuildingBlocks.Configuration;
 using Core.Thalos.Provider;
-using Microsoft.AspNetCore.RateLimiting;
-using Microsoft.AspNetCore.ResponseCompression;
-using System.IO.Compression;
+using Microsoft.AspNetCore.HttpLogging;
 using System.Reflection;
-using System.Threading.RateLimiting;
+using System.Text.Json.Serialization;
 
 var builder = WebApplication.CreateBuilder(args);
 
-var authSettings = AuthHelper.GetAuthSettings(builder, "thalos_dal");
+builder.Configuration
+    .AddUserSecrets(Assembly.GetExecutingAssembly())
+    .AddEnvironmentVariables();
+
+var services = builder.Services.AddKeyVault(builder.Configuration);
+
+var authSettings = await AuthHelper.GetAuthSettings(builder.Services, builder, "thalos_common");
 
 builder.Services.ConfigureAuthentication(builder.Configuration, authSettings);
 
-builder.Configuration.AddUserSecrets(Assembly.GetExecutingAssembly()).AddEnvironmentVariables();
-
-// Add services to the container.
-
-builder.Services.AddControllers();
-// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
 builder.Services.AddEndpointsApiExplorer();
-
-builder.Services.AddLogs(builder);
-
-builder.Services.AddCors(options =>
-{
-    options.AddPolicy("AllowAll", policyBuilder =>
-        policyBuilder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod());
-});
-builder.Services.AddMvc().AddJsonOptions(options =>
-{
-    options.JsonSerializerOptions.WriteIndented = true;
-    options.JsonSerializerOptions.MaxDepth = 20;
-    options.JsonSerializerOptions.NumberHandling = System.Text.Json.Serialization.JsonNumberHandling.AllowNamedFloatingPointLiterals;
-});
-builder.Services.Configure<BrotliCompressionProviderOptions>(options =>
-{
-    options.Level = CompressionLevel.Fastest;
-});
-builder.Services.Configure<GzipCompressionProviderOptions>(options =>
-{
-    options.Level = CompressionLevel.SmallestSize;
-});
-builder.Services.AddResponseCompression(options =>
-{
-    options.EnableForHttps = true;
-    options.Providers.Add<BrotliCompressionProvider>();
-    options.Providers.Add<GzipCompressionProvider>();
-});
-
-builder.Services.AddRateLimiter(_ => _
-    .AddFixedWindowLimiter("fixed", options =>
-    {
-        options.PermitLimit = 5;
-        options.Window = TimeSpan.FromSeconds(10);
-        options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
-        options.QueueLimit = 2;
-    })
-    .AddSlidingWindowLimiter("sliding", options =>
-    {
-        options.PermitLimit = 5;
-        options.Window = TimeSpan.FromSeconds(10);
-        options.SegmentsPerWindow = 5;
-        options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
-        options.QueueLimit = 2;
-    }));
-
-builder.Services.AddResponseCaching();
-builder.Services.AddControllers();
-builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwagger(builder.Configuration, "Core.Thalos.DAL.API.xml", authSettings);
+builder.Services.AddSwaggerGen(builder.Configuration, "Core.Thalos.DAL.API.xml", authSettings);
 builder.Services.AddVersioning(builder.Configuration);
-builder.Services.AddLogging();
+builder.Services.AddResponseCompression();
 builder.Services.AddProblemDetails();
+builder.Services.AddMemoryCache();
+builder.Services.AddLogs(builder);
+builder.Services.AddRedis(builder.Configuration);
+builder.Services.AddMongoLayer(builder.Configuration);
+builder.Services.AddDALLayerServices(builder.Configuration);
 
+builder.Host.ConfigureServices((context, services) =>
+{
 
-builder.Services.AddDALLayer(builder.Configuration);
+    services.AddLogging();
+    services.AddControllers();
+    services.AddProblemDetails();
+    services.AddCors(options
+        => options.AddDefaultPolicy(policyBuilder
+            => policyBuilder
+                .AllowAnyOrigin()
+                .AllowAnyHeader()
+                .AllowAnyMethod()));
+
+    builder.Services.Configure<Microsoft.AspNetCore.Http.Json.JsonOptions>(options =>
+    {
+        options.SerializerOptions.Converters.Add(new JsonStringEnumConverter());
+    });
+
+    services.AddHealthChecks();
+    services.AddHttpLogging(options => options.LoggingFields = HttpLoggingFields.All);
+
+    builder.Services.AddOutputCache(options =>
+    {
+        options.AddBasePolicy(builder =>
+            builder.Expire(TimeSpan.FromSeconds(10)));
+        options.AddPolicy("Expire20", builder =>
+            builder.Expire(TimeSpan.FromSeconds(20)));
+        options.AddPolicy("Expire30", builder =>
+            builder.Expire(TimeSpan.FromSeconds(30)));
+    });
+});
 
 var app = builder.Build();
 
+app.UseLogging(builder.Configuration);
 app.UseSwaggerUI(builder.Configuration, authSettings);
 app.ConfigureSwagger(builder.Configuration);
-app.UseLogging(builder.Configuration);
-app.UseHttpsRedirection();
-app.UseAuthorization();
-app.MapControllers();
 
-app.Run();
+app.UseRouting();
+app.UseCors();
+app.UseHttpsRedirection();
+app.UseStaticFiles();
+app.UseResponseCompression();
+app.UseOutputCache();
+app.UseResponseCaching();
+
+app.UseAuthentication();
+app.UseAuthorization();
+
+app.MapControllers();
+app.MapHealthChecks("/health");
+
+app.Run();

Core.Thalos.DAL.API/appsettings.Development.json

@@ -5,4 +5,18 @@
       "Microsoft.AspNetCore": "Warning"
     }
   },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "MongoDB": "mongodb://localhost:27017",
+    "Redis": "localhost:6379"
+  },
+  "MongoDb": {
+    "DatabaseName": "Thalos",
+    "LocalAudience": ""
+  },
+  "DetailedErrors": true,
+  "UseRedisCache": true,
+  "CacheSettings": {
+    "DefaultCacheDurationInMinutes": 3
+  }
 }

Core.Thalos.DAL.API/appsettings.Local.json

@@ -0,0 +1,35 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "MongoDB": "mongodb://admin_agile:Admin%40agileWebs@portainer.white-enciso.pro:27017/?authMechanism=SCRAM-SHA-256",
+    "Redis": "100.123.31.103:6379"
+  },
+  "MongoDb": {
+    "DatabaseName": "Thalos",
+    "LocalAudience": ""
+  },
+  "DetailedErrors": true,
+  "UseRedisCache": true,
+  "CacheSettings": {
+    "DefaultCacheDurationInMinutes": 3
+  },
+  "ServiceSettings": {
+    "ApplicationName": "thalos",
+    "LayerName": "dal"
+  },
+  "Vault": {
+    "Address": "http://100.123.31.103:8200",
+    "Token": "hvs.e37LQvLuPhTd5ALS5QQ03Cwm",
+    "SecretMount": "secret"
+  },
+  "IdentityProviders": {
+    "Google": true,
+    "Azure":  true
+  }
+}

Core.Thalos.DAL.API/appsettings.json

@@ -4,9 +4,5 @@
       "Default": "Information",
       "Microsoft.AspNetCore": "Warning"
     }
-  },
-  "AllowedHosts": "*",
-  "Endpoints": {
-    "AppConfigurationURI": "https://sandbox-hci-usc-appcg.azconfig.io"
   }
 }

Core.Thalos.DAL.API/sample.settings.json

@@ -26,7 +26,7 @@
     "AuthorizationUrl": "", // URL for authorization endpoint (STORED IN KEY VAULT)
     "TokenUrl": "", // URL for token endpoint (STORED IN KEY VAULT)
     "Scope": "", // Scope for application permissions (STORED IN KEY VAULT)
-    "ClientId": "" // Client ID for Kerberos application (STORED IN KEY VAULT)
+    "ClientId": "" // Client ID for Thalos application (STORED IN KEY VAULT)
   },
   "MicrosoftGraph": {
     "Scopes": "", // Scopes for Microsoft Graph API access

Core.Thalos.Domain/Contexts/Onboarding/Mappers/ModuleMapper.cs

@@ -1,42 +0,0 @@
-// ***********************************************************************
-// <copyright file="ModuleMapper.cs">
-//    AgileWebs
-// </copyright>
-// ***********************************************************************
-using Core.Thalos.Adapters;
-using Core.Thalos.Domain.Contexts.Onboarding.Request;
-using Microsoft.AspNetCore.Http;
-using MongoDB.Bson;
-using System.Security.Claims;
-namespace Core.Thalos.Domain.Contexts.Onboarding.Mappers
-{
-    /// <summary>
-    /// Handles mappings between
-    /// <see cref="ModuleRequest"/>,
-    /// and <see cref="ModuleAdapter"/>
-    /// </summary>
-    public static class ModuleMapper
-    {
-        /// <summary>
-        /// Maps the permissionRequest to ModuleAdapter.
-        /// </summary>
-        /// <param name="newModule">The Module to be mapped.</param>
-        /// <returns>A <see cref="ModuleAdapter"/> representing
-        /// the asynchronous execution of the service.</returns>
-        public static ModuleAdapter ToAdapter(this ModuleRequest newModule, IHttpContextAccessor httpContextAccessor)
-        {
-            return new ModuleAdapter
-            {
-                Id = ObjectId.GenerateNewId().ToString(),
-                Name = newModule.Name,
-                Description = newModule.Description,
-                Icon = newModule.Icon,
-                Route = newModule.Route,
-                Order = newModule.Order,
-                Application = newModule.Application,
-                CreatedAt = DateTime.UtcNow,
-                CreatedBy = httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.Email)?.Value ?? string.Empty,
-            };
-        }
-    }
-}

Core.Thalos.Domain/Contexts/Onboarding/Mappers/PermissionMapper.cs

@@ -1,39 +0,0 @@
-// ***********************************************************************
-// <copyright file="PermissionMapper.cs">
-//    AgileWebs
-// </copyright>
-// ***********************************************************************
-using Core.Thalos.Adapters;
-using Core.Thalos.Domain.Contexts.Onboarding.Request;
-using Microsoft.AspNetCore.Http;
-using MongoDB.Bson;
-using System.Security.Claims;
-namespace Core.Thalos.Domain.Contexts.Onboarding.Mappers
-{
-    /// <summary>
-    /// Handles mappings between
-    /// <see cref="PermissionRequest"/>,
-    /// and <see cref="PermissionAdapter"/>
-    /// </summary>
-    public static class PermissionMapper
-    {
-        /// <summary>
-        /// Maps the permissionRequest to PermissionAdapter.
-        /// </summary>
-        /// <param name="newPermission">The Permission to be mapped.</param>
-        /// <returns>A <see cref="PermissionAdapter"/> representing
-        /// the asynchronous execution of the service.</returns>
-        public static PermissionAdapter ToAdapter(this PermissionRequest newPermission, IHttpContextAccessor httpContextAccessor)
-        {
-            return new PermissionAdapter
-            {
-                Id = ObjectId.GenerateNewId().ToString(),
-                Name = newPermission.Name,
-                Description = newPermission.Description,
-                CreatedAt = DateTime.UtcNow,
-                CreatedBy = httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.Email)?.Value ?? string.Empty,
-                AccessLevel = newPermission.AccessLevel
-            };
-        }
-    }
-}

Core.Thalos.Domain/Contexts/Onboarding/Mappers/RoleMapper.cs

@@ -1,42 +0,0 @@
-// ***********************************************************************
-// <copyright file="RoleMapper.cs">
-//    AgileWebs
-// </copyright>
-// ***********************************************************************
-
-using Core.Thalos.Adapters;
-using Core.Thalos.Domain.Contexts.Onboarding.Request;
-using Microsoft.AspNetCore.Http;
-using MongoDB.Bson;
-using System.Security.Claims;
-namespace Core.Thalos.Domain.Contexts.Onboarding.Mappers
-{
-    /// <summary>
-    /// Handles mappings between
-    /// <see cref="RoleRequest"/>,
-    /// and <see cref="RoleAdapter"/>
-    /// </summary>
-    public static class RoleMapper
-    {
-        /// <summary>
-        /// Maps the RoleRequest to RoleAdapter.
-        /// </summary>
-        /// <param name="newRole">The Role to be mapped.</param>
-        /// <returns>A <see cref="RoleAdapter"/> representing
-        /// the asynchronous execution of the service.</returns>
-        public static RoleAdapter ToAdapter(this RoleRequest newRole, IHttpContextAccessor httpContextAccessor)
-        {
-            return new RoleAdapter
-            {
-                Id = ObjectId.GenerateNewId().ToString(),
-                Name = newRole.Name,
-                Description = newRole.Description,
-                Applications = newRole.Applications,
-                Modules = newRole.Modules,
-                Permissions = newRole.Permissions,
-                CreatedAt = DateTime.UtcNow,
-                CreatedBy = httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.Email)?.Value ?? string.Empty
-            };
-        }
-    }
-}

Core.Thalos.Domain/Contexts/Onboarding/Mappers/UserMapper.cs

@@ -1,46 +0,0 @@
-// ***********************************************************************
-// <copyright file="UserMapper.cs">
-//    AgileWebs
-// </copyright>
-// ***********************************************************************
-using Core.Thalos.Adapters;
-using Core.Thalos.Domain.Contexts.Onboarding.Request;
-using Microsoft.AspNetCore.Http;
-using MongoDB.Bson;
-using System.Security.Claims;
-
-namespace Core.Thalos.Domain.Contexts.Onboarding.Mappers
-{
-    /// <summary>
-    /// Handles mappings between
-    /// <see cref="UserRequest"/>,
-    /// and <see cref="UserAdapter"/>
-    /// </summary>
-    public static class UserMapper
-    {
-        /// <summary>
-        /// Maps the UserRequest to UserAdapter.
-        /// </summary>
-        /// <param name="newUser">The User to be mapped.</param>
-        /// <returns>A <see cref="UserAdapter"/> representing
-        /// the asynchronous execution of the service.</returns>
-        public static UserAdapter ToAdapter(this UserRequest newUser, IHttpContextAccessor httpContextAccessor)
-        {
-            return new UserAdapter
-            {
-                Id = ObjectId.GenerateNewId().ToString(),
-                Guid = Guid.NewGuid().ToString(),
-                Email = newUser.Email,
-                Name = newUser.Name,
-                MiddleName = newUser.MiddleName,
-                LastName = newUser.LastName,
-                DisplayName = $"{newUser.Name} {newUser.MiddleName} {newUser.LastName}",
-                RoleId = newUser.RoleId,
-                Companies = newUser.Companies,
-                Projects = newUser.Projects,
-                CreatedAt = DateTime.UtcNow,
-                CreatedBy = httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.Email)?.Value ?? string.Empty
-            };
-        }
-    }
-}

Core.Thalos.Domain/Contexts/Onboarding/Request/ModuleRequest.cs

@@ -4,7 +4,7 @@
 // </copyright>
 // ***********************************************************************
 
-using Core.Thalos.Adapters.Common.Enums;
+using Core.Thalos.BuildingBlocks;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization.Attributes;
 using System.Text.Json.Serialization;

Core.Thalos.Domain/Contexts/Onboarding/Request/PermissionRequest.cs

@@ -4,7 +4,7 @@
 // </copyright>
 // ***********************************************************************
 
-using Core.Thalos.Adapters.Common.Constants;
+using Core.Thalos.BuildingBlocks;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization.Attributes;
 using System.Text.Json.Serialization;

Core.Thalos.Domain/Contexts/Onboarding/Request/RoleRequest.cs

@@ -4,7 +4,7 @@
 // </copyright>
 // ***********************************************************************
 
-using Core.Thalos.Adapters.Common.Enums;
+using Core.Thalos.BuildingBlocks;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization.Attributes;
 using System.Text.Json.Serialization;

Core.Thalos.Domain/Contexts/Onboarding/Request/TenantRequest.cs

@@ -0,0 +1,96 @@
+// ***********************************************************************
+// <copyright file="TenantRequest.cs">
+//     AgileWebs
+// </copyright>
+// ***********************************************************************
+using MongoDB.Bson.Serialization.Attributes;
+
+namespace Core.Thalos.Domain.Contexts.Onboarding.Request
+{
+    /// <summary>
+    /// Represents a tenant creation request with business and contact details.
+    /// </summary>
+    public class TenantRequest
+    {
+        /// <summary>
+        /// The legal or commercial name of the tenant.
+        /// </summary>
+        [BsonElement("name")]
+        public string Name { get; set; } = null!;
+
+        /// <summary>
+        /// The tax identification number of the tenant (e.g., RFC, VAT).
+        /// </summary>
+        [BsonElement("taxIdentifier")]
+        public string TaxIdentifier { get; set; } = null!;
+
+        /// <summary>
+        /// The primary address line (street, number, etc.).
+        /// </summary>
+        [BsonElement("addressLine1")]
+        public string AddressLine1 { get; set; } = null!;
+
+        /// <summary>
+        /// An optional second address line (apartment, suite, etc.).
+        /// </summary>
+        [BsonElement("addressLine2")]
+        [BsonIgnoreIfNull]
+        public string? AddressLine2 { get; set; }
+
+        /// <summary>
+        /// The city where the tenant is located.
+        /// </summary>
+        [BsonElement("city")]
+        public string City { get; set; } = null!;
+
+        /// <summary>
+        /// The state, province, or region of the tenant.
+        /// </summary>
+        [BsonElement("state")]
+        public string State { get; set; } = null!;
+
+        /// <summary>
+        /// The country of the tenant.
+        /// </summary>
+        [BsonElement("country")]
+        public string Country { get; set; } = null!;
+
+        /// <summary>
+        /// The postal or ZIP code of the tenant’s location.
+        /// </summary>
+        [BsonElement("postalCode")]
+        public string PostalCode { get; set; } = null!;
+
+        /// <summary>
+        /// The main email address for contacting the tenant.
+        /// </summary>
+        [BsonElement("contactEmail")]
+        public string ContactEmail { get; set; } = null!;
+
+        /// <summary>
+        /// The main phone number for contacting the tenant.
+        /// </summary>
+        [BsonElement("contactPhone")]
+        public string ContactPhone { get; set; } = null!;
+
+        /// <summary>
+        /// The tenant’s website URL, if available.
+        /// </summary>
+        [BsonElement("website")]
+        [BsonIgnoreIfNull]
+        public string? Website { get; set; }
+
+        /// <summary>
+        /// The database connection string for the tenant, if applicable.
+        /// </summary>
+        [BsonElement("connectionString")]
+        [BsonIgnoreIfNull]
+        public string? ConnectionString { get; set; }
+
+        /// <summary>
+        /// Indicates whether the tenant uses an isolated database.
+        /// </summary>
+        [BsonElement("isolated")]
+        public bool Isolated { get; set; }
+    }
+}

Core.Thalos.Domain/Contexts/Onboarding/Request/UserRequest.cs

@@ -54,19 +54,5 @@ namespace Core.Thalos.Domain.Contexts.Onboarding.Request
         [BsonRepresentation(BsonType.ObjectId)]
         [JsonPropertyName("roleId")]
         public string RoleId { get; set; } = null!;
-
-        /// <summary>
-        /// Gets or sets the array of companies associated with the user.
-        /// </summary>
-        [BsonElement("companies")]
-        [JsonPropertyName("companies")]
-        public string[] Companies { get; set; } = null!;
-
-        /// <summary>
-        /// Gets or sets the array of projects associated with the user.
-        /// </summary>
-        [BsonElement("projects")]
-        [JsonPropertyName("projects")]
-        public string[]? Projects { get; set; }
     }
 }

Core.Thalos.Domain/Core.Thalos.Domain.csproj

@@ -7,7 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Thalos.Building.Blocks" Version="0.0.2" />
+    <PackageReference Include="Core.Blueprint.KeyVault" Version="1.0.3" />
+    <PackageReference Include="Core.Thalos.BuildingBlocks" Version="1.1.8" />
   </ItemGroup>
 
 </Project>

Core.Thalos.Infraestructure/Caching/CacheHelper.cs

@@ -1,30 +0,0 @@
-using Core.Thalos.Infraestructure.Caching.Configs;
-
-namespace LSA.Core.Dapper.Service.Caching
-{
-    public static class CacheHelper
-    {
-        /// <summary>
-        /// Determines the cache duration based on specific duration, settings, or a default value.
-        /// </summary>
-        /// <param name="specificCacheDuration">Specific cache duration in minutes, if provided.</param>
-        /// <param name="cacheSettings">General cache settings containing default duration values.</param>
-        /// <returns>The cache duration as a TimeSpan.</returns>
-        public static TimeSpan GetCacheDuration(CacheSettings cacheSettings, int? specificCacheDuration = 0)
-        {
-            var defaultCacheDuration = TimeSpan.FromMinutes(.5);
-
-            if (specificCacheDuration.HasValue && specificCacheDuration.Value > 0)
-            {
-                return TimeSpan.FromMinutes(specificCacheDuration.Value);
-            }
-
-            if (cacheSettings.DefaultCacheDurationInMinutes > 0)
-            {
-                return TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes);
-            }
-
-            return defaultCacheDuration;
-        }
-    }
-}

Core.Thalos.Infraestructure/Caching/CacheKeyHelper.cs

@@ -1,47 +0,0 @@
-using System.Reflection;
-using System.Text;
-using System.Text.RegularExpressions;
-
-namespace LSA.Core.Dapper.Service.Caching
-{
-    public static class CacheKeyHelper
-    {
-        public static string GenerateCacheKey(object instance, string methodName, params object[] parameters)
-        {
-            var className = instance.GetType().Name;
-            var keyBuilder = new StringBuilder($"{className}.{methodName}");
-
-            foreach (var param in parameters)
-            {
-                string normalizedParam = NormalizeParameter(param);
-                keyBuilder.Append($".{normalizedParam}");
-            }
-
-            return keyBuilder.ToString();
-        }
-
-        private static string NormalizeParameter(object param)
-        {
-            if (param == null)
-            {
-                return "null";
-            }
-
-            string paramString;
-
-            if (param is DateTime dateTime)
-            {
-                paramString = dateTime.ToString("yyyyMMdd");
-            }
-            else
-            {
-                paramString = param.ToString();
-            }
-
-            // Replace special characters with an underscore
-            string normalizedParam = Regex.Replace(paramString, @"[^a-zA-Z0-9]", "_");
-
-            return normalizedParam;
-        }
-    }
-}

Core.Thalos.Infraestructure/Caching/CacheService.cs

@@ -1,133 +0,0 @@
-using Azure.Identity;
-using Core.Thalos.Infraestructure.Caching.Contracts;
-using Microsoft.Extensions.Logging;
-using StackExchange.Redis;
-using System.Text.Json;
-
-namespace LSA.Core.Dapper.Service.Caching
-{
-    public class CacheService : ICacheService
-    {
-        private IDatabase _cacheDatabase = null!;
-        private readonly ILogger<CacheService> _logger;
-
-
-        public CacheService(string connectionString, ILogger<CacheService> logger)
-        {
-            _logger = logger;
-            Task.Run(async () =>
-            {
-                _cacheDatabase = await GetRedisDatabase(connectionString);
-            }).Wait();
-        }
-
-        private async Task<IDatabase> GetRedisDatabase(string connectionString)
-        {
-            try
-            {
-                var configurationOptions = await ConfigurationOptions.Parse($"{connectionString}")
-                    .ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential());
-
-                configurationOptions.AbortOnConnectFail = false;
-                var connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(configurationOptions);
-
-                _logger.LogInformation("Successfully connected to Redis.");
-
-                return connectionMultiplexer.GetDatabase();
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error establishing Redis connection.");
-                throw;
-            }
-        }
-
-
-        public async Task<T> GetAsync<T>(string key)
-        {
-            try
-            {
-                var value = await _cacheDatabase.StringGetAsync(key);
-                if (value.IsNullOrEmpty)
-                {
-                    _logger.LogInformation($"Cache miss for key: {key}");
-                    return default;
-                }
-
-                _logger.LogInformation($"Cache hit for key: {key}");
-                return JsonSerializer.Deserialize<T>(value);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, $"Error getting cache item with key {key}");
-                throw;
-            }
-        }
-
-        public async Task SetAsync<T>(string key, T value, TimeSpan? expiry = null)
-        {
-            try
-            {
-                var json = JsonSerializer.Serialize(value);
-                await _cacheDatabase.StringSetAsync(key, json, expiry);
-                _logger.LogInformation($"Cache item set with key: {key}");
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, $"Error setting cache item with key {key}");
-                throw;
-            }
-        }
-
-        public async Task RemoveAsync(string key)
-        {
-            try
-            {
-                await _cacheDatabase.KeyDeleteAsync(key);
-                _logger.LogInformation($"Cache item removed with key: {key}");
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, $"Error removing cache item with key {key}");
-                throw;
-            }
-        }
-
-        public async Task<bool> ExistsAsync(string key)
-        {
-            try
-            {
-                var exists = await _cacheDatabase.KeyExistsAsync(key);
-                _logger.LogInformation($"Cache item exists check for key: {key} - {exists}");
-                return exists;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, $"Error checking existence of cache item with key {key}");
-                throw;
-            }
-        }
-
-        public async Task RefreshAsync(string key, TimeSpan? expiry = null)
-        {
-            try
-            {
-                var value = await _cacheDatabase.StringGetAsync(key);
-                if (!value.IsNullOrEmpty)
-                {
-                    await _cacheDatabase.StringSetAsync(key, value, expiry);
-                    _logger.LogInformation($"Cache item refreshed with key: {key}");
-                }
-                else
-                {
-                    _logger.LogWarning($"Cache item with key: {key} does not exist, cannot refresh");
-                }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, $"Error refreshing cache item with key {key}");
-                throw;
-            }
-        }
-    }
-}

Core.Thalos.Infraestructure/Caching/Configs/CacheSettings.cs

@@ -1,7 +0,0 @@
-namespace Core.Thalos.Infraestructure.Caching.Configs
-{
-    public class CacheSettings
-    {
-        public int DefaultCacheDurationInMinutes { get; set; }
-    }
-}

Core.Thalos.Infraestructure/Caching/Contracts/ICacheService.cs

@@ -1,11 +0,0 @@
-namespace Core.Thalos.Infraestructure.Caching.Contracts
-{
-    public interface ICacheService
-    {
-        Task<T> GetAsync<T>(string key);
-        Task SetAsync<T>(string key, T value, TimeSpan? expiry = null);
-        Task RemoveAsync(string key);
-        Task<bool> ExistsAsync(string key);
-        Task RefreshAsync(string key, TimeSpan? expiry = null);
-    }
-}

Core.Thalos.Infraestructure/Contexts/Mongo/ConnectionStringProvider.cs

@@ -1,33 +0,0 @@
-using Microsoft.Extensions.Configuration;
-
-namespace Core.Thalos.Infraestructure.Contexts.Mongo
-{
-    public class ConnectionStringProvider(IConfiguration configuration) : IConnectionStringProvider
-    {
-        public string ConnectionString { get; set; } = string.Empty;
-        public string Databasename { get; set; } = string.Empty;
-        public string Audience { get; set; } = string.Empty;
-
-        public string GetConnectionString()
-        {
-            return configuration?.GetConnectionString("DefaultConnection")?.ToString() ?? string.Empty;
-        }
-        public string GetDatabasename()
-        {
-            return configuration.GetSection("MongoDb:DatabaseName").Value ?? string.Empty;
-        }
-
-        public string GetAudience()
-        {
-            return configuration.GetSection("MongoDb:Audience").Value ?? string.Empty;
-        }
-    }
-    public interface IConnectionStringProvider
-    {
-        string GetConnectionString();
-        string GetDatabasename();
-        string ConnectionString { get; set; }
-        string Databasename { get; set; }
-        string Audience { get; set; }
-    }
-}

Core.Thalos.Infraestructure/Contexts/Mongo/MongoConnSettings.cs

@@ -1,14 +0,0 @@
-namespace Core.Thalos.Infraestructure.Contexts.Mongo;
-
-public interface IMongoConnSettings
-{
-    string ConnectionString { get; set; }
-    string Databasename { get; set; }
-    string Audience { get; set; }
-}
-public class MongoConnSettings : IMongoConnSettings
-{
-    public string ConnectionString { get; set; }
-    public string Databasename { get; set; }
-    public string Audience { get; set; }
-}

Core.Thalos.Infraestructure/PerformanceCacheService/CacheAttribute.cs

@@ -1,15 +0,0 @@
-namespace Core.Thalos.Infraestructure.PerformanceCacheService
-{
-    [AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
-    public class CacheAttribute : Attribute
-    {
-        public int CacheDurationInMinutes { get; set; }
-        public bool EnableCaching { get; set; }
-
-        public CacheAttribute(int cacheDurationInMinutes, bool enableCaching = true)
-        {
-            CacheDurationInMinutes = cacheDurationInMinutes;
-            EnableCaching = enableCaching;
-        }
-    }
-}

Core.Thalos.Provider/Contracts/IModuleProvider.cs

@@ -3,62 +3,85 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-using Core.Blueprint.Mongo;
-using Core.Thalos.Adapters;
+
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.Domain.Contexts.Onboarding.Request;
 
 namespace Core.Thalos.Provider.Contracts
 {
+    /// <summary>
+    /// Interface for Module-related service operations.
+    /// </summary>
     public interface IModuleProvider
     {
         /// <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>
+        /// <param name="newModule">The Module to be created.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{ModuleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<ModuleAdapter> CreateModule(ModuleRequest newModule, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Gets an Module by identifier.
+        /// Gets a Module by its identifier.
         /// </summary>
-        /// <param name="id">The Module identifier.</param>
-        /// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="_id">The Module Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{ModuleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<ModuleAdapter> GetModuleById(string _id, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Gets all the roles.
+        /// Gets all Modules.
         /// </summary>
-        /// <returns>A <see cref="{Task{IEnumerbale{ModuleAdapter}}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{ModuleAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<IEnumerable<ModuleAdapter>> GetAllModules(CancellationToken cancellationToken);
 
         /// <summary>
-        /// Gets all the permissions by permissions identifier list.
+        /// Gets all Modules by a list of identifiers.
         /// </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>
+        /// <param name="modules">The list of Module identifiers.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{ModuleAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<IEnumerable<ModuleAdapter>> GetAllModulesByList(string[] modules, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Changes the status of the permission.
+        /// Changes the status of a Module.
         /// </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>
-        ValueTask<ModuleAdapter> ChangeModuleStatus(string id, StatusEnum newStatus, CancellationToken cancellationToken);
+        /// <param name="_id">The Module Mongo identifier.</param>
+        /// <param name="newStatus">The new status of the Module.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{ModuleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<ModuleAdapter?> ChangeModuleStatus(string _id, Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Updates a Module by id.
+        /// Updates a Module by its identifier.
         /// </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>
-        ValueTask<ModuleAdapter> UpdateModule(ModuleAdapter entity, CancellationToken cancellationToken);
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{ModuleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<ModuleAdapter?> UpdateModule(ModuleAdapter entity, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Deletes a Module by its identifier.
+        /// </summary>
+        /// <param name="_id">The Module Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{ModuleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<ModuleAdapter?> DeleteModule(string _id, CancellationToken cancellationToken);
     }
 }

Core.Thalos.Provider/Contracts/IPermissionProvider.cs

@@ -3,62 +3,85 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-using Core.Blueprint.Mongo;
-using Core.Thalos.Adapters;
+
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.Domain.Contexts.Onboarding.Request;
 
 namespace Core.Thalos.Provider.Contracts
 {
+    /// <summary>
+    /// Interface for Permission-related service operations.
+    /// </summary>
     public interface IPermissionProvider
     {
         /// <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>
+        /// <param name="newPermission">The Permission to be created.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{PermissionAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<PermissionAdapter> CreatePermission(PermissionRequest newPermission, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Gets an Permission by identifier.
+        /// Gets a Permission by its identifier.
         /// </summary>
-        /// <param name="id">The Permission identifier.</param>
-        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="_id">The Permission Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{PermissionAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<PermissionAdapter> GetPermissionById(string _id, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Gets all the roles.
+        /// Gets all Permissions.
         /// </summary>
-        /// <returns>A <see cref="{Task{IEnumerbale{PermissionAdapter}}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{PermissionAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<IEnumerable<PermissionAdapter>> GetAllPermissions(CancellationToken cancellationToken);
 
         /// <summary>
-        /// Gets all the permissions by permissions identifier list.
+        /// Gets all Permissions by a list of identifiers.
         /// </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>
+        /// <param name="permissions">The list of Permission identifiers.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{PermissionAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<IEnumerable<PermissionAdapter>> GetAllPermissionsByList(string[] permissions, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Changes the status of the permission.
+        /// Changes the status of a 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>
-        ValueTask<PermissionAdapter> ChangePermissionStatus(string id, StatusEnum newStatus, CancellationToken cancellationToken);
+        /// <param name="_id">The Permission Mongo identifier.</param>
+        /// <param name="newStatus">The new status of the Permission.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{PermissionAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<PermissionAdapter?> ChangePermissionStatus(string _id, Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Updates a Permission by id.
+        /// Updates a Permission.
         /// </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>
-        ValueTask<PermissionAdapter> UpdatePermission(PermissionAdapter entity, CancellationToken cancellationToken);
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{PermissionAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<PermissionAdapter?> UpdatePermission(PermissionAdapter entity, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Deletes a Permission by its identifier.
+        /// </summary>
+        /// <param name="_id">The Permission Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{PermissionAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<PermissionAdapter?> DeletePermission(string _id, CancellationToken cancellationToken);
     }
 }

Core.Thalos.Provider/Contracts/IRoleProvider.cs

@@ -3,70 +3,97 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-using Core.Thalos.Adapters;
-using Core.Thalos.Adapters.Common.Enums;
+
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.Domain.Contexts.Onboarding.Request;
 
 namespace Core.Thalos.Provider.Contracts
 {
+    /// <summary>
+    /// Interface for Role-related service operations.
+    /// </summary>
     public interface IRoleProvider
     {
         /// <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>
+        /// <param name="newRole">The Role to be created.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<RoleAdapter> CreateRole(RoleRequest newRole, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Gets an Role by identifier.
+        /// Gets a Role by its identifier.
         /// </summary>
-        /// <param name="id">The Role identifier.</param>
-        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="_id">The Role Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<RoleAdapter> GetRoleById(string _id, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Gets all the roles.
+        /// Gets all Roles.
         /// </summary>
-        /// <returns>A <see cref="{Task{IEnumerbale{RoleAdapter}}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{RoleAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<IEnumerable<RoleAdapter>> GetAllRoles(CancellationToken cancellationToken);
 
         /// <summary>
-        /// Changes the status of the role.
+        /// Changes the status of a 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>
-        ValueTask<RoleAdapter> ChangeRoleStatus(string id, Core.Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken);
+        /// <param name="_id">The Role Mongo identifier.</param>
+        /// <param name="newStatus">The new status of the Role.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<RoleAdapter?> ChangeRoleStatus(string _id, Core.Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Updates a Role by id.
+        /// Updates a Role.
         /// </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>
-        ValueTask<RoleAdapter> UpdateRole(RoleAdapter entity, CancellationToken cancellationToken);
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<RoleAdapter?> UpdateRole(RoleAdapter entity, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Adds an application to the role's list of applications.
+        /// 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="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>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous operation with the updated Role.
+        /// </returns>
         ValueTask<RoleAdapter> AddApplicationToRole(string roleId, ApplicationsEnum application, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Removes an application from the role's list of applications.
+        /// 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="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>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous operation with the updated Role.
+        /// </returns>
         ValueTask<RoleAdapter> RemoveApplicationFromRole(string roleId, ApplicationsEnum application, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Deletes a Role by its identifier.
+        /// </summary>
+        /// <param name="_id">The Role Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<RoleAdapter?> DeleteRole(string _id, CancellationToken cancellationToken);
     }
 }

Core.Thalos.Provider/Contracts/ITenantProvider.cs

@@ -0,0 +1,77 @@
+// ***********************************************************************
+// <copyright file="ITenantService.cs">
+//     AgileWebs
+// </copyright>
+// ***********************************************************************
+
+using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Domain.Contexts.Onboarding.Request;
+
+namespace Core.Thalos.Provider.Contracts
+{
+    /// <summary>
+    /// Interface for Tenant-related service operations.
+    /// </summary>
+    public interface ITenantProvider
+    {
+        /// <summary>
+        /// Creates a new Tenant.
+        /// </summary>
+        /// <param name="newTenant">The Tenant to be created.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{TenantAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<TenantAdapter> CreateTenant(TenantRequest newTenant, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Gets a Tenant by its identifier.
+        /// </summary>
+        /// <param name="_id">The Tenant Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{TenantAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<TenantAdapter> GetTenantById(string _id, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Gets all Tenants.
+        /// </summary>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{TenantAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<IEnumerable<TenantAdapter>> GetAllTenants(CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Changes the status of a Tenant.
+        /// </summary>
+        /// <param name="_id">The Tenant Mongo identifier.</param>
+        /// <param name="newStatus">The new status of the Tenant.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{TenantAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<TenantAdapter?> ChangeTenantStatus(string _id, Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Updates a Tenant.
+        /// </summary>
+        /// <param name="entity">The Tenant to be updated.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{TenantAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<TenantAdapter?> UpdateTenant(TenantAdapter entity, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Deletes a Tenant by its identifier.
+        /// </summary>
+        /// <param name="_id">The Tenant Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{TenantAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<TenantAdapter?> DeleteTenant(string _id, CancellationToken cancellationToken);
+    }
+}

Core.Thalos.Provider/Contracts/IUserProvider.cs

@@ -3,134 +3,125 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-using Core.Blueprint.Mongo;
-using Core.Thalos.Adapters;
+
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.Domain.Contexts.Onboarding.Request;
 
 namespace Core.Thalos.Provider.Contracts
 {
+    /// <summary>
+    /// Interface for User-related service operations.
+    /// </summary>
     public interface IUserProvider
     {
         /// <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>
+        /// <param name="newUser">The User to be created.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{UserAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<UserAdapter> CreateUser(UserRequest newUser, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Gets an User by identifier.
+        /// Gets a User by Mongo identifier.
         /// </summary>
-        /// <param name="id">The User identifier.</param>
-        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="_id">The User Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{UserAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<UserAdapter> GetUserById(string _id, CancellationToken cancellationToken);
 
-
         /// <summary>
-        /// Gets all the users.
+        /// Gets all Users.
         /// </summary>
-        /// <returns>A <see cref="{Task{IEnumerable{UserAdapter}}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{UserAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<IEnumerable<UserAdapter>> GetAllUsers(CancellationToken cancellationToken);
 
         /// <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>
-        ValueTask<UserAdapter> GetUserByEmail(string? email, CancellationToken cancellationToken);
-
-        /// <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>
-        ValueTask<UserAdapter> ValidateUserExistence(string? email, CancellationToken cancellationToken);
-
-        /// <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>
-        ValueTask<UserAdapter> ChangeUserStatus(string id, StatusEnum newStatus, CancellationToken cancellationToken);
-
-        /// <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>
-        ValueTask<UserAdapter> UpdateUser(UserAdapter entity, CancellationToken cancellationToken);
-
-        /// <summary>
-        /// Logs in the user.
+        /// Gets a User by email.
         /// </summary>
         /// <param name="email">The User's email.</param>
-        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{UserAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<UserAdapter> GetUserByEmail(string email, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Validates if a User exists by email.
+        /// </summary>
+        /// <param name="email">The User's email.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{UserExistenceAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<UserExistenceAdapter> ValidateUserExistence(string email, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Changes the status of a User.
+        /// </summary>
+        /// <param name="_id">The User Mongo identifier.</param>
+        /// <param name="newStatus">The new status of the User.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{UserAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<UserAdapter?> ChangeUserStatus(string _id, Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Updates a User.
+        /// </summary>
+        /// <param name="entity">The User to be updated.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{UserAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<UserAdapter?> UpdateUser(UserAdapter entity, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Logs in the User.
+        /// </summary>
+        /// <param name="email">The User's email.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{UserAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<UserAdapter?> LogInUser(string email, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Logs out the user's session.
+        /// 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>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{UserAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<UserAdapter?> LogOutUserSession(string email, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Adds a company to the user's list of companies.
+        /// Gets the TokenAdapter for a User.
         /// </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>
-        ValueTask<UserAdapter> AddCompanyToUser(string userId, string companyId, CancellationToken cancellationToken);
-
-        /// <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>
-        ValueTask<UserAdapter> RemoveCompanyFromUser(string userId, string companyId, CancellationToken cancellationToken);
-
-        /// <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>
-        ValueTask<UserAdapter> AddProjectToUser(string userId, string projectId, CancellationToken cancellationToken);
-
-
-        /// <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>
-        ValueTask<UserAdapter> RemoveProjectFromUser(string userId, string projectId, CancellationToken cancellationToken);
-
-        /// <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>
+        /// <param name="email">The User's email.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{TokenAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         ValueTask<TokenAdapter?> GetToken(string email, CancellationToken cancellationToken);
 
         /// <summary>
-        /// Delete an User by identifier.
+        /// Deletes a User by Mongo identifier.
         /// </summary>
-        /// <param name="id">The User identifier.</param>
-        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
-        /// the asynchronous execution of the service.</returns>
-        ValueTask<UserAdapter> DeleteUser(string _id, CancellationToken cancellationToken);
+        /// <param name="_id">The User Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{UserAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        ValueTask<UserAdapter?> DeleteUser(string _id, CancellationToken cancellationToken);
     }
 }

Core.Thalos.Provider/Core.Thalos.Provider.csproj

@@ -11,15 +11,13 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Blueprint.Mongo" Version="0.0.3" />
-    <PackageReference Include="Blueprint.Redis" Version="0.0.1" />
-    <PackageReference Include="BuildingBlocks.Library" Version="0.0.1" />
+    <PackageReference Include="Core.Blueprint.Mongo" Version="1.0.1" />
+    <PackageReference Include="Core.Blueprint.Redis" Version="1.0.2" />
     <PackageReference Include="Mapster" Version="7.4.2-pre02" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\Core.Thalos.Domain\Core.Thalos.Domain.csproj" />
-    <ProjectReference Include="..\Core.Thalos.Infraestructure\Core.Thalos.Infrastructure.csproj" />
   </ItemGroup>
 
 </Project>

Core.Thalos.Provider/Providers/BaseProvider.cs

@@ -1,16 +0,0 @@
-using MongoDB.Driver;
-
-namespace Core.Thalos.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.Thalos.Provider/Providers/HeathOidcCallback.cs

@@ -1,99 +0,0 @@
-using Azure.Core;
-using Azure.Identity;
-using Core.Thalos.Adapters.Common.Constants;
-using MongoDB.Driver.Authentication.Oidc;
-
-namespace Core.Thalos.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.Thalos.Provider/Providers/Onboarding/ModuleProvider.cs

@@ -3,15 +3,16 @@
 //     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.BuildingBlocks;
 using Core.Thalos.Domain.Contexts.Onboarding.Request;
+using Core.Thalos.Provider.Contracts;
+using Mapster;
+using MongoDB.Driver;
+using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
 
 namespace Core.Thalos.Provider.Providers.Onboarding
 {
@@ -21,58 +22,63 @@ namespace Core.Thalos.Provider.Providers.Onboarding
     public class ModuleProvider : IModuleProvider
     {
         private readonly CollectionRepository<ModuleAdapter> repository;
-        private readonly CacheSettings cacheSettings;
+        private readonly ICacheSettings cacheSettings;
         private readonly IRedisCacheProvider cacheProvider;
 
-        public ModuleProvider(CollectionRepository<ModuleAdapter> repository,
-        IRedisCacheProvider cacheProvider, IOptions<CacheSettings> cacheSettings)
+        public ModuleProvider(
+            CollectionRepository<ModuleAdapter> repository,
+            IRedisCacheProvider cacheProvider,
+            ICacheSettings cacheSettings)
         {
             this.repository = repository;
             this.repository.CollectionInitialization();
-            this.cacheSettings = cacheSettings.Value;
             this.cacheProvider = cacheProvider;
+            this.cacheSettings = cacheSettings;
         }
 
         /// <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>
+        /// <param name="newModule">The Module to be created.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{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.
+        /// Gets a 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
+        /// <param name="_id">The Module Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{ModuleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         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; }
+            if (cachedData is not null) return cachedData;
 
             var module = await repository.FindByIdAsync(_id);
-
-            await cacheProvider.SetAsync(cacheKey, module);
+            await cacheProvider.SetAsync(cacheKey, module, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
 
             return module;
         }
 
         /// <summary>
-        /// Gets all the modules.
+        /// Gets all the Modules.
         /// </summary>
-        /// <returns>A <see cref="{Task{IEnumerbale{ModuleAdapter}}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{ModuleAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
         public async ValueTask<IEnumerable<ModuleAdapter>> GetAllModules(CancellationToken cancellationToken)
         {
             var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetModules");
@@ -81,22 +87,22 @@ namespace Core.Thalos.Provider.Providers.Onboarding
             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.
+        /// Gets all the Modules by a list of identifiers.
         /// </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>
+        /// <param name="modules">The list of Module identifiers.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{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;
@@ -104,49 +110,66 @@ namespace Core.Thalos.Provider.Providers.Onboarding
             var builder = Builders<ModuleAdapter>.Filter;
             var filters = new List<FilterDefinition<ModuleAdapter>>();
 
-            if (modules == null || !modules.Any())
+            if (modules is { Length: > 0 })
             {
-                filters.Add(builder.In(x => x.Id, modules));
+                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);
-
+            await cacheProvider.SetAsync(cacheKey, modulesList, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
             return modulesList;
         }
 
-
         /// <summary>
-        /// Changes the status of the module.
+        /// 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)
+        /// <param name="_id">The Module Mongo identifier.</param>
+        /// <param name="newStatus">The new status of the Module.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{ModuleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        public async ValueTask<ModuleAdapter?> ChangeModuleStatus(string _id, StatusEnum newStatus, CancellationToken cancellationToken)
         {
-            var entity = await repository.FindByIdAsync(id);
-            entity.Status = newStatus;
+            var entity = await repository.FindByIdAsync(_id);
 
-            await repository.ReplaceOneAsync(entity);
+            if (entity is not null)
+            {
+                entity.Status = newStatus;
 
-            return entity;
+                return repository.ReplaceOneAsync(entity).Result;
+            }
+            else return null;
         }
 
         /// <summary>
-        /// Updates a Module by id.
+        /// Updates a Module.
         /// </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)
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{ModuleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        public async ValueTask<ModuleAdapter?> UpdateModule(ModuleAdapter entity, CancellationToken cancellationToken)
         {
-            await repository.ReplaceOneAsync(entity);
+            var updatedEntity = await repository.ReplaceOneAsync(entity);
+            return updatedEntity;
+        }
 
+        /// <summary>
+        /// Deletes a Module by identifier.
+        /// </summary>
+        /// <param name="_id">The Module Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{ModuleAdapter}"/> representing the asynchronous deletion result.
+        /// The deleted Module entity if found; otherwise, null.
+        /// </returns>
+        public async ValueTask<ModuleAdapter?> DeleteModule(string _id, CancellationToken cancellationToken)
+        {
+            var entity = await this.repository.DeleteOneAsync(doc => doc._Id == _id);
             return entity;
         }
     }

Core.Thalos.Provider/Providers/Onboarding/PermissionProvider.cs

@@ -3,15 +3,15 @@
 //     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.BuildingBlocks;
 using Core.Thalos.Domain.Contexts.Onboarding.Request;
+using Core.Thalos.Provider.Contracts;
+using Mapster;
+using MongoDB.Driver;
 
 namespace Core.Thalos.Provider.Providers.Onboarding
 {
@@ -21,58 +21,63 @@ namespace Core.Thalos.Provider.Providers.Onboarding
     public class PermissionProvider : IPermissionProvider
     {
         private readonly CollectionRepository<PermissionAdapter> repository;
-        private readonly CacheSettings cacheSettings;
+        private readonly ICacheSettings cacheSettings;
         private readonly IRedisCacheProvider cacheProvider;
 
-        public PermissionProvider(CollectionRepository<PermissionAdapter> repository,
-        IRedisCacheProvider cacheProvider, IOptions<CacheSettings> cacheSettings)
+        public PermissionProvider(
+            CollectionRepository<PermissionAdapter> repository,
+            IRedisCacheProvider cacheProvider,
+            ICacheSettings cacheSettings)
         {
             this.repository = repository;
             this.repository.CollectionInitialization();
-            this.cacheSettings = cacheSettings.Value;
             this.cacheProvider = cacheProvider;
+            this.cacheSettings = cacheSettings;
         }
 
         /// <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>
+        /// <param name="newPermission">The Permission to be created.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{PermissionAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         public async ValueTask<PermissionAdapter> CreatePermission(PermissionRequest newPermission, CancellationToken cancellationToken)
         {
             var permissionCollection = newPermission.Adapt<PermissionAdapter>();
-
             await repository.InsertOneAsync(permissionCollection);
-
             return permissionCollection;
         }
 
         /// <summary>
-        /// Gets an Permission by identifier.
+        /// Gets a 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
+        /// <param name="_id">The Permission Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{PermissionAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         public async ValueTask<PermissionAdapter> GetPermissionById(string _id, CancellationToken cancellationToken)
         {
             var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetPermissionById", _id);
             var cachedData = await cacheProvider.GetAsync<PermissionAdapter>(cacheKey);
 
-            if (cachedData is not null) { return cachedData; }
+            if (cachedData is not null) return cachedData;
 
             var permission = await repository.FindByIdAsync(_id);
-
             await cacheProvider.SetAsync(cacheKey, permission);
 
             return permission;
         }
 
         /// <summary>
-        /// Gets all the permissions.
+        /// Gets all Permissions.
         /// </summary>
-        /// <returns>A <see cref="{Task{IEnumerbale{PermissionAdapter}}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{PermissionAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
         public async ValueTask<IEnumerable<PermissionAdapter>> GetAllPermissions(CancellationToken cancellationToken)
         {
             var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllPermissions");
@@ -81,22 +86,22 @@ namespace Core.Thalos.Provider.Providers.Onboarding
             if (cachedData.Any()) return cachedData;
 
             var permissions = await repository.AsQueryable();
-
-            await cacheProvider.SetAsync(cacheKey, permissions);
+            await cacheProvider.SetAsync(cacheKey, permissions, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
 
             return permissions;
         }
 
         /// <summary>
-        /// Gets all the permissions by permissions identifier list.
+        /// Gets all Permissions by a list of identifiers.
         /// </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>
+        /// <param name="permissions">The list of Permission identifiers.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{PermissionAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
         public async ValueTask<IEnumerable<PermissionAdapter>> GetAllPermissionsByList(string[] permissions, CancellationToken cancellationToken)
         {
             var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllPermissionsByList", permissions);
-
             var cachedData = await cacheProvider.GetAsync<IEnumerable<PermissionAdapter>>(cacheKey) ?? [];
 
             if (cachedData.Any()) return cachedData;
@@ -104,49 +109,66 @@ namespace Core.Thalos.Provider.Providers.Onboarding
             var builder = Builders<PermissionAdapter>.Filter;
             var filters = new List<FilterDefinition<PermissionAdapter>>();
 
-            if (permissions == null || !permissions.Any())
+            if (permissions is { Length: > 0 })
             {
-                filters.Add(builder.In(x => x.Id, permissions));
+                filters.Add(builder.In(x => x._Id, permissions));
             }
 
             var finalFilter = filters.Any() ? builder.And(filters) : builder.Empty;
-
             var permissionsList = await repository.FilterByMongoFilterAsync(finalFilter);
 
-            await cacheProvider.SetAsync(cacheKey, permissionsList);
-
+            await cacheProvider.SetAsync(cacheKey, permissionsList, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
             return permissionsList;
         }
 
-
         /// <summary>
-        /// Changes the status of the permission.
+        /// Changes the status of a 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 ValueTask<PermissionAdapter> ChangePermissionStatus(string id, StatusEnum newStatus, CancellationToken cancellationToken)
+        /// <param name="_id">The Permission Mongo identifier.</param>
+        /// <param name="newStatus">The new status of the Permission.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{PermissionAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        public async ValueTask<PermissionAdapter?> ChangePermissionStatus(string _id, Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken)
         {
-            var entity = await repository.FindByIdAsync(id);
-            entity.Status = newStatus;
+            var entity = await repository.FindByIdAsync(_id);
 
-            await repository.ReplaceOneAsync(entity);
+            if (entity is not null)
+            {
+                entity.Status = newStatus;
 
-            return entity;
+                return repository.ReplaceOneAsync(entity).Result;
+            }
+            else return null;
         }
 
         /// <summary>
-        /// Updates a Permission by id.
+        /// Updates a Permission.
         /// </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 ValueTask<PermissionAdapter> UpdatePermission(PermissionAdapter entity, CancellationToken cancellationToken)
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{PermissionAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        public async ValueTask<PermissionAdapter?> UpdatePermission(PermissionAdapter entity, CancellationToken cancellationToken)
         {
-            await repository.ReplaceOneAsync(entity);
+            var updatedEntity = await repository.ReplaceOneAsync(entity);
+            return updatedEntity;
+        }
 
+        /// <summary>
+        /// Deletes a Permission by identifier.
+        /// </summary>
+        /// <param name="_id">The Permission Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{PermissionAdapter}"/> representing the asynchronous deletion result.
+        /// The deleted Permission entity if found; otherwise, null.
+        /// </returns>
+        public async ValueTask<PermissionAdapter?> DeletePermission(string _id, CancellationToken cancellationToken)
+        {
+            var entity = await this.repository.DeleteOneAsync(doc => doc._Id == _id);
             return entity;
         }
     }

Core.Thalos.Provider/Providers/Onboarding/RoleProvider.cs

@@ -3,21 +3,15 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-using Core.Thalos.Adapters;
-using Core.Thalos.Adapters.Common.Enums;
+
 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 MongoDB.Bson;
-using System.Text.RegularExpressions;
-using MongoDB.Bson.Serialization;
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.Domain.Contexts.Onboarding.Request;
-using Microsoft.Graph;
-using System.ComponentModel.Design;
+using Core.Thalos.Provider.Contracts;
+using Mapster;
+using MongoDB.Driver;
 
 namespace Core.Thalos.Provider.Providers.Onboarding
 {
@@ -27,58 +21,63 @@ namespace Core.Thalos.Provider.Providers.Onboarding
     public class RoleProvider : IRoleProvider
     {
         private readonly CollectionRepository<RoleAdapter> repository;
-        private readonly CacheSettings cacheSettings;
+        private readonly ICacheSettings cacheSettings;
         private readonly IRedisCacheProvider cacheProvider;
 
-        public RoleProvider(CollectionRepository<RoleAdapter> repository,
-        IRedisCacheProvider cacheProvider, IOptions<CacheSettings> cacheSettings)
+        public RoleProvider(
+            CollectionRepository<RoleAdapter> repository,
+            IRedisCacheProvider cacheProvider,
+            ICacheSettings cacheSettings)
         {
             this.repository = repository;
             this.repository.CollectionInitialization();
-            this.cacheSettings = cacheSettings.Value;
             this.cacheProvider = cacheProvider;
+            this.cacheSettings = cacheSettings;
         }
 
         /// <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>
+        /// <param name="newRole">The Role to be created.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         public async ValueTask<RoleAdapter> CreateRole(RoleRequest newRole, CancellationToken cancellationToken)
         {
             var roleCollection = newRole.Adapt<RoleAdapter>();
-
             await repository.InsertOneAsync(roleCollection);
-
             return roleCollection;
         }
 
         /// <summary>
-        /// Gets an Role by identifier.
+        /// Gets a Role by its identifier.
         /// </summary>
-        /// <param name="id">The Role identifier.</param>
-        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="_id">The Role Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
         public async ValueTask<RoleAdapter> GetRoleById(string _id, CancellationToken cancellationToken)
         {
             var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetRoleById", _id);
             var cachedData = await cacheProvider.GetAsync<RoleAdapter>(cacheKey);
 
-            if (cachedData is not null) { return cachedData; }
+            if (cachedData is not null) return cachedData;
 
             var role = await repository.FindByIdAsync(_id);
-
-            await cacheProvider.SetAsync(cacheKey, role);
+            await cacheProvider.SetAsync(cacheKey, role, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
 
             return role;
         }
 
         /// <summary>
-        /// Gets all the roles.
+        /// Gets all Roles.
         /// </summary>
-        /// <returns>A <see cref="{Task{IEnumerbale{RoleAdapter}}}"/> representing
-        /// the asynchronous execution of the service.</returns>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{RoleAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
         public async ValueTask<IEnumerable<RoleAdapter>> GetAllRoles(CancellationToken cancellationToken)
         {
             var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllRoles");
@@ -87,84 +86,105 @@ namespace Core.Thalos.Provider.Providers.Onboarding
             if (cachedData.Any()) return cachedData;
 
             var roles = await repository.AsQueryable();
-
-            await cacheProvider.SetAsync(cacheKey, roles);
+            await cacheProvider.SetAsync(cacheKey, roles, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
 
             return roles;
         }
 
         /// <summary>
-        /// Changes the status of the role.
+        /// Changes the status of a 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 ValueTask<RoleAdapter> ChangeRoleStatus(string id, Core.Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken)
+        /// <param name="_id">The Role Mongo identifier.</param>
+        /// <param name="newStatus">The new status of the Role.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        public async ValueTask<RoleAdapter?> ChangeRoleStatus(string _id, Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken)
         {
-            var entity = await repository.FindByIdAsync(id);
-            entity.Status = newStatus;
+            var entity = await repository.FindByIdAsync(_id);
 
-            await repository.ReplaceOneAsync(entity);
+            if (entity is not null)
+            {
+                entity.Status = newStatus;
 
-            return entity;
+                return repository.ReplaceOneAsync(entity).Result;
+            }
+            else return null;
         }
 
         /// <summary>
-        /// Updates a Role by id.
+        /// Updates a Role.
         /// </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 ValueTask<RoleAdapter> UpdateRole(RoleAdapter entity, CancellationToken cancellationToken)
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        public async ValueTask<RoleAdapter?> UpdateRole(RoleAdapter entity, CancellationToken cancellationToken)
         {
-            await repository.ReplaceOneAsync(entity);
-
-            return entity;
+            var updatedEntity = await repository.ReplaceOneAsync(entity);
+            return updatedEntity;
         }
 
         /// <summary>
-        /// Adds an application to the role's list of applications.
+        /// 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="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>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous operation, with the updated Role object.
+        /// </returns>
         public async ValueTask<RoleAdapter> AddApplicationToRole(string roleId, ApplicationsEnum application, CancellationToken cancellationToken)
         {
             var role = await repository.FindOneAsync(
-                u => u.Id == roleId &&
-                u.Status == Core.Blueprint.Mongo.StatusEnum.Active);
+                u => u._Id == roleId && u.Status == Blueprint.Mongo.StatusEnum.Active);
 
-            var updatedApplications = role.Applications.Append(application).Distinct().ToArray();
+            var updatedApplications = role.Applications?.Append(application).Distinct().ToArray();
             role.Applications = updatedApplications;
 
+            await repository.ReplaceOneAsync(role);
+            return role;
+        }
+
+        /// <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>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous operation, with the updated Role object.
+        /// </returns>
+        public async ValueTask<RoleAdapter> RemoveApplicationFromRole(string roleId, ApplicationsEnum application, CancellationToken cancellationToken)
+        {
+            var role = await repository.FindOneAsync(
+                u => u._Id == roleId && u.Status == Blueprint.Mongo.StatusEnum.Active);
+
+            var updatedApplications = role.Applications?
+                .Where(c => c != application)
+                .ToArray();
+
+            role.Applications = updatedApplications;
             await repository.ReplaceOneAsync(role);
 
             return role;
         }
 
         /// <summary>
-        /// Removes an application from the role's list of applications.
+        /// Deletes a Role by identifier.
         /// </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 ValueTask<RoleAdapter> RemoveApplicationFromRole(string roleId, ApplicationsEnum application, CancellationToken cancellationToken)
+        /// <param name="_id">The Role Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous deletion result.
+        /// The deleted Role entity if found; otherwise, null.
+        /// </returns>
+        public async ValueTask<RoleAdapter?> DeleteRole(string _id, CancellationToken cancellationToken)
         {
-            var role = await repository.FindOneAsync(
-                u => u.Id == roleId &&
-                u.Status == Core.Blueprint.Mongo.StatusEnum.Active);
-
-            var updatedApplications = role.Applications
-                    ?.Where(c => c != application)
-                    .ToArray();
-
-            role.Applications = updatedApplications;
-
-            await repository.ReplaceOneAsync(role);
-
-            return role;
+            var entity = await repository.DeleteOneAsync(doc => doc._Id == _id);
+            return entity;
         }
     }
 }

Core.Thalos.Provider/Providers/Onboarding/TenantProvider.cs

@@ -0,0 +1,144 @@
+// ***********************************************************************
+// <copyright file="TenantService.cs">
+//     AgileWebs
+// </copyright>
+// ***********************************************************************
+
+using Core.Blueprint.Mongo;
+using Core.Blueprint.Redis;
+using Core.Blueprint.Redis.Helpers;
+using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Domain.Contexts.Onboarding.Request;
+using Core.Thalos.Provider.Contracts;
+using Mapster;
+
+namespace Core.Thalos.Provider.Providers.Onboarding
+{
+    /// <summary>
+    /// Handles all services and business rules related to <see cref="TenantAdapter"/>.
+    /// </summary>
+    public class TenantProvider : ITenantProvider
+    {
+        private readonly CollectionRepository<TenantAdapter> repository;
+        private readonly ICacheSettings cacheSettings;
+        private readonly IRedisCacheProvider cacheProvider;
+
+        public TenantProvider(
+            CollectionRepository<TenantAdapter> repository,
+            IRedisCacheProvider cacheProvider,
+            ICacheSettings cacheSettings)
+        {
+            this.repository = repository;
+            this.repository.CollectionInitialization();
+            this.cacheSettings = cacheSettings;
+            this.cacheProvider = cacheProvider;
+        }
+
+        /// <summary>
+        /// Creates a new Tenant.
+        /// </summary>
+        /// <param name="newTenant">The Tenant to be created.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{TenantAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        public async ValueTask<TenantAdapter> CreateTenant(TenantRequest newTenant, CancellationToken cancellationToken)
+        {
+            var tenant = newTenant.Adapt<TenantAdapter>();
+            await repository.InsertOneAsync(tenant);
+            return tenant;
+        }
+
+        /// <summary>
+        /// Gets a Tenant by identifier.
+        /// </summary>
+        /// <param name="_id">The Tenant Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{TenantAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        public async ValueTask<TenantAdapter> GetTenantById(string _id, CancellationToken cancellationToken)
+        {
+            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetTenantById", _id);
+            var cachedData = await cacheProvider.GetAsync<TenantAdapter>(cacheKey);
+
+            if (cachedData is not null) return cachedData;
+
+            var tenant = await repository.FindByIdAsync(_id);
+            await cacheProvider.SetAsync(cacheKey, tenant, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
+
+            return tenant;
+        }
+
+        /// <summary>
+        /// Gets all Tenants.
+        /// </summary>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{IEnumerable{TenantAdapter}}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        public async ValueTask<IEnumerable<TenantAdapter>> GetAllTenants(CancellationToken cancellationToken)
+        {
+            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetTenants");
+            var cachedData = await cacheProvider.GetAsync<IEnumerable<TenantAdapter>>(cacheKey) ?? [];
+
+            if (cachedData.Any()) return cachedData;
+
+            var tenants = await repository.AsQueryable();
+            await cacheProvider.SetAsync(cacheKey, tenants, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
+
+            return tenants;
+        }
+
+        /// <summary>
+        /// Changes the status of a Tenant.
+        /// </summary>
+        /// <param name="_id">The Tenant Mongo identifier.</param>
+        /// <param name="newStatus">The new status of the Tenant.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{TenantAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        public async ValueTask<TenantAdapter?> ChangeTenantStatus(string _id, Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken)
+        {
+            var entity = await repository.FindByIdAsync(_id);
+
+            if (entity is not null)
+            {
+                entity.Status = newStatus;
+
+                return repository.ReplaceOneAsync(entity).Result;
+            }
+            else return null;
+        }
+
+        /// <summary>
+        /// Updates a Tenant.
+        /// </summary>
+        /// <param name="entity">The Tenant to be updated.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{TenantAdapter}"/> representing the asynchronous execution of the service.
+        /// </returns>
+        public async ValueTask<TenantAdapter?> UpdateTenant(TenantAdapter entity, CancellationToken cancellationToken)
+        {
+            var updatedEntity = await repository.ReplaceOneAsync(entity);
+            return updatedEntity;
+        }
+
+        /// <summary>
+        /// Deletes a Tenant by identifier.
+        /// </summary>
+        /// <param name="_id">The Tenant Mongo identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>
+        /// A <see cref="ValueTask{TenantAdapter}"/> representing the asynchronous deletion result.
+        /// The deleted Tenant entity if found; otherwise, null.
+        /// </returns>
+        public async ValueTask<TenantAdapter?> DeleteTenant(string _id, CancellationToken cancellationToken)
+        {
+            var entity = await repository.DeleteOneAsync(doc => doc._Id == _id);
+            return entity;
+        }
+    }
+}

Core.Thalos.Provider/Providers/Onboarding/UserProvider.cs

@@ -4,18 +4,16 @@
 // </copyright>
 // ***********************************************************************
 
-using Core.Thalos.Adapters;
-using Core.Thalos.Adapters.Common.Enums;
 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.BuildingBlocks;
 using Core.Thalos.Provider.Contracts;
+using Mapster;
 using MongoDB.Bson;
-using System.Text.RegularExpressions;
 using MongoDB.Bson.Serialization;
+using MongoDB.Driver;
+using System.Text.RegularExpressions;
 
 namespace Core.Thalos.Provider.Providers.Onboarding
 {
@@ -25,15 +23,17 @@ namespace Core.Thalos.Provider.Providers.Onboarding
     public class UserProvider : IUserProvider
     {
         private readonly CollectionRepository<UserAdapter> repository;
-        private readonly CacheSettings cacheSettings;
+        private readonly ICacheSettings cacheSettings;
         private readonly IRedisCacheProvider cacheProvider;
 
         public UserProvider(CollectionRepository<UserAdapter> repository,
-        IRedisCacheProvider cacheProvider, IOptions<CacheSettings> cacheSettings)
+            IRedisCacheProvider cacheProvider,
+            ICacheSettings cacheSettings
+            )
         {
             this.repository = repository;
             this.repository.CollectionInitialization();
-            this.cacheSettings = cacheSettings.Value;
+            this.cacheSettings = cacheSettings;
             this.cacheProvider = cacheProvider;
         }
 
@@ -55,7 +55,7 @@ namespace Core.Thalos.Provider.Providers.Onboarding
         /// <summary>
         /// Gets an User by identifier.
         /// </summary>
-        /// <param name="id">The User identifier.</param>
+        /// <param name="_id">The User mongo identifier.</param>
         /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
         /// the asynchronous execution of the service.</returns>
         public async ValueTask<UserAdapter> GetUserById(string _id, CancellationToken cancellationToken)
@@ -67,7 +67,7 @@ namespace Core.Thalos.Provider.Providers.Onboarding
 
             var user = await repository.FindByIdAsync(_id);
 
-            await cacheProvider.SetAsync(cacheKey, user);
+            await cacheProvider.SetAsync(cacheKey, user, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
 
             return user;
         }
@@ -86,7 +86,7 @@ namespace Core.Thalos.Provider.Providers.Onboarding
 
             var users = await repository.AsQueryable();
 
-            await cacheProvider.SetAsync(cacheKey, users);
+            await cacheProvider.SetAsync(cacheKey, users, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
 
             return users;
         }
@@ -97,15 +97,15 @@ namespace Core.Thalos.Provider.Providers.Onboarding
         /// <param name="email">The User email.</param>
         /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
         /// the asynchronous execution of the service.</returns>
-        public async ValueTask<UserAdapter> GetUserByEmail(string? email, CancellationToken cancellationToken)
+        public async ValueTask<UserAdapter> GetUserByEmail(string email, CancellationToken cancellationToken)
         {
             var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetUserByEmail", email);
             var cachedData = await cacheProvider.GetAsync<UserAdapter>(cacheKey);
 
-            if (cachedData is not null) { return cachedData; }
+            //if (cachedData is not null) { return cachedData; }
 
             var user = await repository.FindOneAsync(
-                u => u.Email == email && 
+                u => u.Email == email &&
                 u.Status == Core.Blueprint.Mongo.StatusEnum.Active);
 
             await cacheProvider.SetAsync(cacheKey, user);
@@ -119,57 +119,63 @@ namespace Core.Thalos.Provider.Providers.Onboarding
         /// <param name="email">The User email.</param>
         /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
         /// the asynchronous execution of the service.</returns>
-        public async ValueTask<UserAdapter> ValidateUserExistence(string? email, CancellationToken cancellationToken)
+        public async ValueTask<UserExistenceAdapter> ValidateUserExistence(string email, CancellationToken cancellationToken)
         {
             var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetUserByEmail", email);
             var cachedData = await cacheProvider.GetAsync<UserAdapter>(cacheKey);
 
-            if (cachedData is not null) { return cachedData; }
+            //if (cachedData is not null) { return cachedData; }
 
             var user = await repository.FindOneAsync(
                 u => u.Email == email &&
                 u.Status == Core.Blueprint.Mongo.StatusEnum.Active);
 
-            await cacheProvider.SetAsync(cacheKey, user);
+            UserExistenceAdapter userExistance = new UserExistenceAdapter();
 
-            return user;
+            userExistance.Existence = (user != null) ? true : false;
+
+            await cacheProvider.SetAsync(cacheKey, userExistance);
+
+            return userExistance;
         }
 
         /// <summary>
         /// Changes the status of the user.
         /// </summary>
-        /// <param name="id">The user identifier.</param>
+        /// <param name="_id">The user mongo 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>
-        public async ValueTask<UserAdapter> ChangeUserStatus(string id, Core.Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken)
+        public async ValueTask<UserAdapter?> ChangeUserStatus(string _id, Core.Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken)
         {
-            var entity = await repository.FindByIdAsync(id);
-            entity.Status = newStatus;
+            var entity = await repository.FindByIdAsync(_id);
 
-            await repository.ReplaceOneAsync(entity);
+            if (entity is not null)
+            {
+                entity.Status = newStatus;
 
-            return entity;
+                return repository.ReplaceOneAsync(entity).Result;
+            }
+            else return null;
         }
 
         /// <summary>
-        /// Updates a User by id.
+        /// Updates a User by _id.
         /// </summary>
         /// <param name="entity">The User to be updated.</param>
-        /// <param name="id">The User identifier.</param>
+        /// <param name="_id">The User mongo identifier.</param>
         /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
         /// the asynchronous execution of the service.</returns>
-        public async ValueTask<UserAdapter> UpdateUser(UserAdapter entity, CancellationToken cancellationToken)
+        public async ValueTask<UserAdapter?> UpdateUser(UserAdapter entity, CancellationToken cancellationToken)
         {
-            await repository.ReplaceOneAsync(entity);
-
-            return entity;
+            var updatedEntity = await repository.ReplaceOneAsync(entity);
+            return updatedEntity;
         }
 
         /// <summary>
         /// Logs in the user.
         /// </summary>
-        /// <param name="id">The User identifier.</param>
+        /// <param name="_id">The User mongo identifier.</param>
         /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
         /// the asynchronous execution of the service.</returns>
         public async ValueTask<UserAdapter?> LogInUser(string email, CancellationToken cancellationToken)
@@ -204,92 +210,6 @@ namespace Core.Thalos.Provider.Providers.Onboarding
             return user;
         }
 
-        /// <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>
-        public async ValueTask<UserAdapter> AddCompanyToUser(string userId, string companyId, CancellationToken cancellationToken)
-        {
-            var user = await repository.FindOneAsync(
-                u => u.Id == userId &&
-                u.Status == Core.Blueprint.Mongo.StatusEnum.Active);
-
-            var updatedCompanies = user.Companies.Append(companyId).Distinct().ToArray();
-            user.Companies = updatedCompanies;
-
-            await repository.ReplaceOneAsync(user);
-
-            return user;
-        }
-
-        /// <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>
-        public async ValueTask<UserAdapter> RemoveCompanyFromUser(string userId, string companyId, CancellationToken cancellationToken)
-        {
-            var user = await repository.FindOneAsync(
-                u => u.Id == userId &&
-                u.Status == Core.Blueprint.Mongo.StatusEnum.Active);
-
-            var updatedCompanies = user.Companies
-                    ?.Where(c => c != companyId)
-                    .ToArray();
-
-            user.Companies = updatedCompanies;
-
-            await repository.ReplaceOneAsync(user);
-
-            return user;
-        }
-
-        /// <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>
-        public async ValueTask<UserAdapter> AddProjectToUser(string userId, string projectId, CancellationToken cancellationToken)
-        {
-            var user = await repository.FindOneAsync(
-                u => u.Id == userId &&
-                u.Status == Core.Blueprint.Mongo.StatusEnum.Active);
-
-            var updatedProjects = user.Projects.Append(projectId).Distinct().ToArray();
-            user.Companies = updatedProjects;
-
-            await repository.ReplaceOneAsync(user);
-
-            return user;
-        }
-
-        /// <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>
-        public async ValueTask<UserAdapter> RemoveProjectFromUser(string userId, string projectId, CancellationToken cancellationToken)
-        {
-            var user = await repository.FindOneAsync(
-                u => u.Id == userId &&
-                u.Status == Core.Blueprint.Mongo.StatusEnum.Active);
-
-            var updatedProjects = user.Projects
-                    ?.Where(c => c != projectId)
-                    .ToArray();
-
-            user.Companies = updatedProjects;
-
-            await repository.ReplaceOneAsync(user);
-
-            return user;
-        }
-
         /// <summary>
         /// Gets the token adapter for a user.
         /// </summary>
@@ -323,6 +243,16 @@ namespace Core.Thalos.Provider.Providers.Onboarding
                     new BsonDocument("$unwind", "$role"),
                     new BsonDocument("$match", new BsonDocument("role.status", Core.Blueprint.Mongo.StatusEnum.Active.ToString())),
 
+                    // Tenant lookup
+                    new BsonDocument("$lookup", new BsonDocument
+                    {
+                        { "from", "Tenants" },
+                        { "localField", "tenantId" },
+                        { "foreignField", "_id" },
+                        { "as", "tenant" }
+                    }),
+                    new BsonDocument("$unwind", "$tenant"),
+
                     new BsonDocument("$addFields", new BsonDocument
                     {
                         { "role.permissions", new BsonDocument("$map", new BsonDocument
@@ -385,6 +315,25 @@ namespace Core.Thalos.Provider.Providers.Onboarding
                         { "role.updatedAt", 1 },
                         { "role.createdBy", 1 },
                         { "role.updatedBy", 1 },
+                        { "tenant._id", 1 },
+                        { "tenant.name", 1 },
+                        { "tenant.taxIdentifier", 1 },
+                        { "tenant.addressLine1", 1 },
+                        { "tenant.addressLine2", 1 },
+                        { "tenant.city", 1 },
+                        { "tenant.state", 1 },
+                        { "tenant.country", 1 },
+                        { "tenant.postalCode", 1 },
+                        { "tenant.contactEmail", 1 },
+                        { "tenant.contactPhone", 1 },
+                        { "tenant.website", 1 },
+                        { "tenant.connectionString", 1 },
+                        { "tenant.isolated", 1 },
+                        { "tenant.status", 1 },
+                        { "tenant.createdAt", 1 },
+                        { "tenant.updatedAt", 1 },
+                        { "tenant.createdBy", 1 },
+                        { "tenant.updatedBy", 1 },
                         { "permissions", 1 },
                         { "modules", 1 }
                     })
@@ -398,54 +347,163 @@ namespace Core.Thalos.Provider.Providers.Onboarding
                 {
                     User = new UserAdapter
                     {
-                        Id = result["_id"]?.ToString() ?? "",
-                        Guid = result["guid"].AsString,
-                        Email = result["email"].AsString,
-                        Name = result["name"].AsString,
-                        MiddleName = result["middleName"].AsString,
-                        LastName = result["lastName"].AsString,
-                        DisplayName = result["displayName"].AsString,
-                        RoleId = result["roleId"]?.ToString() ?? "",
-                        Companies = result["companies"].AsBsonArray
-                            .Select(c => c.AsString)
-                            .ToArray(),
-                        Projects = result["projects"].AsBsonArray
-                            .Select(c => c.AsString)
-                            .ToArray(),
-                        LastLogIn = result["lastLogIn"].ToUniversalTime(),
-                        LastLogOut = result["lastLogOut"].ToUniversalTime(),
-                        CreatedAt = result["createdAt"].ToUniversalTime(),
-                        CreatedBy = result["createdBy"].AsString,
-                        UpdatedAt = result["updatedAt"].ToUniversalTime(),
-                        UpdatedBy = result["updatedBy"].AsString,
-                        Status = (Core.Blueprint.Mongo.StatusEnum)Enum.Parse(typeof(Core.Blueprint.Mongo.StatusEnum), result["status"].AsString),
+                        _Id = result["_id"]?.ToString() ?? "",
+                        Email = result.Contains("email") && !result["email"].IsBsonNull ? result["email"].AsString : string.Empty,
+                        Name = result.Contains("name") && !result["name"].IsBsonNull ? result["name"].AsString : string.Empty,
+                        MiddleName = result.Contains("middleName") && !result["middleName"].IsBsonNull ? result["middleName"].AsString : string.Empty,
+                        LastName = result.Contains("lastName") && !result["lastName"].IsBsonNull ? result["lastName"].AsString : string.Empty,
+                        DisplayName = result.Contains("displayName") && !result["displayName"].IsBsonNull ? result["displayName"].AsString : string.Empty,
+                        RoleId = result.Contains("roleId") && !result["roleId"].IsBsonNull ? result["roleId"].ToString() : string.Empty,
+                        LastLogIn = result.Contains("lastLogIn") && !result["lastLogIn"].IsBsonNull ? result["lastLogIn"].ToUniversalTime() : DateTime.MinValue,
+                        LastLogOut = result.Contains("lastLogOut") && !result["lastLogOut"].IsBsonNull ? result["lastLogOut"].ToUniversalTime() : DateTime.MinValue,
+                        CreatedAt = result.Contains("createdAt") && !result["createdAt"].IsBsonNull ? result["createdAt"].ToUniversalTime() : DateTime.MinValue,
+                        CreatedBy = result.Contains("createdBy") && !result["createdBy"].IsBsonNull ? result["createdBy"].AsString : string.Empty,
+                        UpdatedAt = result.Contains("updatedAt") && !result["updatedAt"].IsBsonNull ? result["updatedAt"].ToUniversalTime() : DateTime.MinValue,
+                        UpdatedBy = result.Contains("updatedBy") && !result["updatedBy"].IsBsonNull ? result["updatedBy"].AsString : string.Empty,
+                        Status = result.Contains("status") && !result["status"].IsBsonNull
+                            ? (Core.Blueprint.Mongo.StatusEnum)Enum.Parse(typeof(Core.Blueprint.Mongo.StatusEnum), result["status"].AsString)
+                            : Core.Blueprint.Mongo.StatusEnum.Inactive
                     },
                     Role = new RoleAdapter
                     {
-                        Id = result["role"]["_id"]?.ToString() ?? "",
-                        Name = result["role"]["name"].AsString,
-                        Description = result["role"]["description"].AsString,
-                        Applications = result["role"]["applications"].AsBsonArray
-                            .Select(c => (ApplicationsEnum)c.AsInt32)
-                            .ToArray(),
-                        Modules = result["role"]["modules"].AsBsonArray
-                            .Select(c => c.ToString() ?? "")
-                            .ToArray(),
-                        Permissions = result["role"]["permissions"].AsBsonArray
-                            .Select(c => c.ToString() ?? "")
-                            .ToArray(),
-                        Status = (Core.Blueprint.Mongo.StatusEnum)Enum.Parse(typeof(Core.Blueprint.Mongo.StatusEnum), result["role"]["status"].AsString),
-                        CreatedAt = result["role"]["createdAt"].ToUniversalTime(),
-                        UpdatedAt = result["role"]["updatedAt"].ToUniversalTime(),
-                        CreatedBy = result["role"]["createdBy"].AsString,
-                        UpdatedBy = result["role"]["updatedBy"].AsString
+                        Id = result.Contains("role") && result["role"].IsBsonDocument && result["role"].AsBsonDocument.Contains("_id")
+                            ? result["role"]["_id"]?.ToString() ?? ""
+                            : string.Empty,
+                        Name = result.Contains("role") && result["role"].IsBsonDocument && result["role"].AsBsonDocument.Contains("name")
+                            ? result["role"]["name"]?.AsString ?? ""
+                            : string.Empty,
+                        Description = result.Contains("role") && result["role"].IsBsonDocument && result["role"].AsBsonDocument.Contains("description")
+                            ? result["role"]["description"]?.AsString ?? ""
+                            : string.Empty,
+                        Applications = result.Contains("role") && result["role"].IsBsonDocument &&
+                       result["role"].AsBsonDocument.Contains("applications") &&
+                       result["role"]["applications"].IsBsonArray
+                            ? result["role"]["applications"].AsBsonArray
+                                .Where(app => app != null && app.IsInt32)
+                                .Select(app => (ApplicationsEnum)app.AsInt32)
+                                .ToArray()
+                            : Array.Empty<ApplicationsEnum>(),
+                        Modules = result.Contains("role") && result["role"].IsBsonDocument &&
+                            result["role"].AsBsonDocument.Contains("modules") &&
+                            result["role"]["modules"].IsBsonArray
+                            ? result["role"]["modules"].AsBsonArray
+                                .Where(m => m != null)
+                                .Select(m => m.ToString() ?? "")
+                                .ToArray()
+                            : Array.Empty<string>(),
+                        Permissions = result.Contains("role") && result["role"].IsBsonDocument &&
+                            result["role"].AsBsonDocument.Contains("permissions") &&
+                            result["role"]["permissions"].IsBsonArray
+                            ? result["role"]["permissions"].AsBsonArray
+                                .Where(p => p != null)
+                                .Select(p => p.ToString() ?? "")
+                                .ToArray()
+                            : Array.Empty<string>(),
+                        Status = result.Contains("role") && result["role"].IsBsonDocument &&
+                             result["role"].AsBsonDocument.Contains("status") &&
+                             !result["role"]["status"].IsBsonNull
+                            ? (Core.Blueprint.Mongo.StatusEnum)Enum.Parse(typeof(Core.Blueprint.Mongo.StatusEnum), result["role"]["status"].AsString)
+                            : Core.Blueprint.Mongo.StatusEnum.Inactive,
+                        CreatedAt = result.Contains("role") && result["role"].IsBsonDocument &&
+                            result["role"].AsBsonDocument.Contains("createdAt") &&
+                            !result["role"]["createdAt"].IsBsonNull
+                            ? result["role"]["createdAt"].ToUniversalTime()
+                            : DateTime.MinValue,
+                        UpdatedAt = result.Contains("role") && result["role"].IsBsonDocument &&
+                            result["role"].AsBsonDocument.Contains("updatedAt") &&
+                            !result["role"]["updatedAt"].IsBsonNull
+                            ? result["role"]["updatedAt"].ToUniversalTime()
+                            : DateTime.MinValue,
+                        CreatedBy = result.Contains("role") && result["role"].IsBsonDocument &&
+                            result["role"].AsBsonDocument.Contains("createdBy") &&
+                            !result["role"]["createdBy"].IsBsonNull
+                            ? result["role"]["createdBy"].AsString
+                            : string.Empty,
+                        UpdatedBy = result.Contains("role") && result["role"].IsBsonDocument &&
+                            result["role"].AsBsonDocument.Contains("updatedBy") &&
+                            !result["role"]["updatedBy"].IsBsonNull
+                            ? result["role"]["updatedBy"].AsString
+                            : string.Empty
                     },
-                    Permissions = result["permissions"].AsBsonArray
-                        .Select(permission => BsonSerializer.Deserialize<PermissionAdapter>(permission.AsBsonDocument))
-                        .Where(permission => permission.Status == Core.Blueprint.Mongo.StatusEnum.Active)
+                    Tenant = result.Contains("tenant") && result["tenant"].IsBsonDocument
+                    ? new TenantAdapter
+                    {
+                        Id = result.Contains("tenant") && result["tenant"].IsBsonDocument && result["tenant"].AsBsonDocument.Contains("_id")
+                            ? result["tenant"]["_id"]?.ToString() ?? ""
+                            : string.Empty,
+                        Name = result["tenant"].AsBsonDocument.Contains("name") && !result["tenant"]["name"].IsBsonNull
+                            ? result["tenant"]["name"].AsString
+                            : string.Empty,
+                        TaxIdentifier = result["tenant"].AsBsonDocument.Contains("taxIdentifier") && !result["tenant"]["taxIdentifier"].IsBsonNull
+                            ? result["tenant"]["taxIdentifier"].AsString
+                            : string.Empty,
+                        AddressLine1 = result["tenant"].AsBsonDocument.Contains("addressLine1") && !result["tenant"]["addressLine1"].IsBsonNull
+                            ? result["tenant"]["addressLine1"].AsString
+                            : string.Empty,
+                        AddressLine2 = result["tenant"].AsBsonDocument.Contains("addressLine2") && !result["tenant"]["addressLine2"].IsBsonNull
+                            ? result["tenant"]["addressLine2"].AsString
+                            : null,
+                        City = result["tenant"].AsBsonDocument.Contains("city") && !result["tenant"]["city"].IsBsonNull
+                            ? result["tenant"]["city"].AsString
+                            : string.Empty,
+                        State = result["tenant"].AsBsonDocument.Contains("state") && !result["tenant"]["state"].IsBsonNull
+                            ? result["tenant"]["state"].AsString
+                            : string.Empty,
+                        Country = result["tenant"].AsBsonDocument.Contains("country") && !result["tenant"]["country"].IsBsonNull
+                            ? result["tenant"]["country"].AsString
+                            : string.Empty,
+                        PostalCode = result["tenant"].AsBsonDocument.Contains("postalCode") && !result["tenant"]["postalCode"].IsBsonNull
+                            ? result["tenant"]["postalCode"].AsString
+                            : string.Empty,
+                        ContactEmail = result["tenant"].AsBsonDocument.Contains("contactEmail") && !result["tenant"]["contactEmail"].IsBsonNull
+                            ? result["tenant"]["contactEmail"].AsString
+                            : string.Empty,
+                        ContactPhone = result["tenant"].AsBsonDocument.Contains("contactPhone") && !result["tenant"]["contactPhone"].IsBsonNull
+                            ? result["tenant"]["contactPhone"].AsString
+                            : string.Empty,
+                        Website = result["tenant"].AsBsonDocument.Contains("website") && !result["tenant"]["website"].IsBsonNull
+                            ? result["tenant"]["website"].AsString
+                            : null,
+                        ConnectionString = result["tenant"].AsBsonDocument.Contains("connectionString") && !result["tenant"]["connectionString"].IsBsonNull
+                            ? result["tenant"]["connectionString"].AsString
+                            : null,
+                        Isolated = result["tenant"].AsBsonDocument.Contains("isolated") && !result["tenant"]["isolated"].IsBsonNull
+                            ? result["tenant"]["isolated"].ToBoolean()
+                            : false,
+                        CreatedAt = result["tenant"].AsBsonDocument.Contains("createdAt") && !result["tenant"]["createdAt"].IsBsonNull
+                            ? result["tenant"]["createdAt"].ToUniversalTime()
+                            : DateTime.MinValue,
+                        UpdatedAt = result["tenant"].AsBsonDocument.Contains("updatedAt") && !result["tenant"]["updatedAt"].IsBsonNull
+                            ? result["tenant"]["updatedAt"].ToUniversalTime()
+                            : DateTime.MinValue,
+                        CreatedBy = result["tenant"].AsBsonDocument.Contains("createdBy") && !result["tenant"]["createdBy"].IsBsonNull
+                            ? result["tenant"]["createdBy"].AsString
+                            : string.Empty,
+                        UpdatedBy = result["tenant"].AsBsonDocument.Contains("updatedBy") && !result["tenant"]["updatedBy"].IsBsonNull
+                            ? result["tenant"]["updatedBy"].AsString
+                            : string.Empty,
+                        Status = result["tenant"].AsBsonDocument.Contains("status") && !result["tenant"]["status"].IsBsonNull
+                            ? (Core.Blueprint.Mongo.StatusEnum)Enum.Parse(typeof(Core.Blueprint.Mongo.StatusEnum), result["tenant"]["status"].AsString)
+                            : Core.Blueprint.Mongo.StatusEnum.Active
+                    }
+                    : null,
+                    Permissions = result.Contains("permissions") && result["permissions"].IsBsonArray
+                        ? result["permissions"].AsBsonArray
+                            .Where(p => p != null && p.IsBsonDocument)
+                            .Select(p => BsonSerializer.Deserialize<PermissionAdapter>(p.AsBsonDocument))
+                            .Where(p => p.Status == Core.Blueprint.Mongo.StatusEnum.Active)
+                            .ToList()
+                        : new List<PermissionAdapter>(),
+                    Modules = result.Contains("modules") && result["modules"].IsBsonArray
+                    ? result["modules"].AsBsonArray
+                        .Where(p => p != null && p.IsBsonDocument)
+                        .Select(p => BsonSerializer.Deserialize<ModuleAdapter>(p.AsBsonDocument))
+                        .Where(p => p.Status == Core.Blueprint.Mongo.StatusEnum.Active)
                         .ToList()
+                    : new List<ModuleAdapter>()
                 };
 
+
                 return tokenAdapter;
 
             }
@@ -456,12 +514,12 @@ namespace Core.Thalos.Provider.Providers.Onboarding
         }
 
         /// <summary>
-        /// Deletes an User by id.
+        /// Deletes an User by _id.
         /// </summary>
-        /// <param name="id">The User identifier.</param>
+        /// <param name="_id">The User mongo identifier.</param>
         /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
         /// the asynchronous execution of the service.</returns>
-        public async ValueTask<UserAdapter> DeleteUser(string _id, CancellationToken cancellationToken)
+        public async ValueTask<UserAdapter?> DeleteUser(string _id, CancellationToken cancellationToken)
         {
             var entity = await repository.DeleteOneAsync(doc => doc.Id == _id);
 

Core.Thalos.Provider/ServiceCollectionExtensions.cs

@@ -1,100 +1,31 @@
-using Core.Thalos.Infraestructure.Caching.Contracts;
-using Core.Thalos.Infraestructure.Contexts.Mongo;
+using Core.Blueprint.Mongo;
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.Provider.Contracts;
-using Core.Thalos.Provider.Providers;
 using Core.Thalos.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.Thalos.Provider
 {
     public static class ServiceCollectionExtensions
     {
-        public static IServiceCollection AddDALLayer(this IServiceCollection services, IConfiguration configuration)
+        public static IServiceCollection AddDALLayerServices(this IServiceCollection services, IConfiguration configuration)
         {
-            var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? string.Empty;
+            //Mongo
+            services.AddScoped<IModuleProvider, ModuleProvider>();
+            services.AddScoped<CollectionRepository<ModuleAdapter>>();
 
-            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;
+            services.AddScoped<IPermissionProvider, PermissionProvider>();
+            services.AddScoped<CollectionRepository<PermissionAdapter>>();
 
-            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);
-
-            return services;
-        }
-
-
-        private static IServiceCollection AddDALConfigurationLayer(this IServiceCollection services)
-        {
-            services.AddHttpContextAccessor();
+            services.AddScoped<IRoleProvider, RoleProvider>();
+            services.AddScoped<CollectionRepository<RoleAdapter>>();
 
             services.AddScoped<IUserProvider, UserProvider>();
-            services.AddScoped<IRoleProvider, RoleProvider>();
-            services.AddScoped<IPermissionProvider, PermissionProvider>();
-            services.AddScoped<IPermissionProvider, PermissionProvider>();
-            services.AddScoped<IModuleProvider, ModuleProvider>();
-            return services;
-        }
+            services.AddScoped<CollectionRepository<UserAdapter>>();
 
-        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>>()));
+            services.AddScoped<ITenantProvider, TenantProvider>();
+            services.AddScoped<CollectionRepository<TenantAdapter>>();
 
             return services;
         }