Update .gitea/workflows/pipeline.yml

feat: added inital test pipeline
2025-07-20 23:23:36 +00:00 · 2025-07-19 00:18:55 -06:00
28 changed files with 983 additions and 1303 deletions
--- a/.gitea/workflows/pipeline.yml
+++ b/.gitea/workflows/pipeline.yml
@@ -0,0 +1,19 @@
+name: Core Thalos DAL - Deploy
+run-name: ${{ gitea.actor }} is testing out Gitea Actions
+on: [push]
+
+jobs:
+  Explore-Gitea-Actions:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo "The job was automatically triggered by a ${{ gitea.event_name }} event."
+      - run: echo "This job is now running on a ${{ runner.os }} server hosted by Gitea!"
+      - run: echo "The name of your branch is ${{ gitea.ref }} and your repository is ${{ gitea.repository }}."
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - run: echo "The ${{ gitea.repository }} repository has been cloned to the runner."
+      - run: echo "The workflow is now ready to test your code on the runner."
+      - name: List files in the repository
+        run: |
+          ls ${{ gitea.workspace }}
+      - run: echo "This job's status is ${{ job.status }}."
--- a/Core.Thalos.DAL.API/Controllers/ModuleController.cs
+++ b/Core.Thalos.DAL.API/Controllers/ModuleController.cs
@@ -5,68 +5,98 @@
 // ***********************************************************************

 using Asp.Versioning;
-using Core.Thalos.BuildingBlocks;
+using Core.Blueprint.Mongo;
+using Core.Thalos.Adapters;
+using Core.Thalos.Adapters.Attributes;
+using Core.Thalos.Adapters.Common.Constants;
 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.Thalos.API.Controllers
 {
    /// <summary>
-    /// Handles all requests for module management.
+    /// Handles all requests for module authentication.
    /// </summary>
    [ApiVersion(MimeTypes.ApplicationVersion)]
    [Route("api/v{api-version:apiVersion}/[controller]")]
    [Produces(MimeTypes.ApplicationJson)]
    [Consumes(MimeTypes.ApplicationJson)]
    [ApiController]
-    [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+    [AllowAnonymous]
    public class ModuleController(IModuleProvider service) : ControllerBase
    {
        /// <summary>
-        /// Gets all modules.
+        /// Gets all the 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)]
-        [Permission("ModuleManagement.Read, RoleManagement.Read")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("ModuleManagement.Read, RoleManagement.Read")]
        public async Task<IActionResult> GetAllModulesAsync(CancellationToken cancellationToken)
        {
-            var result = await service.GetAllModules(cancellationToken);
+            var result = await service.GetAllModules(cancellationToken).ConfigureAwait(false);
            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)]
-        [Permission("ModuleManagement.Read")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[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);
+            var result = await service.GetAllModulesByList(modules, cancellationToken).ConfigureAwait(false);
            return Ok(result);
        }

+
        /// <summary>
-        /// Gets the module by mongo identifier.
+        /// Gets the module by 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)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        [Permission("ModuleManagement.Read")]
-        public async Task<IActionResult> GetModuleByIdAsync([FromRoute] string _id, CancellationToken cancellationToken)
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("ModuleManagement.Read")]
+        public async Task<IActionResult> GetModuleByIdAsync([FromRoute] string id, CancellationToken cancellationToken)
        {
-            var result = await service.GetModuleById(_id, cancellationToken);
+            var result = await service.GetModuleById(id, cancellationToken).ConfigureAwait(false);

            if (result == null)
-                return NotFound("Module not found");
+            {
+                return NotFound("Entity not found");
+            }

            return Ok(result);
        }
@@ -74,71 +104,70 @@ namespace LSA.Core.Thalos.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)]
-        [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
-        [Permission("ModuleManagement.Write")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("ModuleManagement.Write")]
        public async Task<IActionResult> CreateModuleAsync([FromBody] ModuleRequest newModule, CancellationToken cancellationToken)
        {
-            var result = await service.CreateModule(newModule, cancellationToken);
+            var result = await service.CreateModule(newModule, cancellationToken).ConfigureAwait(false);
            return Created("CreatedWithIdAsync", result);
        }

        /// <summary>
-        /// Updates a full module by mongo identifier.
+        /// Updates a full module by 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)]
-        [ProducesResponseType(StatusCodes.Status400BadRequest)]
-        [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
-        [Permission("ModuleManagement.Write")]
-        public async Task<IActionResult> UpdateModuleAsync([FromRoute] string _id, [FromBody] ModuleAdapter entity, CancellationToken cancellationToken)
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("ModuleManagement.Write")]
+        public async Task<IActionResult> UpdateModuleAsync([FromRoute] string id, ModuleAdapter entity, CancellationToken cancellationToken)
        {
-            if (_id != entity._Id)
+            if (id != entity.Id?.ToString())
+            {
                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)]
-        [Permission("ModuleManagement.Write")]
-        public async Task<IActionResult> ChangeModuleStatus([FromRoute] string _id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("ModuleManagement.Write")]
+        public async Task<IActionResult> ChangeModuleStatus([FromRoute] string id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
        {
-            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");
-
+            var result = await service.ChangeModuleStatus(id, newStatus, cancellationToken).ConfigureAwait(false);
            return Ok(result);
        }
    }
--- a/Core.Thalos.DAL.API/Controllers/PermissionController.cs
+++ b/Core.Thalos.DAL.API/Controllers/PermissionController.cs
@@ -5,12 +5,15 @@
 // ***********************************************************************

 using Asp.Versioning;
-using Core.Thalos.BuildingBlocks;
+using Core.Blueprint.Mongo;
+using Core.Thalos.Adapters;
+using Core.Thalos.Adapters.Attributes;
+using Core.Thalos.Adapters.Common.Constants;
 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.Thalos.API.Controllers
 {
@@ -22,21 +25,21 @@ namespace LSA.Core.Thalos.API.Controllers
    [Produces(MimeTypes.ApplicationJson)]
    [Consumes(MimeTypes.ApplicationJson)]
    [ApiController]
-    [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
    public class PermissionController(IPermissionProvider service) : ControllerBase
    {
        /// <summary>
-        /// Gets all permissions.
+        /// Gets all the 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 permissions found.</response>
+        /// <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<PermissionAdapter>), StatusCodes.Status200OK)]
-        [Permission("PermissionManagement.Read, RoleManagement.Read")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("PermissionManagement.Read, RoleManagement.Read")]
        public async Task<IActionResult> GetAllPermissionsAsync(CancellationToken cancellationToken)
        {
            var result = await service.GetAllPermissions(cancellationToken).ConfigureAwait(false);
@@ -47,17 +50,17 @@ namespace LSA.Core.Thalos.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="400">Bad request if list is null or empty.</response>
+        /// <response code="404">The permissions not found error.</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)]
-        [Permission("PermissionManagement.Read")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("PermissionManagement.Read")]
        public async Task<IActionResult> GetAllPermissionsByList([FromBody] string[] permissions, CancellationToken cancellationToken)
        {
            if (permissions == null || !permissions.Any())
@@ -70,27 +73,27 @@ namespace LSA.Core.Thalos.API.Controllers
        }

        /// <summary>
-        /// Gets the permission by mongo identifier.
+        /// Gets the permission by identifier.
        /// </summary>
-        /// <param name="_id">The permission mongo identifier.</param>
-        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <param name="id">The permission identifier.</param>
        /// <returns>The <see cref="PermissionAdapter"/> found entity.</returns>
        /// <response code="200">The permission found.</response>
-        /// <response code="404">The permission not found.</response>
+        /// <response code="404">The permission not found error.</response>
        /// <response code="500">The service internal error.</response>
        [HttpGet]
        [Route(Routes.Id)]
        [Consumes(MimeTypes.ApplicationJson)]
        [Produces(MimeTypes.ApplicationJson)]
        [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
-        [Permission("PermissionManagement.Read")]
-        public async Task<IActionResult> GetPermissionByIdAsync([FromRoute] string _id, CancellationToken cancellationToken)
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("PermissionManagement.Read")]
+        public async Task<IActionResult> GetPermissionByIdAsync([FromRoute] string id, CancellationToken cancellationToken)
        {
-            var result = await service.GetPermissionById(_id, cancellationToken).ConfigureAwait(false);
+            var result = await service.GetPermissionById(id, cancellationToken).ConfigureAwait(false);

            if (result == null)
            {
-                return NotFound("Permission not found");
+                return NotFound("Entity not found");
            }

            return Ok(result);
@@ -100,14 +103,14 @@ namespace LSA.Core.Thalos.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">Internal server error.</response>
+        /// <response code="500">The service internal e|ror.</response>
        [HttpPost]
        [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status201Created)]
-        [Permission("PermissionManagement.Write")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("PermissionManagement.Write")]
        public async Task<IActionResult> CreatePermissionAsync([FromBody] PermissionRequest newPermission, CancellationToken cancellationToken)
        {
            var result = await service.CreatePermission(newPermission, cancellationToken).ConfigureAwait(false);
@@ -115,25 +118,25 @@ namespace LSA.Core.Thalos.API.Controllers
        }

        /// <summary>
-        /// Updates a full permission by mongo identifier.
+        /// Updates a full permission by identifier.
        /// </summary>
-        /// <param name="_id">The permission mongo identifier.</param>
        /// <param name="entity">The permission to update.</param>
-        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <param name="id">The permission identifier.</param>
        /// <returns>The <see cref="PermissionAdapter"/> updated entity.</returns>
        /// <response code="200">The permission updated.</response>
-        /// <response code="400">Bad request if ID mismatch.</response>
+        /// <response code="404">The permission not found.</response>
        /// <response code="422">The permission could not be updated.</response>
-        /// <response code="500">Internal server error.</response>
+        /// <response code="500">The service internal error.</response>
        [HttpPut]
        [Route(Routes.Id)]
        [Consumes(MimeTypes.ApplicationJson)]
        [Produces(MimeTypes.ApplicationJson)]
        [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
-        [Permission("PermissionManagement.Write")]
-        public async Task<IActionResult> UpdatePermissionAsync([FromRoute] string _id, [FromBody] PermissionAdapter entity, CancellationToken cancellationToken)
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("PermissionManagement.Write")]
+        public async Task<IActionResult> UpdatePermissionAsync([FromRoute] string id, PermissionAdapter entity, CancellationToken cancellationToken)
        {
-            if (_id != entity._Id)
+            if (id != entity.Id?.ToString())
            {
                return BadRequest("Permission ID mismatch");
            }
@@ -146,48 +149,23 @@ namespace LSA.Core.Thalos.API.Controllers
        /// <summary>
        /// Changes the status of the permission.
        /// </summary>
-        /// <param name="_id">The permission mongo identifier.</param>
+        /// <param name="id">The permission 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 status was updated.</response>
-        /// <response code="500">Internal server error.</response>
+        /// <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>
        [HttpPatch]
        [Route(Routes.ChangeStatus)]
        [Consumes(MimeTypes.ApplicationJson)]
        [Produces(MimeTypes.ApplicationJson)]
        [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
-        [Permission("PermissionManagement.Write")]
-        public async Task<IActionResult> ChangePermissionStatus([FromRoute] string _id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[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);
-
-            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.");
-
+            var result = await service.ChangePermissionStatus(id, newStatus, cancellationToken).ConfigureAwait(false);
            return Ok(result);
        }
    }
--- a/Core.Thalos.DAL.API/Controllers/RoleController.cs
+++ b/Core.Thalos.DAL.API/Controllers/RoleController.cs
@@ -3,9 +3,11 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-
 using Asp.Versioning;
-using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Adapters;
+using Core.Thalos.Adapters.Attributes;
+using Core.Thalos.Adapters.Common.Constants;
+using Core.Thalos.Adapters.Common.Enums;
 using Core.Thalos.Domain.Contexts.Onboarding.Request;
 using Core.Thalos.Provider.Contracts;
 using Microsoft.AspNetCore.Authorization;
@@ -22,19 +24,19 @@ namespace LSA.Core.Thalos.API.Controllers
    [Produces(MimeTypes.ApplicationJson)]
    [Consumes(MimeTypes.ApplicationJson)]
    [ApiController]
-    [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
    public class RoleController(IRoleProvider service) : ControllerBase
    {
        /// <summary>
-        /// Gets all roles.
+        /// Gets all the roles.
        /// </summary>
-        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
-        /// <returns>The <see cref="IEnumerable{RoleAdapter}"/> found entities.</returns>
+        /// <returns>The rol 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)]
-        [Permission("RoleManagement.Read")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("RoleManagement.Read")]
        public async Task<IActionResult> GetAllRolesAsync(CancellationToken cancellationToken)
        {
            var result = await service.GetAllRoles(cancellationToken).ConfigureAwait(false);
@@ -42,25 +44,25 @@ namespace LSA.Core.Thalos.API.Controllers
        }

        /// <summary>
-        /// Gets the role by mongo identifier.
+        /// Gets the role by identifier.
        /// </summary>
-        /// <param name="_id">The role mongo identifier.</param>
-        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <param name="id">The role identifier.</param>
        /// <returns>The <see cref="RoleAdapter"/> found entity.</returns>
        /// <response code="200">The role found.</response>
-        /// <response code="404">The role not found.</response>
+        /// <response code="404">The role not found error.</response>
        /// <response code="500">The service internal error.</response>
        [HttpGet]
        [Route(Routes.Id)]
        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
-        [Permission("RoleManagement.Read")]
-        public async Task<IActionResult> GetRoleByIdAsync([FromRoute] string _id, CancellationToken cancellationToken)
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("RoleManagement.Read")]
+        public async Task<IActionResult> GetRoleByIdAsync([FromRoute] string id, CancellationToken cancellationToken)
        {
-            var result = await service.GetRoleById(_id, cancellationToken).ConfigureAwait(false);
+            var result = await service.GetRoleById(id, cancellationToken).ConfigureAwait(false);

            if (result == null)
            {
-                return NotFound("Role not found");
+                return NotFound("Entity not found");
            }

            return Ok(result);
@@ -70,14 +72,14 @@ namespace LSA.Core.Thalos.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)]
-        [Permission("RoleManagement.Write")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("RoleManagement.Write")]
        public async Task<IActionResult> CreateRoleAsync([FromBody] RoleRequest newRole, CancellationToken cancellationToken)
        {
            var result = await service.CreateRole(newRole, cancellationToken).ConfigureAwait(false);
@@ -85,66 +87,67 @@ namespace LSA.Core.Thalos.API.Controllers
        }

        /// <summary>
-        /// Updates a full role by mongo identifier.
+        /// Updates a full role by identifier.
        /// </summary>
-        /// <param name="_id">The role mongo identifier.</param>
        /// <param name="entity">The role to update.</param>
-        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <param name="id">The role identifier.</param>
        /// <returns>The <see cref="RoleAdapter"/> updated entity.</returns>
        /// <response code="200">The role updated.</response>
-        /// <response code="400">Bad request if role ID mismatches.</response>
+        /// <response code="404">The role not found.</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)]
-        [Permission("RoleManagement.Write")]
-        public async Task<IActionResult> UpdateRoleAsync([FromRoute] string _id, [FromBody] RoleAdapter entity, CancellationToken cancellationToken)
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("RoleManagement.Write")]
+        public async Task<IActionResult> UpdateRoleAsync([FromRoute] string id, [FromBody] RoleAdapter entity, CancellationToken cancellationToken)
        {
-            if (_id != entity._Id)
+            if (id != entity.Id?.ToString())
            {
                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 mongo identifier.</param>
+        /// <param name="id">The role 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 status updated.</response>
+        /// <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="500">The service internal error.</response>
        [HttpPatch]
        [Route(Routes.ChangeStatus)]
        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
-        [Permission("RoleManagement.Write")]
-        public async Task<IActionResult> ChangeRoleStatus([FromRoute] string _id, [FromRoute] StatusEnum newStatus, CancellationToken cancellationToken)
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[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);
-
-            if (result == null)
-                return NotFound("Role not found");
-
+            var result = await service.ChangeRoleStatus(id, newStatus, cancellationToken).ConfigureAwait(false);
            return Ok(result);
        }

        /// <summary>
        /// Adds an application to the role's list of applications.
        /// </summary>
-        /// <param name="roleId">The mongo 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>
-        /// <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>
+        /// <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>
        /// <response code="500">The service internal error.</response>
        [HttpPost(Routes.AddApplication)]
        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
-        [Permission("RoleManagement.Write")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[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);
@@ -154,42 +157,21 @@ namespace LSA.Core.Thalos.API.Controllers
        /// <summary>
        /// Removes an application from the role's list of applications.
        /// </summary>
-        /// <param name="roleId">The mongo 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>
-        /// <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>
+        /// <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>
        /// <response code="500">The service internal error.</response>
        [HttpDelete(Routes.RemoveApplication)]
        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
-        [Permission("RoleManagement.Write")]
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[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);
-        }
    }
 }
--- a/Core.Thalos.DAL.API/Controllers/TenantController.cs
+++ b/Core.Thalos.DAL.API/Controllers/TenantController.cs
@@ -1,169 +0,0 @@
-// ***********************************************************************
-// <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);
-        }
-    }
-}
--- a/Core.Thalos.DAL.API/Controllers/UserController.cs
+++ b/Core.Thalos.DAL.API/Controllers/UserController.cs
@@ -3,13 +3,15 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-
 using Asp.Versioning;
-using Core.Thalos.BuildingBlocks;
+using Core.Blueprint.Mongo;
+using Core.Thalos.Adapters;
+using Core.Thalos.Adapters.Attributes;
+using Core.Thalos.Adapters.Common.Constants;
 using Core.Thalos.Provider.Contracts;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
+using Microsoft.Graph;
 using UserRequest = Core.Thalos.Domain.Contexts.Onboarding.Request.UserRequest;

 namespace LSA.Core.Thalos.API.Controllers
@@ -25,14 +27,16 @@ namespace LSA.Core.Thalos.API.Controllers
    public class UserController(IUserProvider service) : ControllerBase
    {
        /// <summary>
-        /// Gets all users.
+        /// Gets all the 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);
@@ -40,44 +44,62 @@ namespace LSA.Core.Thalos.API.Controllers
        }

        /// <summary>
-        /// Gets the user by mongo identifier.
+        /// Gets the user by identifier.
        /// </summary>
-        /// <param name="_id">The user Mongo identifier.</param>
-        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <param name="id">The user identifier.</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")]
-        public async Task<IActionResult> GetUserById([FromRoute] string _id, CancellationToken cancellationToken)
+        //[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);
-            return result == null ? NotFound("User not found") : Ok(result);
+            var result = await service.GetUserById(id, cancellationToken).ConfigureAwait(false);
+
+            if (result == null)
+            {
+                return NotFound("Entity not found");
+            }
+
+            return 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.GoogleScheme}")]
+        //[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.AzureScheme}")]
        public async Task<IActionResult> GetUserByEmail([FromRoute] string email, CancellationToken cancellationToken)
        {
            var result = await service.GetUserByEmail(email, cancellationToken).ConfigureAwait(false);
-            return result == null ? NotFound("User not found") : Ok(result);
+
+            if (result == null)
+            {
+                return NotFound("User not found");
+            }
+
+            return Ok(result);
        }

        /// <summary>
        /// Validates if a user exists on the database.
        /// </summary>
        /// <param name="email">The user's email.</param>
-        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
-        /// <returns>The <see cref="UserExistenceAdapter"/> indicating existence.</returns>
+        /// <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>
        [HttpGet]
        [Route("{email}/ValidateExistence")]
        [ProducesResponseType(typeof(UserExistenceAdapter), StatusCodes.Status200OK)]
@@ -85,19 +107,28 @@ namespace LSA.Core.Thalos.API.Controllers
        public async Task<IActionResult> ValidateUserExistence([FromRoute] string email, CancellationToken cancellationToken)
        {
            var result = await service.ValidateUserExistence(email, cancellationToken).ConfigureAwait(false);
-            return result == null ? NotFound("User not found") : Ok(result);
+
+            if (result == null)
+            {
+                return NotFound("User not found");
+            }
+
+            return Ok(result);
        }

        /// <summary>
        /// Creates a new user.
        /// </summary>
        /// <param name="newUser">The user to be added.</param>
-        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <param name="sendInvitation">Sends an invitation in case of third party access.</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);
@@ -105,75 +136,171 @@ namespace LSA.Core.Thalos.API.Controllers
        }

        /// <summary>
-        /// Updates a full user by mongo identifier.
+        /// Updates a full user by identifier.
        /// </summary>
-        /// <param name="_id">The user Mongo identifier.</param>
        /// <param name="entity">The user to update.</param>
-        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <param name="id">The user identifier.</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")]
-        public async Task<IActionResult> UpdateUserAsync([FromRoute] string _id, [FromBody] UserAdapter entity, CancellationToken cancellationToken)
+        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        //[Permission("UserManagement.Write")]
+        public async Task<IActionResult> UpdateUserAsync([FromRoute] string id, [FromBody] UserAdapter entity, CancellationToken cancellationToken)
        {
-            if (_id != entity._Id)
+            if (id != entity.Id?.ToString())
+            {
                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>
-        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
-        /// <returns>The <see cref="UserAdapter"/> found entity.</returns>
+        /// <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>
        [HttpPatch(Routes.LogIn)]
        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
+        //[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.AzureScheme}")]
        public async Task<IActionResult> LoginUserAsync([FromRoute] string email, CancellationToken cancellationToken)
        {
            var result = await service.LogInUser(email, cancellationToken).ConfigureAwait(false);
-            return result == null ? NotFound($"The user with email: '{email}' was not found") : Ok(result);
+
+            if (result is null)
+                return new NotFoundObjectResult($"The user with email: '{email}' was not found");
+
+            return Ok(result);
        }

        /// <summary>
        /// Logs out the user.
        /// </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"/> updated entity.</returns>
+        /// <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>
        [HttpPatch(Routes.LogOut)]
        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
+        //[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.AzureScheme}")]
        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 Mongo identifier.</param>
+        /// <param name="id">The user 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);
+            var result = await service.ChangeUserStatus(id, newStatus, cancellationToken).ConfigureAwait(false);
+            return Ok(result);
+        }

-            if (result == null)
-                return NotFound("User not found");
+        /// <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);
+        }

+        /// <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.RemoveProjectFromUser(userId, projectId, cancellationToken).ConfigureAwait(false);
            return Ok(result);
        }

@@ -181,35 +308,21 @@ namespace LSA.Core.Thalos.API.Controllers
        /// Gets a token for the user, including roles, permissions, and modules.
        /// </summary>
        /// <param name="email">The user's email.</param>
-        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
-        /// <returns>The <see cref="TokenAdapter"/> with user details.</returns>
+        /// <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>
        [HttpGet]
        [Route("{email}/GetTokenAdapter")]
        [ProducesResponseType(typeof(TokenAdapter), StatusCodes.Status200OK)]
-        [Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.GoogleScheme}")]
+        //[Authorize(AuthenticationSchemes = $"{Schemes.DefaultScheme}, {Schemes.AzureScheme}")]
        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);
-        }

-        /// <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);
+            if (tokenAdapter == null) return NotFound($"User with email: {email} not found");
+
+            return Ok(tokenAdapter);
        }
    }
 }
--- a/Core.Thalos.DAL.API/Extensions/SwaggerExtensions.cs
+++ b/Core.Thalos.DAL.API/Extensions/SwaggerExtensions.cs
@@ -0,0 +1,71 @@
+using Asp.Versioning.ApiExplorer;
+using Microsoft.Extensions.Options;
+using Microsoft.OpenApi.Any;
+using Swashbuckle.AspNetCore.SwaggerGen;
+using Swashbuckle.AspNetCore.SwaggerUI;
+
+namespace Core.Thalos.DAL.API.Extensions
+{
+    public static class SwaggerExtensions
+    {
+        public static void AddSwagger(this IServiceCollection services)
+        {
+            services.AddEndpointsApiExplorer();
+            services.AddSwaggerGen();
+            services.AddTransient<IConfigureOptions<SwaggerGenOptions>, ConfigureSwaggerOptions>();
+        }
+
+        public static void ConfigureSwagger(this WebApplication app)
+        {
+            app.UseSwagger();
+            app.UseSwaggerUI(options =>
+            {
+                foreach (var version in app.DescribeApiVersions().Select(version => version.GroupName))
+                    options.SwaggerEndpoint($"/swagger/{version}/swagger.json", version);
+
+                options.DisplayRequestDuration();
+                options.EnableTryItOutByDefault();
+                options.DocExpansion(DocExpansion.None);
+            });
+        }
+        public static IServiceCollection AddVersioning(this IServiceCollection services)
+        {
+            services.AddApiVersioning(options => options.ReportApiVersions = true)
+                   .AddApiExplorer(options =>
+                   {
+                       options.GroupNameFormat = "'v'VVV";
+                       options.SubstituteApiVersionInUrl = true;
+                   });
+
+            return services;
+        }
+    }
+    public class ConfigureSwaggerOptions : IConfigureOptions<SwaggerGenOptions>
+    {
+        private readonly IApiVersionDescriptionProvider _provider;
+
+        public ConfigureSwaggerOptions(IApiVersionDescriptionProvider provider)
+        {
+            _provider = provider;
+        }
+
+        public void Configure(SwaggerGenOptions options)
+        {
+            foreach (var description in _provider.ApiVersionDescriptions)
+                options.SwaggerDoc(description.GroupName, new()
+                {
+                    Title = AppDomain.CurrentDomain.FriendlyName,
+                    Version = description.ApiVersion.ToString()
+                });
+
+            //Map ALL Values Format TODO
+            options.MapType<DateOnly>(() => new()
+            {
+                Format = "date",
+                Example = new OpenApiString(DateOnly.MinValue.ToString())
+            });
+
+            options.CustomSchemaIds(type => type.ToString().Replace("+", "."));
+        }
+    }
+}
--- a/Core.Thalos.DAL.API/Program.cs
+++ b/Core.Thalos.DAL.API/Program.cs
@@ -1,9 +1,8 @@
 using Core.Blueprint.DAL.Mongo.Configuration;
-using Core.Blueprint.KeyVault.Configuration;
 using Core.Blueprint.Logging.Configuration;
 using Core.Blueprint.Redis.Configuration;
-using Core.Thalos.BuildingBlocks;
-using Core.Thalos.BuildingBlocks.Configuration;
+using Core.Thalos.Adapters.Extensions;
+using Core.Thalos.DAL.API.Extensions;
 using Core.Thalos.Provider;
 using Microsoft.AspNetCore.HttpLogging;
 using System.Reflection;
@@ -11,19 +10,12 @@ using System.Text.Json.Serialization;

 var builder = WebApplication.CreateBuilder(args);

+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
 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.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen(builder.Configuration, "Core.Thalos.DAL.API.xml", authSettings);
-builder.Services.AddVersioning(builder.Configuration);
 builder.Services.AddResponseCompression();
 builder.Services.AddProblemDetails();
 builder.Services.AddMemoryCache();
@@ -50,6 +42,11 @@ builder.Host.ConfigureServices((context, services) =>
        options.SerializerOptions.Converters.Add(new JsonStringEnumConverter());
    });

+    services
+        .AddEndpointsApiExplorer()
+        .AddVersioning()
+        .AddSwagger();
+
    services.AddHealthChecks();
    services.AddHttpLogging(options => options.LoggingFields = HttpLoggingFields.All);

@@ -66,22 +63,20 @@ builder.Host.ConfigureServices((context, services) =>

 var app = builder.Build();

-app.UseLogging(builder.Configuration);
-app.UseSwaggerUI(builder.Configuration, authSettings);
-app.ConfigureSwagger(builder.Configuration);
-
-app.UseRouting();
+app.UseSwagger();
+app.UseSwaggerUI();
+app.UseAuthentication();
+app.UseAuthorization();
+app.MapControllers();
 app.UseCors();
+app.ConfigureSwagger();
 app.UseHttpsRedirection();
 app.UseStaticFiles();
+app.UseRouting();
 app.UseResponseCompression();
 app.UseOutputCache();
 app.UseResponseCaching();
-
-app.UseAuthentication();
-app.UseAuthorization();
-
-app.MapControllers();
+app.UseLogging(builder.Configuration);
 app.MapHealthChecks("/health");

 app.Run();
--- a/Core.Thalos.DAL.API/appsettings.Local.json
+++ b/Core.Thalos.DAL.API/appsettings.Local.json
@@ -22,14 +22,5 @@
  "ServiceSettings": {
    "ApplicationName": "thalos",
    "LayerName": "dal"
-  },
-  "Vault": {
-    "Address": "http://100.123.31.103:8200",
-    "Token": "hvs.e37LQvLuPhTd5ALS5QQ03Cwm",
-    "SecretMount": "secret"
-  },
-  "IdentityProviders": {
-    "Google": true,
-    "Azure":  true
  }
 }
--- a/Core.Thalos.DAL.API/appsettings.json
+++ b/Core.Thalos.DAL.API/appsettings.json
@@ -4,5 +4,19 @@
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
+  },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    "MongoDB": "mongodb://admin_agile:Admin%40agileWebs@portainer.white-enciso.pro:27017/?authMechanism=SCRAM-SHA-256",
+    "Redis": "localhost:6379"
+  },
+  "MongoDb": {
+    "DatabaseName": "Thalos",
+    "LocalAudience": ""
+  },
+  "DetailedErrors": true,
+  "UseRedisCache": true,
+  "CacheSettings": {
+    "DefaultCacheDurationInMinutes": 3
  }
 }
--- a/Core.Thalos.Domain/Contexts/Onboarding/Request/ModuleRequest.cs
+++ b/Core.Thalos.Domain/Contexts/Onboarding/Request/ModuleRequest.cs
@@ -4,7 +4,7 @@
 // </copyright>
 // ***********************************************************************

-using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Adapters.Common.Enums;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization.Attributes;
 using System.Text.Json.Serialization;
--- a/Core.Thalos.Domain/Contexts/Onboarding/Request/PermissionRequest.cs
+++ b/Core.Thalos.Domain/Contexts/Onboarding/Request/PermissionRequest.cs
@@ -4,7 +4,7 @@
 // </copyright>
 // ***********************************************************************

-using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Adapters.Common.Constants;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization.Attributes;
 using System.Text.Json.Serialization;
--- a/Core.Thalos.Domain/Contexts/Onboarding/Request/RoleRequest.cs
+++ b/Core.Thalos.Domain/Contexts/Onboarding/Request/RoleRequest.cs
@@ -4,7 +4,7 @@
 // </copyright>
 // ***********************************************************************

-using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Adapters.Common.Enums;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization.Attributes;
 using System.Text.Json.Serialization;
--- a/Core.Thalos.Domain/Contexts/Onboarding/Request/TenantRequest.cs
+++ b/Core.Thalos.Domain/Contexts/Onboarding/Request/TenantRequest.cs
@@ -1,96 +0,0 @@
-// ***********************************************************************
-// <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; }
-    }
-}
--- a/Core.Thalos.Domain/Contexts/Onboarding/Request/UserRequest.cs
+++ b/Core.Thalos.Domain/Contexts/Onboarding/Request/UserRequest.cs
@@ -54,5 +54,19 @@ 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; }
    }
 }
--- a/Core.Thalos.Domain/Core.Thalos.Domain.csproj
+++ b/Core.Thalos.Domain/Core.Thalos.Domain.csproj
@@ -7,12 +7,7 @@
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="Core.Blueprint.KeyVault" Version="1.0.3" />
-    <PackageReference Include="Core.Thalos.BuildingBlocks" Version="1.1.5" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\shared libs\Core.Thalos.BuildingBlocks\Core.Thalos.BuildingBlocks\Core.Thalos.BuildingBlocks.csproj" />
+    <PackageReference Include="Core.Thalos.BuildingBlocks" Version="1.0.3" />
  </ItemGroup>

 </Project>
--- a/Core.Thalos.Provider/Contracts/IModuleProvider.cs
+++ b/Core.Thalos.Provider/Contracts/IModuleProvider.cs
@@ -3,85 +3,62 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-
-using Core.Thalos.BuildingBlocks;
+using Core.Blueprint.Mongo;
+using Core.Thalos.Adapters;
 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="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>
+        /// <param name="entity">The Module to be created.</param>
+        /// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<ModuleAdapter> CreateModule(ModuleRequest newModule, CancellationToken cancellationToken);

        /// <summary>
-        /// Gets a Module by its identifier.
+        /// Gets an 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 execution of the service.
-        /// </returns>
+        /// <param name="id">The Module identifier.</param>
+        /// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<ModuleAdapter> GetModuleById(string _id, CancellationToken cancellationToken);

        /// <summary>
-        /// Gets all Modules.
+        /// Gets all the roles.
        /// </summary>
-        /// <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>
+        /// <returns>A <see cref="{Task{IEnumerbale{ModuleAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<IEnumerable<ModuleAdapter>> GetAllModules(CancellationToken cancellationToken);

        /// <summary>
-        /// Gets all Modules by a list of identifiers.
+        /// Gets all the permissions by permissions identifier list.
        /// </summary>
-        /// <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>
+        /// <param name="permissions">The list of permissions identifiers.</param>
+        /// <returns>A <see cref="Task{IEnumerable{ModuleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<IEnumerable<ModuleAdapter>> GetAllModulesByList(string[] modules, CancellationToken cancellationToken);

        /// <summary>
-        /// Changes the status of a Module.
+        /// Changes the status of the permission.
        /// </summary>
-        /// <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);
+        /// <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);

        /// <summary>
-        /// Updates a Module by its identifier.
+        /// Updates a Module by id.
        /// </summary>
        /// <param name="entity">The Module to be updated.</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?> 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);
+        /// <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);
    }
 }
--- a/Core.Thalos.Provider/Contracts/IPermissionProvider.cs
+++ b/Core.Thalos.Provider/Contracts/IPermissionProvider.cs
@@ -3,85 +3,62 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-
-using Core.Thalos.BuildingBlocks;
+using Core.Blueprint.Mongo;
+using Core.Thalos.Adapters;
 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="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>
+        /// <param name="entity">The Permission to be created.</param>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<PermissionAdapter> CreatePermission(PermissionRequest newPermission, CancellationToken cancellationToken);

        /// <summary>
-        /// Gets a Permission by its identifier.
+        /// Gets an 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 execution of the service.
-        /// </returns>
+        /// <param name="id">The Permission identifier.</param>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<PermissionAdapter> GetPermissionById(string _id, CancellationToken cancellationToken);

        /// <summary>
-        /// Gets all Permissions.
+        /// Gets all the roles.
        /// </summary>
-        /// <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>
+        /// <returns>A <see cref="{Task{IEnumerbale{PermissionAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<IEnumerable<PermissionAdapter>> GetAllPermissions(CancellationToken cancellationToken);

        /// <summary>
-        /// Gets all Permissions by a list of identifiers.
+        /// Gets all the permissions by permissions identifier list.
        /// </summary>
-        /// <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>
+        /// <param name="permissions">The list of permissions identifiers.</param>
+        /// <returns>A <see cref="Task{IEnumerable{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<IEnumerable<PermissionAdapter>> GetAllPermissionsByList(string[] permissions, CancellationToken cancellationToken);

        /// <summary>
-        /// Changes the status of a Permission.
+        /// Changes the status of the permission.
        /// </summary>
-        /// <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);
+        /// <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);

        /// <summary>
-        /// Updates a Permission.
+        /// Updates a Permission by id.
        /// </summary>
        /// <param name="entity">The Permission to be updated.</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?> 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);
+        /// <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);
    }
 }
--- a/Core.Thalos.Provider/Contracts/IRoleProvider.cs
+++ b/Core.Thalos.Provider/Contracts/IRoleProvider.cs
@@ -3,97 +3,70 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-
-using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Adapters;
+using Core.Thalos.Adapters.Common.Enums;
 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="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>
+        /// <param name="entity">The Role to be created.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<RoleAdapter> CreateRole(RoleRequest newRole, CancellationToken cancellationToken);

        /// <summary>
-        /// Gets a Role by its identifier.
+        /// Gets an Role by 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>
+        /// <param name="id">The Role identifier.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<RoleAdapter> GetRoleById(string _id, CancellationToken cancellationToken);

        /// <summary>
-        /// Gets all Roles.
+        /// Gets all the roles.
        /// </summary>
-        /// <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>
+        /// <returns>A <see cref="{Task{IEnumerbale{RoleAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<IEnumerable<RoleAdapter>> GetAllRoles(CancellationToken cancellationToken);

        /// <summary>
-        /// Changes the status of a Role.
+        /// Changes the status of the role.
        /// </summary>
-        /// <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);
+        /// <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);

        /// <summary>
-        /// Updates a Role.
+        /// Updates a Role by id.
        /// </summary>
        /// <param name="entity">The Role to be updated.</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?> UpdateRole(RoleAdapter entity, CancellationToken cancellationToken);
+        /// <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);

        /// <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>
-        /// <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>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</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>
-        /// <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>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</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);
    }
 }
--- a/Core.Thalos.Provider/Contracts/ITenantProvider.cs
+++ b/Core.Thalos.Provider/Contracts/ITenantProvider.cs
@@ -1,77 +0,0 @@
-// ***********************************************************************
-// <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);
-    }
-}
--- a/Core.Thalos.Provider/Contracts/IUserProvider.cs
+++ b/Core.Thalos.Provider/Contracts/IUserProvider.cs
@@ -3,125 +3,134 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-
-using Core.Thalos.BuildingBlocks;
+using Core.Blueprint.Mongo;
+using Core.Thalos.Adapters;
 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="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>
+        /// <param name="entity">The User to be created.</param>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<UserAdapter> CreateUser(UserRequest newUser, CancellationToken cancellationToken);

        /// <summary>
-        /// Gets a User by Mongo identifier.
+        /// Gets an User by identifier.
        /// </summary>
-        /// <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>
+        /// <param name="id">The User identifier.</param>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<UserAdapter> GetUserById(string _id, CancellationToken cancellationToken);

+
        /// <summary>
-        /// Gets all Users.
+        /// Gets all the users.
        /// </summary>
-        /// <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>
+        /// <returns>A <see cref="{Task{IEnumerable{UserAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<IEnumerable<UserAdapter>> GetAllUsers(CancellationToken cancellationToken);

        /// <summary>
-        /// Gets a User by email.
+        /// Gets an User 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{UserAdapter}"/> representing the asynchronous execution of the service.
-        /// </returns>
-        ValueTask<UserAdapter> GetUserByEmail(string email, CancellationToken cancellationToken);
+        /// <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 User exists by email.
+        /// Validates if a users 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);
+        /// <param name="eamil">The User email.</param>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
+        ValueTask<UserExistenceAdapter> ValidateUserExistence(string? email, CancellationToken cancellationToken);

        /// <summary>
-        /// Changes the status of a User.
+        /// Changes the status of the 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);
+        /// <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.
+        /// Updates a User by id.
        /// </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);
+        /// <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.
+        /// 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>
+        /// <returns>A <see cref="{Task{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>
-        /// <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>
+        /// <returns>A <see cref="{Task{UserAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        ValueTask<UserAdapter?> LogOutUserSession(string email, CancellationToken cancellationToken);

        /// <summary>
-        /// Gets the TokenAdapter for a User.
+        /// Adds a company to the user's list of companies.
        /// </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{TokenAdapter}"/> representing the asynchronous execution of the service.
-        /// </returns>
+        /// <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>
        ValueTask<TokenAdapter?> GetToken(string email, CancellationToken cancellationToken);

        /// <summary>
-        /// Deletes a User by Mongo identifier.
+        /// Delete an User by identifier.
        /// </summary>
-        /// <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);
+        /// <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);
    }
 }
--- a/Core.Thalos.Provider/Core.Thalos.Provider.csproj
+++ b/Core.Thalos.Provider/Core.Thalos.Provider.csproj
@@ -11,7 +11,7 @@
  </ItemGroup>

  <ItemGroup>
-    <PackageReference Include="Core.Blueprint.Mongo" Version="1.0.1" />
+    <PackageReference Include="Core.Blueprint.Mongo" Version="1.0.0" />
    <PackageReference Include="Core.Blueprint.Redis" Version="1.0.2" />
    <PackageReference Include="Mapster" Version="7.4.2-pre02" />
  </ItemGroup>
--- a/Core.Thalos.Provider/Providers/Onboarding/ModuleProvider.cs
+++ b/Core.Thalos.Provider/Providers/Onboarding/ModuleProvider.cs
@@ -3,16 +3,15 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-
+using Core.Thalos.Adapters;
 using Core.Blueprint.Mongo;
+using Mapster;
+using Microsoft.Extensions.Options;
+using MongoDB.Driver;
+using Core.Thalos.Provider.Contracts;
+using Core.Thalos.Domain.Contexts.Onboarding.Request;
 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;
-using MongoDB.Driver;
-using StatusEnum = Core.Blueprint.Mongo.StatusEnum;

 namespace Core.Thalos.Provider.Providers.Onboarding
 {
@@ -22,63 +21,59 @@ namespace Core.Thalos.Provider.Providers.Onboarding
    public class ModuleProvider : IModuleProvider
    {
        private readonly CollectionRepository<ModuleAdapter> repository;
-        private readonly ICacheSettings cacheSettings;
+        private readonly CacheSettings cacheSettings;
        private readonly IRedisCacheProvider cacheProvider;

-        public ModuleProvider(
-            CollectionRepository<ModuleAdapter> repository,
+        public ModuleProvider(CollectionRepository<ModuleAdapter> repository,
            IRedisCacheProvider cacheProvider,
-            ICacheSettings cacheSettings)
+            IOptions<CacheSettings> 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="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>
+        /// <param name="entity">The Module to be created.</param>
+        /// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        public async ValueTask<ModuleAdapter> CreateModule(ModuleRequest newModule, CancellationToken cancellationToken)
        {
            var moduleCollection = newModule.Adapt<ModuleAdapter>();
+
            await repository.InsertOneAsync(moduleCollection);
+
            return moduleCollection;
        }

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

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

            var module = await repository.FindByIdAsync(_id);
-            await cacheProvider.SetAsync(cacheKey, module, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
+
+            await cacheProvider.SetAsync(cacheKey, module);

            return module;
        }

        /// <summary>
-        /// Gets all the Modules.
+        /// Gets all the modules.
        /// </summary>
-        /// <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>
+        /// <returns>A <see cref="{Task{IEnumerbale{ModuleAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        public async ValueTask<IEnumerable<ModuleAdapter>> GetAllModules(CancellationToken cancellationToken)
        {
            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetModules");
@@ -87,22 +82,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 a list of identifiers.
+        /// Gets all the modules by modules identifier list.
        /// </summary>
-        /// <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>
+        /// <param name="modules">The list of modules identifiers.</param>
+        /// <returns>A <see cref="Task{IEnumerable{ModuleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        public async ValueTask<IEnumerable<ModuleAdapter>> GetAllModulesByList(string[] modules, CancellationToken cancellationToken)
        {
            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllModulesByList", modules);
+
            var cachedData = await cacheProvider.GetAsync<IEnumerable<ModuleAdapter>>(cacheKey) ?? [];

            if (cachedData.Any()) return cachedData;
@@ -110,66 +105,49 @@ namespace Core.Thalos.Provider.Providers.Onboarding
            var builder = Builders<ModuleAdapter>.Filter;
            var filters = new List<FilterDefinition<ModuleAdapter>>();

-            if (modules is { Length: > 0 })
+            if (modules != null || !modules.Any())
            {
                filters.Add(builder.In(x => x._Id, modules));
            }

            var finalFilter = filters.Any() ? builder.And(filters) : builder.Empty;
+
            var modulesList = await repository.FilterByMongoFilterAsync(finalFilter);

-            await cacheProvider.SetAsync(cacheKey, modulesList, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
+            await cacheProvider.SetAsync(cacheKey, modulesList);
+
            return modulesList;
        }

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

-            if (entity is not null)
-            {
-                entity.Status = newStatus;
+            await repository.ReplaceOneAsync(entity);

-                return repository.ReplaceOneAsync(entity).Result;
-            }
-            else return null;
+            return entity;
        }

        /// <summary>
-        /// Updates a Module.
+        /// Updates a Module by id.
        /// </summary>
        /// <param name="entity">The Module to be updated.</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?> UpdateModule(ModuleAdapter entity, CancellationToken cancellationToken)
+        /// <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)
        {
-            var updatedEntity = await repository.ReplaceOneAsync(entity);
-            return updatedEntity;
-        }
+            await repository.ReplaceOneAsync(entity);

-        /// <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;
        }
    }
--- a/Core.Thalos.Provider/Providers/Onboarding/PermissionProvider.cs
+++ b/Core.Thalos.Provider/Providers/Onboarding/PermissionProvider.cs
@@ -3,14 +3,14 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-
 using Core.Blueprint.Mongo;
 using Core.Blueprint.Redis;
 using Core.Blueprint.Redis.Helpers;
-using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Adapters;
 using Core.Thalos.Domain.Contexts.Onboarding.Request;
 using Core.Thalos.Provider.Contracts;
 using Mapster;
+using Microsoft.Extensions.Options;
 using MongoDB.Driver;

 namespace Core.Thalos.Provider.Providers.Onboarding
@@ -21,63 +21,60 @@ namespace Core.Thalos.Provider.Providers.Onboarding
    public class PermissionProvider : IPermissionProvider
    {
        private readonly CollectionRepository<PermissionAdapter> repository;
-        private readonly ICacheSettings cacheSettings;
+        private readonly CacheSettings cacheSettings;
        private readonly IRedisCacheProvider cacheProvider;

-        public PermissionProvider(
-            CollectionRepository<PermissionAdapter> repository,
+        public PermissionProvider(CollectionRepository<PermissionAdapter> repository,
            IRedisCacheProvider cacheProvider,
-            ICacheSettings cacheSettings)
+            IOptions<CacheSettings> 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="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>
+        /// <param name="entity">The Permission to be created.</param>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        public async ValueTask<PermissionAdapter> CreatePermission(PermissionRequest newPermission, CancellationToken cancellationToken)
        {
            var permissionCollection = newPermission.Adapt<PermissionAdapter>();
+
            await repository.InsertOneAsync(permissionCollection);
+
            return permissionCollection;
        }

        /// <summary>
-        /// Gets a Permission by identifier.
+        /// Gets an 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 execution of the service.
-        /// </returns>
+        /// <param name="id">The Permission identifier.</param>
+        /// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>0
        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 Permissions.
+        /// Gets all the permissions.
        /// </summary>
-        /// <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>
+        /// <returns>A <see cref="{Task{IEnumerbale{PermissionAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        public async ValueTask<IEnumerable<PermissionAdapter>> GetAllPermissions(CancellationToken cancellationToken)
        {
            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllPermissions");
@@ -86,22 +83,22 @@ namespace Core.Thalos.Provider.Providers.Onboarding
            if (cachedData.Any()) return cachedData;

            var permissions = await repository.AsQueryable();
-            await cacheProvider.SetAsync(cacheKey, permissions, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
+
+            await cacheProvider.SetAsync(cacheKey, permissions);

            return permissions;
        }

        /// <summary>
-        /// Gets all Permissions by a list of identifiers.
+        /// Gets all the permissions by permissions identifier list.
        /// </summary>
-        /// <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>
+        /// <param name="permissions">The list of permissions identifiers.</param>
+        /// <returns>A <see cref="Task{IEnumerable{PermissionAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        public async 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;
@@ -109,66 +106,49 @@ namespace Core.Thalos.Provider.Providers.Onboarding
            var builder = Builders<PermissionAdapter>.Filter;
            var filters = new List<FilterDefinition<PermissionAdapter>>();

-            if (permissions is { Length: > 0 })
+            if (permissions != null || !permissions.Any())
            {
                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, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
+            await cacheProvider.SetAsync(cacheKey, permissionsList);
+
            return permissionsList;
        }

+
        /// <summary>
-        /// Changes the status of a Permission.
+        /// Changes the status of the permission.
        /// </summary>
-        /// <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)
+        /// <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)
        {
-            var entity = await repository.FindByIdAsync(_id);
+            var entity = await repository.FindByIdAsync(id);
+            entity.Status = newStatus;

-            if (entity is not null)
-            {
-                entity.Status = newStatus;
+            await repository.ReplaceOneAsync(entity);

-                return repository.ReplaceOneAsync(entity).Result;
-            }
-            else return null;
+            return entity;
        }

        /// <summary>
-        /// Updates a Permission.
+        /// Updates a Permission by id.
        /// </summary>
        /// <param name="entity">The Permission to be updated.</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?> UpdatePermission(PermissionAdapter entity, CancellationToken cancellationToken)
+        /// <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)
        {
-            var updatedEntity = await repository.ReplaceOneAsync(entity);
-            return updatedEntity;
-        }
+            await repository.ReplaceOneAsync(entity);

-        /// <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;
        }
    }
--- a/Core.Thalos.Provider/Providers/Onboarding/RoleProvider.cs
+++ b/Core.Thalos.Provider/Providers/Onboarding/RoleProvider.cs
@@ -3,15 +3,21 @@
 //     AgileWebs
 // </copyright>
 // ***********************************************************************
-
 using Core.Blueprint.Mongo;
 using Core.Blueprint.Redis;
 using Core.Blueprint.Redis.Helpers;
-using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Adapters;
+using Core.Thalos.Adapters.Common.Enums;
 using Core.Thalos.Domain.Contexts.Onboarding.Request;
 using Core.Thalos.Provider.Contracts;
 using Mapster;
+using Microsoft.Extensions.Options;
+using Microsoft.Graph;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
 using MongoDB.Driver;
+using System.ComponentModel.Design;
+using System.Text.RegularExpressions;

 namespace Core.Thalos.Provider.Providers.Onboarding
 {
@@ -21,63 +27,60 @@ namespace Core.Thalos.Provider.Providers.Onboarding
    public class RoleProvider : IRoleProvider
    {
        private readonly CollectionRepository<RoleAdapter> repository;
-        private readonly ICacheSettings cacheSettings;
-        private readonly IRedisCacheProvider cacheProvider;
+		private readonly CacheSettings cacheSettings;
+		private readonly IRedisCacheProvider cacheProvider;

-        public RoleProvider(
-            CollectionRepository<RoleAdapter> repository,
-            IRedisCacheProvider cacheProvider,
-            ICacheSettings cacheSettings)
+		public RoleProvider(CollectionRepository<RoleAdapter> repository,
+		    IRedisCacheProvider cacheProvider,
+			IOptions<CacheSettings> cacheSettings
+			)
        {
            this.repository = repository;
            this.repository.CollectionInitialization();
-            this.cacheProvider = cacheProvider;
-            this.cacheSettings = cacheSettings;
-        }
+			this.cacheSettings = cacheSettings.Value;
+			this.cacheProvider = cacheProvider;
+		}

        /// <summary>
        /// Creates a new Role.
        /// </summary>
-        /// <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>
+        /// <param name="entity">The Role to be created.</param>
+        /// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        public async ValueTask<RoleAdapter> CreateRole(RoleRequest newRole, CancellationToken cancellationToken)
        {
            var roleCollection = newRole.Adapt<RoleAdapter>();
+
            await repository.InsertOneAsync(roleCollection);
+
            return roleCollection;
        }

        /// <summary>
-        /// Gets a Role by its identifier.
+        /// Gets an Role by 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>
+        /// <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> 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, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
+
+            await cacheProvider.SetAsync(cacheKey, role);

            return role;
        }

        /// <summary>
-        /// Gets all Roles.
+        /// Gets all the roles.
        /// </summary>
-        /// <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>
+        /// <returns>A <see cref="{Task{IEnumerbale{RoleAdapter}}}"/> representing
+        /// the asynchronous execution of the service.</returns>
        public async ValueTask<IEnumerable<RoleAdapter>> GetAllRoles(CancellationToken cancellationToken)
        {
            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllRoles");
@@ -86,105 +89,84 @@ namespace Core.Thalos.Provider.Providers.Onboarding
            if (cachedData.Any()) return cachedData;

            var roles = await repository.AsQueryable();
-            await cacheProvider.SetAsync(cacheKey, roles, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
+
+            await cacheProvider.SetAsync(cacheKey, roles);

            return roles;
        }

        /// <summary>
-        /// Changes the status of a Role.
+        /// Changes the status of the role.
        /// </summary>
-        /// <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)
+        /// <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)
        {
-            var entity = await repository.FindByIdAsync(_id);
+            var entity = await repository.FindByIdAsync(id);
+            entity.Status = newStatus;

-            if (entity is not null)
-            {
-                entity.Status = newStatus;
+            await repository.ReplaceOneAsync(entity);

-                return repository.ReplaceOneAsync(entity).Result;
-            }
-            else return null;
+            return entity;
        }

        /// <summary>
-        /// Updates a Role.
+        /// Updates a Role by id.
        /// </summary>
        /// <param name="entity">The Role to be updated.</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?> UpdateRole(RoleAdapter entity, CancellationToken cancellationToken)
+        /// <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)
        {
-            var updatedEntity = await repository.ReplaceOneAsync(entity);
-            return updatedEntity;
+            await repository.ReplaceOneAsync(entity);
+
+            return entity;
        }

        /// <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>
-        /// <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>
+        /// <returns>A <see cref="{Task{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 == Blueprint.Mongo.StatusEnum.Active);
+                u => u._Id == roleId &&
+                u.Status == Core.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.
+        /// 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>
-        /// <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>
+        /// <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)
        {
            var role = await repository.FindOneAsync(
-                u => u._Id == roleId && u.Status == Blueprint.Mongo.StatusEnum.Active);
+                u => u._Id == roleId &&
+                u.Status == Core.Blueprint.Mongo.StatusEnum.Active);

-            var updatedApplications = role.Applications?
-                .Where(c => c != application)
-                .ToArray();
+            var updatedApplications = role.Applications
+                    ?.Where(c => c != application)
+                    .ToArray();

            role.Applications = updatedApplications;
+
            await repository.ReplaceOneAsync(role);

            return role;
        }
-
-        /// <summary>
-        /// Deletes a Role by 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 deletion result.
-        /// The deleted Role entity if found; otherwise, null.
-        /// </returns>
-        public async ValueTask<RoleAdapter?> DeleteRole(string _id, CancellationToken cancellationToken)
-        {
-            var entity = await repository.DeleteOneAsync(doc => doc._Id == _id);
-            return entity;
-        }
    }
 }
--- a/Core.Thalos.Provider/Providers/Onboarding/TenantProvider.cs
+++ b/Core.Thalos.Provider/Providers/Onboarding/TenantProvider.cs
@@ -1,144 +0,0 @@
-// ***********************************************************************
-// <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;
-        }
-    }
-}
--- a/Core.Thalos.Provider/Providers/Onboarding/UserProvider.cs
+++ b/Core.Thalos.Provider/Providers/Onboarding/UserProvider.cs
@@ -7,12 +7,15 @@
 using Core.Blueprint.Mongo;
 using Core.Blueprint.Redis;
 using Core.Blueprint.Redis.Helpers;
-using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Adapters;
+using Core.Thalos.Adapters.Common.Enums;
 using Core.Thalos.Provider.Contracts;
 using Mapster;
+using Microsoft.Extensions.Options;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver;
+using System.Reflection;
 using System.Text.RegularExpressions;

 namespace Core.Thalos.Provider.Providers.Onboarding
@@ -23,19 +26,19 @@ namespace Core.Thalos.Provider.Providers.Onboarding
    public class UserProvider : IUserProvider
    {
        private readonly CollectionRepository<UserAdapter> repository;
-        private readonly ICacheSettings cacheSettings;
-        private readonly IRedisCacheProvider cacheProvider;
+        private readonly CacheSettings cacheSettings;
+		private readonly IRedisCacheProvider cacheProvider;

-        public UserProvider(CollectionRepository<UserAdapter> repository,
+		public UserProvider(CollectionRepository<UserAdapter> repository,
            IRedisCacheProvider cacheProvider,
-            ICacheSettings cacheSettings
+			IOptions<CacheSettings> cacheSettings
            )
        {
            this.repository = repository;
            this.repository.CollectionInitialization();
-            this.cacheSettings = cacheSettings;
-            this.cacheProvider = cacheProvider;
-        }
+			this.cacheSettings = cacheSettings.Value;
+			this.cacheProvider = cacheProvider;
+		}

        /// <summary>
        /// Creates a new User.
@@ -55,7 +58,7 @@ namespace Core.Thalos.Provider.Providers.Onboarding
        /// <summary>
        /// Gets an User by identifier.
        /// </summary>
-        /// <param name="_id">The User mongo identifier.</param>
+        /// <param name="id">The User 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)
@@ -63,11 +66,11 @@ namespace Core.Thalos.Provider.Providers.Onboarding
            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetUserById", _id);
            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.FindByIdAsync(_id);

-            await cacheProvider.SetAsync(cacheKey, user, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
+            await cacheProvider.SetAsync(cacheKey, user);

            return user;
        }
@@ -82,11 +85,11 @@ namespace Core.Thalos.Provider.Providers.Onboarding
            var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllUsers");
            var cachedData = await cacheProvider.GetAsync<IEnumerable<UserAdapter>>(cacheKey) ?? [];

-            //if (cachedData.Any()) return cachedData;
+            if (cachedData.Any()) return cachedData;

            var users = await repository.AsQueryable();

-            await cacheProvider.SetAsync(cacheKey, users, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
+            await cacheProvider.SetAsync(cacheKey, users);

            return users;
        }
@@ -97,7 +100,7 @@ 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);
@@ -119,7 +122,7 @@ 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<UserExistenceAdapter> 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);
@@ -142,40 +145,38 @@ namespace Core.Thalos.Provider.Providers.Onboarding
        /// <summary>
        /// Changes the status of the user.
        /// </summary>
-        /// <param name="_id">The user mongo identifier.</param>
+        /// <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>
-        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);
+            var entity = await repository.FindByIdAsync(id);
+            entity.Status = newStatus;

-            if (entity is not null)
-            {
-                entity.Status = newStatus;
+            await repository.ReplaceOneAsync(entity);

-                return repository.ReplaceOneAsync(entity).Result;
-            }
-            else return null;
+            return entity;
        }

        /// <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 mongo identifier.</param>
+        /// <param name="id">The User 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)
        {
-            var updatedEntity = await repository.ReplaceOneAsync(entity);
-            return updatedEntity;
+            await repository.ReplaceOneAsync(entity);
+
+            return entity;
        }

        /// <summary>
        /// Logs in the user.
        /// </summary>
-        /// <param name="_id">The User mongo identifier.</param>
+        /// <param name="id">The User 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)
@@ -210,6 +211,92 @@ 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.Projects = 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.Projects = updatedProjects;
+
+            await repository.ReplaceOneAsync(user);
+
+            return user;
+        }
+
        /// <summary>
        /// Gets the token adapter for a user.
        /// </summary>
@@ -319,19 +406,31 @@ namespace Core.Thalos.Provider.Providers.Onboarding
                    User = new UserAdapter
                    {
                        Id = result["_id"]?.ToString() ?? "",
-                        Guid = result.Contains("guid") && !result["guid"].IsBsonNull ? result["guid"].AsString : string.Empty,
-                        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,
+                        Guid = result.Contains("guid") && !result["guid"].IsBsonNull ? result["guid"].AsString : "",
+                        Email = result.Contains("email") && !result["email"].IsBsonNull ? result["email"].AsString : "",
+                        Name = result.Contains("name") && !result["name"].IsBsonNull ? result["name"].AsString : "",
+                        MiddleName = result.Contains("middleName") && !result["middleName"].IsBsonNull ? result["middleName"].AsString : "",
+                        LastName = result.Contains("lastName") && !result["lastName"].IsBsonNull ? result["lastName"].AsString : "",
+                        DisplayName = result.Contains("displayName") && !result["displayName"].IsBsonNull ? result["displayName"].AsString : "",
+                        RoleId = result.Contains("roleId") && !result["roleId"].IsBsonNull ? result["roleId"].ToString() : "",
+                        Companies = result.Contains("companies") && result["companies"].IsBsonArray
+                            ? result["companies"].AsBsonArray
+                                .Where(c => c != null && !c.IsBsonNull)
+                                .Select(c => c.AsString)
+                                .ToArray()
+                            : Array.Empty<string>(),
+                                        Projects = result.Contains("projects") && result["projects"].IsBsonArray
+                            ? result["projects"].AsBsonArray
+                                .Where(p => p != null && !p.IsBsonNull)
+                                .Select(p => p.AsString)
+                                .ToArray()
+                            : Array.Empty<string>(),
                        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,
+                        CreatedBy = result.Contains("createdBy") && !result["createdBy"].IsBsonNull ? result["createdBy"].AsString : "",
                        UpdatedAt = result.Contains("updatedAt") && !result["updatedAt"].IsBsonNull ? result["updatedAt"].ToUniversalTime() : DateTime.MinValue,
-                        UpdatedBy = result.Contains("updatedBy") && !result["updatedBy"].IsBsonNull ? result["updatedBy"].AsString : string.Empty,
+                        UpdatedBy = result.Contains("updatedBy") && !result["updatedBy"].IsBsonNull ? result["updatedBy"].AsString : "",
                        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
@@ -340,13 +439,13 @@ namespace Core.Thalos.Provider.Providers.Onboarding
                    {
                        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
@@ -390,12 +489,12 @@ namespace Core.Thalos.Provider.Providers.Onboarding
                            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.Contains("permissions") && result["permissions"].IsBsonArray
                        ? result["permissions"].AsBsonArray
@@ -403,14 +502,7 @@ namespace Core.Thalos.Provider.Providers.Onboarding
                            .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>()
+                        : new List<PermissionAdapter>()
                };


@@ -424,12 +516,12 @@ namespace Core.Thalos.Provider.Providers.Onboarding
        }

        /// <summary>
-        /// Deletes an User by _id.
+        /// Deletes an User by id.
        /// </summary>
-        /// <param name="_id">The User mongo identifier.</param>
+        /// <param name="id">The User 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);

--- a/Core.Thalos.Provider/ServiceCollectionExtensions.cs
+++ b/Core.Thalos.Provider/ServiceCollectionExtensions.cs
@@ -1,5 +1,5 @@
 using Core.Blueprint.Mongo;
-using Core.Thalos.BuildingBlocks;
+using Core.Thalos.Adapters;
 using Core.Thalos.Provider.Contracts;
 using Core.Thalos.Provider.Providers.Onboarding;
 using Microsoft.Extensions.Configuration;
@@ -24,9 +24,6 @@ namespace Core.Thalos.Provider
            services.AddScoped<IUserProvider, UserProvider>();
            services.AddScoped<CollectionRepository<UserAdapter>>();

-            services.AddScoped<ITenantProvider, TenantProvider>();
-            services.AddScoped<CollectionRepository<TenantAdapter>>();
-
            return services;
        }
    }
Author	SHA1	Message	Date
efrain_marin	de418a123e	Update .gitea/workflows/pipeline.yml Some checks failed Core Thalos DAL - Deploy / Explore-Gitea-Actions (push) Has been cancelled Details	2025-07-20 23:23:36 +00:00
Efra	179e94979c	feat: added inital test pipeline Some checks failed Core Thalos DAL - Deploy / Explore-Gitea-Actions (push) Has been cancelled Details	2025-07-19 00:18:55 -06:00