Update hashi vault token

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

.dockerignore

@@ -0,0 +1,17 @@
+**/bin/
+**/obj/
+**/.vs/
+**/.idea/
+**/.vscode/
+**/*.user
+**/*.suo
+**/*.swp
+**/*.csproj.user
+**/*.log
+**/Properties/launchSettings.json
+**/appsettings.Local.json
+**/appsettings.*.Development.json
+.git/
+.gitignore
+Dockerfile
+docker-compose*.yml

Core.Thalos.BFF.Api/Controllers/AuthenticationController.cs

@@ -1,18 +1,10 @@
 using Asp.Versioning;
-using Core.Thalos.Adapters;
-using Core.Thalos.Adapters.Common.Constants;
-using Core.Thalos.Adapters.Contracts;
 using Core.Thalos.Application.UseCases.Users.Input;
-using Core.Thalos.BFF.Api.Services;
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.External.Clients.Thalos.Requests.Users;
-using Google.Apis.Auth.OAuth2;
 using LSA.Dashboard.External.Clients.Dashboard;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.Graph;
-using Newtonsoft.Json.Linq;
-using System.Reflection;
-using System.Text.Json;
 
 namespace Core.Thalos.BFF.Api.Controllers
 {
@@ -25,22 +17,10 @@ namespace Core.Thalos.BFF.Api.Controllers
     [Consumes(MimeTypes.ApplicationJson)]
     [ApiController]
     public class AuthenticationController(
-        IThalosServiceClient thalosServiceClient, 
+    IThalosServiceClient thalosServiceClient,
-        ILogger<AuthenticationController> logger, 
+    ILogger<AuthenticationController> logger,
-        ITokenService tokenService,
+    ITokenService tokenService) : BaseController(logger)
-        IGoogleAuthorization googleAuthorization) : BaseController(logger)
     {
-        [HttpGet]
-        public IActionResult Authorize() => Ok(googleAuthorization.GetAuthorizationUrl());
-
-        [HttpGet("callback")]
-        public async Task<IActionResult> Callback(string code)
-        {
-            var userCredential = await googleAuthorization.ExchangeCodeForToken(code);
-
-            return Ok(new Token(userCredential!.Token.IdToken));
-        }
-
         /// <summary>
         /// Get token for user.
         /// </summary>
@@ -51,7 +31,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         [HttpGet]
         [Route(Routes.GenerateToken)]
         [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        [Authorize]
+        [Authorize(AuthenticationSchemes = Schemes.GoogleScheme)]
         public async Task<IActionResult> GenerateTokenService(CancellationToken cancellationToken)
         {
             try
@@ -102,7 +82,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         [HttpGet]
         [Route(Routes.RefreshToken)]
         [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
-        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
         public async Task<IActionResult> RefreshCustomTokenAsync(CancellationToken cancellationToken)
         {
             var tokenAdapter = new TokenAdapter();

Core.Thalos.BFF.Api/Controllers/ModuleController.cs

@@ -1,8 +1,5 @@
 using Asp.Versioning;
-using Core.Thalos.Adapters;
+using Core.Thalos.BuildingBlocks;
-using Core.Thalos.Adapters.Attributes;
-using Core.Thalos.Adapters.Common.Constants;
-using Core.Thalos.BFF.Api.Services;
 using Core.Thalos.External.Clients.Thalos.Requests.Permissions;
 using Lib.Architecture.BuildingBlocks;
 using LSA.Dashboard.External.Clients.Dashboard;
@@ -20,21 +17,20 @@ namespace Core.Thalos.BFF.Api.Controllers
     [Consumes("application/json")]
     [Produces("application/json")]
     [ApiController]
-    //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+    [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
     public class ModuleController(IThalosServiceClient thalosServiceClient, ILogger<ModuleController> logger) : BaseController(logger)
     {
         /// <summary>
-        /// Gets all the modules.
+        /// Gets all modules.
         /// </summary>
         [HttpGet("GetAll")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(IEnumerable<ModuleAdapter>), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        [Authorize(AuthenticationSchemes = Constant.Scheme)]
+        [Permission("ModuleManagement.Read, RoleManagement.Read")]
-        //[Permission("ModuleManagement.Read, RoleManagement.Read")]
         public async Task<IActionResult> GetAllModulesService(CancellationToken cancellationToken)
         {
             try
@@ -51,7 +47,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         }
 
         /// <summary>
-        /// Gets all the modules by module identifiers.
+        /// Gets all modules by module identifiers.
         /// </summary>
         /// <param name="request">The request containing the list of module identifiers.</param>
         /// <param name="cancellationToken">Cancellation token for the asynchronous operation.</param>
@@ -67,8 +63,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        [AllowAnonymous]
+        [Permission("ModuleManagement.Read")]
-        //[Permission("ModuleManagement.Read")]
         public async Task<IActionResult> GetAllModulesByListAsync([FromBody] GetAllModulesByListRequest request, CancellationToken cancellationToken)
         {
             try
@@ -95,14 +90,13 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Creates a new module.
         /// </summary>
         [HttpPost("Create")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        [AllowAnonymous]
+        [Permission("ModuleManagement.Write")]
-        //[Permission("ModuleManagement.Write")]
         public async Task<IActionResult> CreateModuleService(CreateModuleRequest newModule, CancellationToken cancellationToken)
         {
             try
@@ -130,20 +124,20 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Gets the module by identifier.
         /// </summary>
         [HttpPost("GetById")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Permission("ModuleManagement.Read")]
+        [Permission("ModuleManagement.Read")]
         public async Task<IActionResult> GetModuleByIdService(GetModuleRequest request, CancellationToken cancellationToken)
         {
             try
             {
                 logger.LogInformation($"{nameof(GetModuleByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
 
-                if (string.IsNullOrEmpty(request.Id)) return BadRequest("Invalid module identifier");
+                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid module identifier");
 
                 return await Handle(() => thalosServiceClient.GetModuleByIdService(request, cancellationToken)).ConfigureAwait(false);
             }
@@ -158,13 +152,13 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Updates a full module by identifier.
         /// </summary>
         [HttpPut("Update")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Permission("ModuleManagement.Write")]
+        [Permission("ModuleManagement.Write")]
         public async Task<IActionResult> UpdateModuleService(UpdateModuleRequest newModule, CancellationToken cancellationToken)
         {
             try
@@ -193,21 +187,21 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// </summary>
         [HttpPatch]
         [Route("ChangeStatus")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status204NoContent)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Permission("ModuleManagement.Write")]
+        [Permission("ModuleManagement.Write")]
         public async Task<IActionResult> ChangeModuleStatusService([FromBody] ChangeModuleStatusRequest request, CancellationToken cancellationToken)
         {
             try
             {
                 logger.LogInformation($"{nameof(ChangeModuleStatusService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
 
-                if (string.IsNullOrEmpty(request.Id)) { return BadRequest("Invalid module identifier"); }
+                if (string.IsNullOrEmpty(request._Id)) { return BadRequest("Invalid module identifier"); }
 
                 return await Handle(() => thalosServiceClient.ChangeModuleStatusService(request, cancellationToken)).ConfigureAwait(false);
             }
@@ -218,6 +212,32 @@ namespace Core.Thalos.BFF.Api.Controllers
             }
         }
 
+        /// <summary>
+        /// Deletes the Module by identifier.
+        /// </summary>
+        [HttpDelete("Delete")]
+        [ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Permission("ModuleManagement.Write")]
+        public async Task<IActionResult> DeleteModuleByIdService(DeleteModuleRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(DeleteModuleByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
 
+                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid Module identifier");
+
+                return await Handle(() => thalosServiceClient.DeleteModuleByIdService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(DeleteModuleByIdService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
     }
 }

Core.Thalos.BFF.Api/Controllers/PermissionController.cs

@@ -1,13 +1,10 @@
 using Asp.Versioning;
-using Core.Thalos.Adapters;
+using Core.Thalos.BuildingBlocks;
-using Core.Thalos.Adapters.Attributes;
-using Core.Thalos.Adapters.Common.Constants;
 using Core.Thalos.External.Clients.Thalos.Requests.Permissions;
 using Lib.Architecture.BuildingBlocks;
 using LSA.Dashboard.External.Clients.Dashboard;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.Graph;
 using System.Text.Json;
 
 namespace Core.Thalos.BFF.Api.Controllers
@@ -20,20 +17,20 @@ namespace Core.Thalos.BFF.Api.Controllers
     [Consumes("application/json")]
     [Produces("application/json")]
     [ApiController]
-    //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+    [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
     public class PermissionController(IThalosServiceClient thalosServiceClient, ILogger<PermissionController> logger) : BaseController(logger)
     {
         /// <summary>
-        /// Gets all the permissions.
+        /// Gets all permissions.
         /// </summary>
         [HttpGet("GetAll")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(IEnumerable<PermissionAdapter>), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        ////[Permission("PermissionManagement.Read, RoleManagement.Read")]
+        [Permission("PermissionManagement.Read, RoleManagement.Read")]
         public async Task<IActionResult> GetAllPermissionsService(CancellationToken cancellationToken)
         {
             try
@@ -50,7 +47,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         }
 
         /// <summary>
-        /// Gets all the permissions by permission identifiers.
+        /// Gets all permissions by permission identifiers.
         /// </summary>
         /// <param name="request">The request containing the list of permission identifiers.</param>
         /// <param name="cancellationToken">Cancellation token for the asynchronous operation.</param>
@@ -66,7 +63,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Permission("PermissionManagement.Read")]
+        [Permission("PermissionManagement.Read")]
         public async Task<IActionResult> GetAllPermissionsByListAsync([FromBody] GetAllPermissionsByListRequest request, CancellationToken cancellationToken)
         {
             try
@@ -93,13 +90,13 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Creates a new permission.
         /// </summary>
         [HttpPost("Create")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Permission("PermissionManagement.Write")]
+        [Permission("PermissionManagement.Write")]
         public async Task<IActionResult> CreatePermissionService(CreatePermissionRequest newPermission, CancellationToken cancellationToken)
         {
             try
@@ -125,20 +122,20 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Gets the permission by identifier.
         /// </summary>
         [HttpPost("GetById")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Permission("PermissionManagement.Read")]
+        [Permission("PermissionManagement.Read")]
         public async Task<IActionResult> GetPermissionByIdService(GetPermissionRequest request, CancellationToken cancellationToken)
         {
             try
             {
                 logger.LogInformation($"{nameof(GetPermissionByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
 
-                if (string.IsNullOrEmpty(request.Id)) return BadRequest("Invalid permission identifier");
+                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid permission identifier");
 
                 return await Handle(() => thalosServiceClient.GetPermissionByIdService(request, cancellationToken)).ConfigureAwait(false);
             }
@@ -153,13 +150,13 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Updates a full permission by identifier.
         /// </summary>
         [HttpPut("Update")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Permission("PermissionManagement.Write")]
+        [Permission("PermissionManagement.Write")]
         public async Task<IActionResult> UpdatePermissionService(UpdatePermissionRequest newPermission, CancellationToken cancellationToken)
         {
             try
@@ -186,21 +183,21 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// </summary>
         [HttpPatch]
         [Route("ChangeStatus")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status204NoContent)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Permission("PermissionManagement.Write")]
+        [Permission("PermissionManagement.Write")]
         public async Task<IActionResult> ChangePermissionStatusService([FromBody] ChangePermissionStatusRequest request, CancellationToken cancellationToken)
         {
             try
             {
                 logger.LogInformation($"{nameof(ChangePermissionStatusService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
 
-                if (string.IsNullOrEmpty(request.Id)) { return BadRequest("Invalid permission identifier"); }
+                if (string.IsNullOrEmpty(request._Id)) { return BadRequest("Invalid permission identifier"); }
 
                 return await Handle(() => thalosServiceClient.ChangePermissionStatusService(request, cancellationToken)).ConfigureAwait(false);
             }
@@ -211,6 +208,32 @@ namespace Core.Thalos.BFF.Api.Controllers
             }
         }
 
+        /// <summary>
+        /// Deletes the Permission by identifier.
+        /// </summary>
+        [HttpDelete("Delete")]
+        [ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Permission("PermissionManagement.Write")]
+        public async Task<IActionResult> DeletePermissionByIdService(DeletePermissionRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(DeletePermissionByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
 
+                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid Permission identifier");
+
+                return await Handle(() => thalosServiceClient.DeletePermissionByIdService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(DeletePermissionByIdService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
     }
 }

Core.Thalos.BFF.Api/Controllers/RoleController.cs

@@ -1,7 +1,6 @@
 using Asp.Versioning;
-using Core.Thalos.Adapters.Attributes;
-using Core.Thalos.Adapters.Common.Constants;
 using Core.Thalos.Application.UseCases.Roles.Input;
+using Core.Thalos.BuildingBlocks;
 using Lib.Architecture.BuildingBlocks;
 using LSA.Dashboard.External.Clients.Dashboard;
 using Microsoft.AspNetCore.Authorization;
@@ -18,14 +17,14 @@ namespace Core.Thalos.BFF.Api.Controllers
     [Consumes("application/json")]
     [Produces("application/json")]
     [ApiController]
-    //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+    [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
     public class RoleController(IThalosServiceClient thalosServiceClient, ILogger<RoleController> logger) : BaseController(logger)
     {
         /// <summary>
-        /// Gets all the roles.
+        /// Gets all roles.
         /// </summary>
         [HttpGet("GetAll")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(IEnumerable<RoleAdapter>), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
@@ -51,7 +50,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Creates a new role.
         /// </summary>
         [HttpPost("Create")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
@@ -89,7 +88,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Gets the role by identifier.
         /// </summary>
         [HttpPost("GetById")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
@@ -102,7 +101,7 @@ namespace Core.Thalos.BFF.Api.Controllers
             {
                 logger.LogInformation($"{nameof(GetRoleByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
 
-                if (string.IsNullOrEmpty(request.Id)) return BadRequest("Invalid role identifier");
+                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid role identifier");
 
                 return await Handle(() => thalosServiceClient.GetRoleByIdService(request, cancellationToken)).ConfigureAwait(false);
             }
@@ -117,7 +116,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Updates a full role by identifier.
         /// </summary>
         [HttpPut("Update")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
@@ -134,7 +133,7 @@ namespace Core.Thalos.BFF.Api.Controllers
 
                 if (string.IsNullOrEmpty(request.Name)) return BadRequest("Invalid role name");
 
-                if (string.IsNullOrEmpty(request.Id)) return BadRequest("Invalid role identifier");
+                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid role identifier");
 
                 if (string.IsNullOrEmpty(request.Description)) return BadRequest("Invalid role description");
 
@@ -159,7 +158,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// </summary>
         [HttpPatch]
         [Route("ChangeStatus")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status204NoContent)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
@@ -173,7 +172,7 @@ namespace Core.Thalos.BFF.Api.Controllers
             {
                 logger.LogInformation($"{nameof(ChangeRoleStatusService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
 
-                if (string.IsNullOrEmpty(request.Id)) { return BadRequest("Invalid role identifier"); }
+                if (string.IsNullOrEmpty(request._Id)) { return BadRequest("Invalid role identifier"); }
 
                 return await Handle(() => thalosServiceClient.ChangeRoleStatusService(request, cancellationToken)).ConfigureAwait(false);
             }
@@ -189,7 +188,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// </summary>
         [HttpPost]
         [Route("AddApplication")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status204NoContent)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
@@ -219,7 +218,7 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// </summary>
         [HttpDelete]
         [Route("RemoveApplication")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status204NoContent)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
@@ -243,5 +242,33 @@ namespace Core.Thalos.BFF.Api.Controllers
                 throw;
             }
         }
+
+        /// <summary>
+        /// Deletes the Role by identifier.
+        /// </summary>
+        [HttpDelete("Delete")]
+        [ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Permission("RoleManagement.Write")]
+        public async Task<IActionResult> DeleteRoleByIdService(DeleteRoleRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(DeleteRoleByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid Role identifier");
+
+                return await Handle(() => thalosServiceClient.DeleteRoleByIdService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(DeleteRoleByIdService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
     }
 }

Core.Thalos.BFF.Api/Controllers/TenantController.cs

@@ -0,0 +1,196 @@
+using Asp.Versioning;
+using Core.Thalos.BuildingBlocks;
+using Core.Thalos.External.Clients.Thalos.Requests.Tenants;
+using Lib.Architecture.BuildingBlocks;
+using LSA.Dashboard.External.Clients.Dashboard;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Text.Json;
+
+namespace Core.Thalos.BFF.Api.Controllers
+{
+    /// <summary>
+    /// Handles all requests for Tenant authentication.
+    /// </summary>
+    [ApiVersion("1.0")]
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [Consumes("application/json")]
+    [Produces("application/json")]
+    [ApiController]
+    [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+    public class TenantController(IThalosServiceClient thalosServiceClient, ILogger<TenantController> logger) : BaseController(logger)
+    {
+        /// <summary>
+        /// Gets all Tenants.
+        /// </summary>
+        [HttpGet("GetAll")]
+        [ProducesResponseType(typeof(IEnumerable<TenantAdapter>), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Permission("TenantManagement.Read, RoleManagement.Read")]
+        public async Task<IActionResult> GetAllTenantsService(CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(GetAllTenantsService)} - Request received - Payload: ");
+
+                return await Handle(() => thalosServiceClient.GetAllTenantsService(new GetAllTenantsRequest { }, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(GetAllTenantsService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new Tenant.
+        /// </summary>
+        [HttpPost("Create")]
+        [ProducesResponseType(typeof(TenantAdapter), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Permission("TenantManagement.Write")]
+        public async Task<IActionResult> CreateTenantService(CreateTenantRequest newTenant, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(CreateTenantService)} - Request received - Payload: {JsonSerializer.Serialize(newTenant)}");
+
+                if (newTenant == null) return BadRequest("Invalid Tenant object");
+
+                if (string.IsNullOrEmpty(newTenant.Name)) return BadRequest("Invalid Tenant name");
+
+                return await Handle(() => thalosServiceClient.CreateTenantService(newTenant, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(CreateTenantService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(newTenant)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Tenant by identifier.
+        /// </summary>
+        [HttpPost("GetById")]
+        [ProducesResponseType(typeof(TenantAdapter), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Permission("TenantManagement.Read")]
+        public async Task<IActionResult> GetTenantByIdService(GetTenantRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(GetTenantByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid Tenant identifier");
+
+                return await Handle(() => thalosServiceClient.GetTenantByIdService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(GetTenantByIdService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Updates a full Tenant by identifier.
+        /// </summary>
+        [HttpPut("Update")]
+        [ProducesResponseType(typeof(TenantAdapter), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Permission("TenantManagement.Write")]
+        public async Task<IActionResult> UpdateTenantService(UpdateTenantRequest newTenant, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(UpdateTenantService)} - Request received - Payload: {JsonSerializer.Serialize(newTenant)}");
+
+                if (newTenant == null) return BadRequest("Invalid Tenant object");
+
+                if (string.IsNullOrEmpty(newTenant.Name)) return BadRequest("Invalid Tenant name");
+
+
+                return await Handle(() => thalosServiceClient.UpdateTenantService(newTenant, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(UpdateTenantService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(newTenant)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Changes the status of the Tenant.
+        /// </summary>
+        [HttpPatch]
+        [Route("ChangeStatus")]
+        [ProducesResponseType(typeof(TenantAdapter), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Permission("TenantManagement.Write")]
+        public async Task<IActionResult> ChangeTenantStatusService([FromBody] ChangeTenantStatusRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(ChangeTenantStatusService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request._Id)) { return BadRequest("Invalid Tenant identifier"); }
+
+                return await Handle(() => thalosServiceClient.ChangeTenantStatusService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(ChangeTenantStatusService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Deletes the Tenant by identifier.
+        /// </summary>
+        [HttpDelete("Delete")]
+        [ProducesResponseType(typeof(TenantAdapter), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Permission("TenantManagement.Write")]
+        public async Task<IActionResult> DeleteTenantByIdService(DeleteTenantRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(DeleteTenantByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid Tenant identifier");
+
+                return await Handle(() => thalosServiceClient.DeleteTenantByIdService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(DeleteTenantByIdService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
+    }
+}

Core.Thalos.BFF.Api/Controllers/UserController.cs

@@ -1,7 +1,6 @@
 using Asp.Versioning;
-using Core.Thalos.Adapters.Attributes;
-using Core.Thalos.Adapters.Common.Constants;
 using Core.Thalos.Application.UseCases.Users.Input;
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.External.Clients.Thalos.Requests.Users;
 using Lib.Architecture.BuildingBlocks;
 using LSA.Dashboard.External.Clients.Dashboard;
@@ -22,17 +21,17 @@ namespace Core.Thalos.BFF.Api.Controllers
     public class UserController(IThalosServiceClient thalosServiceClient, ILogger<UserController> logger) : BaseController(logger)
     {
         /// <summary>
-        /// Gets all the users.
+        /// Gets all users.
         /// </summary>
         [HttpGet("GetAll")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(IEnumerable<UserAdapter>), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        //[Permission("UserManagement.Read")]
+        [Permission("UserManagement.Read")]
         public async Task<IActionResult> GetAllUsersService(CancellationToken cancellationToken)
         {
             try
@@ -52,14 +51,14 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Creates a new user.
         /// </summary>
         [HttpPost("Create")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        //[Permission("UserManagement.Write")]
+        [Permission("UserManagement.Write")]
         public async Task<IActionResult> CreateUserService(CreateUserRequest newUser, CancellationToken cancellationToken)
         {
             try
@@ -76,7 +75,7 @@ namespace Core.Thalos.BFF.Api.Controllers
 
                 if (string.IsNullOrEmpty(newUser.RoleId)) return BadRequest("Invalid role id");
 
-                if (!newUser.Companies.Any()) return BadRequest("The user must contain at least one company");
+                if (string.IsNullOrEmpty(newUser.TenantId)) return BadRequest("Invalid tenant id");
 
                 return await Handle(() => thalosServiceClient.CreateUserService(newUser, cancellationToken)).ConfigureAwait(false);
             }
@@ -91,21 +90,21 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Gets the user by identifier.
         /// </summary>
         [HttpPost("GetById")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        //[Permission("UserManagement.Read")]
+        [Permission("UserManagement.Read")]
         public async Task<IActionResult> GetUserByIdService(GetUserRequest request, CancellationToken cancellationToken)
         {
             try
             {
                 logger.LogInformation($"{nameof(GetUserByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
 
-                if (string.IsNullOrEmpty(request.Id)) return BadRequest("Invalid user identifier");
+                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid user identifier");
 
                 return await Handle(() => thalosServiceClient.GetUserByIdService(request, cancellationToken)).ConfigureAwait(false);
             }
@@ -120,14 +119,14 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Gets the user by email.
         /// </summary>
         [HttpPost("GetByEmail")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        //[Permission("UserManagement.Read")]
+        [Permission("UserManagement.Read")]
         public async Task<IActionResult> GetUserByEmailService(GetUserByEmailRequest request, CancellationToken cancellationToken)
         {
             try
@@ -149,14 +148,14 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Updates a full user by identifier.
         /// </summary>
         [HttpPut("Update")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        //[Permission("UserManagement.Write")]
+        [Permission("UserManagement.Write")]
         public async Task<IActionResult> UpdateUserService(UpdateUserRequest request, CancellationToken cancellationToken)
         {
             try
@@ -173,8 +172,6 @@ namespace Core.Thalos.BFF.Api.Controllers
 
                 if (string.IsNullOrEmpty(request.RoleId)) return BadRequest("Invalid role id");
 
-                if (!request.Companies.Any()) return BadRequest("The user must contain at least one company");
-
                 return await Handle(() => thalosServiceClient.UpdateUserService(request, cancellationToken)).ConfigureAwait(false);
             }
             catch (Exception ex)
@@ -188,13 +185,13 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Logs in the user.
         /// </summary>
         [HttpPatch("LoginUser")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = $"{Schemes.AzureScheme}, {Schemes.DefaultScheme}")]
+        [Authorize(AuthenticationSchemes = $"{Schemes.GoogleScheme}, {Schemes.DefaultScheme}")]
         public async Task<IActionResult> LoginUserService([FromBody] LoginUserRequest request, CancellationToken cancellationToken)
         {
             try
@@ -216,13 +213,13 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// Logs out the user.
         /// </summary>
         [HttpPatch("LogoutUser")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = $"{Schemes.AzureScheme}, {Schemes.DefaultScheme}")]
+        [Authorize(AuthenticationSchemes = $"{Schemes.GoogleScheme}, {Schemes.DefaultScheme}")]
         public async Task<IActionResult> LogoutUserService([FromBody] LogoutUserRequest request, CancellationToken cancellationToken)
         {
             try
@@ -245,22 +242,22 @@ namespace Core.Thalos.BFF.Api.Controllers
         /// </summary>
         [HttpPatch]
         [Route("ChangeStatus")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status204NoContent)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
         [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
+        [Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        //[Permission("UserManagement.Write")]
+        [Permission("UserManagement.Write")]
         public async Task<IActionResult> ChangeUserStatusService([FromBody] ChangeUserStatusRequest request, CancellationToken cancellationToken)
         {
             try
             {
                 logger.LogInformation($"{nameof(ChangeUserStatusService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
 
-                if (string.IsNullOrEmpty(request.Id)) { return BadRequest("Invalid user identifier"); }
+                if (string.IsNullOrEmpty(request._Id)) { return BadRequest("Invalid user identifier"); }
 
                 return await Handle(() => thalosServiceClient.ChangeUserStatusService(request, cancellationToken)).ConfigureAwait(false);
             }
@@ -271,140 +268,11 @@ namespace Core.Thalos.BFF.Api.Controllers
             }
         }
 
-        /// <summary>
-        /// Adds a company to the user's list of companies.
-        /// </summary>
-        [HttpPost]
-        [Route("AddCompany")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status204NoContent)]
-        [ProducesResponseType(StatusCodes.Status400BadRequest)]
-        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
-        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
-        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
-        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        //[Permission("UserManagement.Write")]
-        public async Task<IActionResult> AddCompanyToUserService([FromBody] AddCompanyToUserRequest request, CancellationToken cancellationToken)
-        {
-            try
-            {
-                logger.LogInformation($"{nameof(AddCompanyToUserService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
-
-                if (string.IsNullOrEmpty(request.UserId)) { return BadRequest("Invalid user identifier"); }
-                if (string.IsNullOrEmpty(request.CompanyId)) { return BadRequest("Invalid company identifier"); }
-
-                return await Handle(() => thalosServiceClient.AddCompanyToUserService(request, cancellationToken)).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"{nameof(AddCompanyToUserService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
-                throw;
-            }
-        }
-
-        /// <summary>
-        /// Removes a company from the user's list of companies.
-        /// </summary>
-        [HttpDelete]
-        [Route("RemoveCompany")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status204NoContent)]
-        [ProducesResponseType(StatusCodes.Status400BadRequest)]
-        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
-        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
-        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
-        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        //[Permission("UserManagement.Write")]
-        public async Task<IActionResult> RemoveCompanyFromUserService([FromBody] RemoveCompanyFromUserRequest request, CancellationToken cancellationToken)
-        {
-            try
-            {
-                logger.LogInformation($"{nameof(RemoveCompanyFromUserService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
-
-                if (string.IsNullOrEmpty(request.UserId)) { return BadRequest("Invalid user identifier"); }
-                if (string.IsNullOrEmpty(request.CompanyId)) { return BadRequest("Invalid company identifier"); }
-
-                return await Handle(() => thalosServiceClient.RemoveCompanyFromUserService(request, cancellationToken)).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"{nameof(RemoveCompanyFromUserService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
-                throw;
-            }
-        }
-
-        /// <summary>
-        /// Adds a project to the user's list of companies.
-        /// </summary>
-        [HttpPost]
-        [Route("AddProject")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status204NoContent)]
-        [ProducesResponseType(StatusCodes.Status400BadRequest)]
-        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
-        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
-        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
-        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        //[Permission("UserManagement.Write")]
-
-        public async Task<IActionResult> AddProjectToUserService([FromBody] AddProjectToUserRequest request, CancellationToken cancellationToken)
-        {
-            try
-            {
-                logger.LogInformation($"{nameof(AddProjectToUserService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
-
-                if (string.IsNullOrEmpty(request.UserId)) { return BadRequest("Invalid user identifier"); }
-                if (string.IsNullOrEmpty(request.ProjectId)) { return BadRequest("Invalid project identifier"); }
-
-                return await Handle(() => thalosServiceClient.AddProjectToUserService(request, cancellationToken)).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"{nameof(AddProjectToUserService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
-                throw;
-            }
-        }
-
-        /// <summary>
-        /// Removes a project from the user's list of companies.
-        /// </summary>
-        [HttpDelete]
-        [Route("RemoveProject")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status204NoContent)]
-        [ProducesResponseType(StatusCodes.Status400BadRequest)]
-        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
-        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
-        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
-        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-        //[Authorize(AuthenticationSchemes = Schemes.DefaultScheme)]
-        //[Permission("UserManagement.Write")]
-        public async Task<IActionResult> RemoveProjectFromUserService([FromBody] RemoveProjectFromUserRequest request, CancellationToken cancellationToken)
-        {
-            try
-            {
-                logger.LogInformation($"{nameof(RemoveProjectFromUserService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
-
-                if (string.IsNullOrEmpty(request.UserId)) { return BadRequest("Invalid user identifier"); }
-                if (string.IsNullOrEmpty(request.ProjectId)) { return BadRequest("Invalid project identifier"); }
-
-                return await Handle(() => thalosServiceClient.RemoveProjectFromUserService(request, cancellationToken)).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                logger.LogError($"{nameof(RemoveProjectFromUserService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
-                throw;
-            }
-        }
-
         /// <summary>
         /// Gets the user by email.
         /// </summary>
         [HttpPost("ValidateExistence")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
@@ -427,5 +295,33 @@ namespace Core.Thalos.BFF.Api.Controllers
                 throw;
             }
         }
+
+        /// <summary>
+        /// Deletes the User by identifier.
+        /// </summary>
+        [HttpDelete("Delete")]
+        [ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status412PreconditionFailed)]
+        [ProducesResponseType(typeof(Notification), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        [Permission("UserManagement.Write")]
+        public async Task<IActionResult> DeleteUserByIdService(DeleteUserRequest request, CancellationToken cancellationToken)
+        {
+            try
+            {
+                logger.LogInformation($"{nameof(DeleteUserByIdService)} - Request received - Payload: {JsonSerializer.Serialize(request)}");
+
+                if (string.IsNullOrEmpty(request._Id)) return BadRequest("Invalid User identifier");
+
+                return await Handle(() => thalosServiceClient.DeleteUserByIdService(request, cancellationToken)).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError($"{nameof(DeleteUserByIdService)} - An Error Occurred- {ex.Message} - {ex.InnerException} - {ex.StackTrace} - with payload {JsonSerializer.Serialize(request)}");
+                throw;
+            }
+        }
     }
 }

Core.Thalos.BFF.Api/Core.Thalos.BFF.Api.csproj

@@ -10,12 +10,6 @@
   <ItemGroup>
     <PackageReference Include="Asp.Versioning.Mvc" Version="8.1.0" />
     <PackageReference Include="Core.Blueprint.Logging" Version="1.0.0" />
-    <PackageReference Include="Google.Apis.Auth" Version="1.70.0" />
-    <PackageReference Include="Google.Apis.Oauth2.v2" Version="1.68.0.1869" />
-    <PackageReference Include="Google.Protobuf" Version="3.31.1" />
-    <PackageReference Include="Microsoft.AspNetCore.Authentication.Google" Version="8.0.17" />
-    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.17" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="8.1.4" />
   </ItemGroup>
 
   <ItemGroup>

Core.Thalos.BFF.Api/Program.cs

@@ -1,28 +1,14 @@
-using Asp.Versioning;
+using Core.Blueprint.KeyVault.Configuration;
-using Azure.Identity;
 using Core.Blueprint.Logging.Configuration;
-using Core.Thalos.Adapters.Contracts;
+using Core.Thalos.BuildingBlocks;
-using Core.Thalos.Adapters.Extensions;
+using Core.Thalos.BuildingBlocks.Configuration;
-using Core.Thalos.Adapters.Services;
+using Core.Thalos.BuildingBlocks.Extensions;
-using Core.Thalos.BFF.Api.Services;
 using Core.Thalos.External.ClientConfiguration;
-using Google.Protobuf.WellKnownTypes;
-using Microsoft.AspNetCore.Authentication;
-using Microsoft.AspNetCore.Authentication.Cookies;
-using Microsoft.AspNetCore.Authentication.JwtBearer;
-using Microsoft.AspNetCore.Authentication.OpenIdConnect;
 using Microsoft.AspNetCore.ResponseCompression;
-using Microsoft.Extensions.Configuration.AzureAppConfiguration;
-using Microsoft.IdentityModel.Tokens;
-using Microsoft.OpenApi.Any;
-using Microsoft.OpenApi.Interfaces;
-using Microsoft.OpenApi.Models;
 using OpenTelemetry.Logs;
 using OpenTelemetry.Resources;
-using Swashbuckle.AspNetCore.SwaggerUI;
 using System.IO.Compression;
 using System.Reflection;
-using System.Security.Claims;
 
 var builder = WebApplication.CreateBuilder(args);
 
@@ -30,171 +16,128 @@ builder.Configuration
     .AddUserSecrets(Assembly.GetExecutingAssembly())
     .AddEnvironmentVariables();
 
-// 🔑 Google Auth config
+var services = builder.Services.AddKeyVault(builder.Configuration);
-var googleClientId = builder.Configuration["Authentication:Google:ClientId"];
-var googleClientSecret = builder.Configuration["Authentication:Google:ClientSecret"];
-var redirectUri = builder.Configuration["Authentication:Google:RedirectUri"];
 
-// 🧩 Authentication
+var authSettings = await AuthHelper.GetAuthSettings(builder.Services, builder, "thalos_common");
-builder.Services.AddAuthentication(options =>
+
-{
+builder.Services.ConfigureAuthentication(builder.Configuration, authSettings);
-    options.DefaultAuthenticateScheme = Constant.Scheme;
-    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
-})
-.AddScheme<AuthenticationSchemeOptions,
-GoogleAccessTokenAuthenticationHandler>(Constant.Scheme, null)
-.AddGoogle(options =>
-{
-    options.ClientId = googleClientId!;
-    options.ClientSecret = googleClientSecret!;
-    //options.SaveTokens = true;
-    options.CallbackPath = $"/{redirectUri}";
-});
 
-builder.Services.AddAuthorization();
-builder.Services.AddScoped<IGoogleAuthHelper, GoogleAuthHelperService>();
-builder.Services.AddScoped<IGoogleAuthorization, GoogleAuthorizationService>();
 builder.Services.AddEndpointsApiExplorer();
 
-// 🧩 Swagger + OAuth2
-builder.Services.AddSwaggerGen(opts =>
-{
-    const string schemeName = "oauth2";
 
-    opts.SwaggerDoc("v1",
-        new OpenApiInfo { Title = "Core.Thalos.BFF", Version = "v1" });
-
-    opts.AddSecurityDefinition(schemeName, new OpenApiSecurityScheme
-    {
-        Type = SecuritySchemeType.OAuth2,
-        Scheme = "bearer",              // tells Swagger-UI to build an Authorization header
-        BearerFormat = "JWT",
-        Name = "Authorization",
-        In = ParameterLocation.Header,
-
-        /* ⚠️  The key line – tell Swagger-UI to pick id_token instead of access_token */
-        Extensions = new Dictionary<string, IOpenApiExtension>
-        {
-            ["x-tokenName"] = new OpenApiString("id_token")
-        },
-
-        Flows = new OpenApiOAuthFlows
-        {
-            AuthorizationCode = new OpenApiOAuthFlow
-            {
-                AuthorizationUrl = new Uri("https://accounts.google.com/o/oauth2/v2/auth"),
-                TokenUrl = new Uri("https://oauth2.googleapis.com/token"),
-                Scopes = new Dictionary<string, string>
-                {
-                    { "openid",  "OpenID Connect" },
-                    { "email",   "Access email"   },
-                    { "profile", "Access profile" }
-                }
-            }
-        }
-    });
-
-    // every operation requires the scheme
-    opts.AddSecurityRequirement(new OpenApiSecurityRequirement
-    {
-        [new OpenApiSecurityScheme
-        {
-            Reference = new OpenApiReference
-            { Type = ReferenceType.SecurityScheme, Id = schemeName }
-        }
-        ] = new[] { "openid", "email", "profile" }
-    });
-});
-
-// 🎯 Existing configs (unchanged)
 builder.Services.AddResponseCompression();
 builder.Services.AddProblemDetails();
 builder.Services.AddLogs(builder);
 builder.Services.AddMemoryCache();
-builder.Services.AddResponseCaching(options => { options.UseCaseSensitivePaths = true; });
+builder.Services.AddResponseCaching(configureOptions => { configureOptions.UseCaseSensitivePaths = true; });
-
+builder.Logging.AddOpenTelemetry(options =>
-builder.Logging.AddOpenTelemetry(logging =>
 {
-    logging.IncludeScopes = true;
+    options.IncludeScopes = true;
-    logging.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("core.thalos.bff.api"))
+    options.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("core.thalos.bff.api")).AddConsoleExporter();
-           .AddConsoleExporter();
 });
 
 builder.Host.ConfigureServices((context, services) =>
 {
-    services.AddHsts(options =>
+    builder.Services.AddHsts(options =>
     {
         options.Preload = true;
         options.IncludeSubDomains = true;
         options.MaxAge = TimeSpan.FromDays(60);
     });
+    builder.Services.AddResponseCaching(configureOptions =>
+    {
+        configureOptions.UseCaseSensitivePaths = true;
+        configureOptions.MaximumBodySize = 2048;
+    });
+    builder.Services.AddHttpsRedirection(options =>
+    {
+        options.RedirectStatusCode = 308;
+    });
 
-    services.AddHttpsRedirection(options => { options.RedirectStatusCode = 308; });
+    services.AddHttpLogging(http =>
+    {
+        http.CombineLogs = true;
+    });
     services.AddAntiforgery();
-    services.AddHttpLogging(http => http.CombineLogs = true);
-    services.AddCors(options => options.AddPolicy("AllowAll", policy => policy.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod()));
 
-    services.AddMvc().AddJsonOptions(opt =>
+    services.AddCors(options =>
     {
-        opt.JsonSerializerOptions.WriteIndented = true;
+        options.AddPolicy("AllowAll", policyBuilder =>
-        opt.JsonSerializerOptions.MaxDepth = 20;
+            policyBuilder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod());
-        opt.JsonSerializerOptions.NumberHandling = System.Text.Json.Serialization.JsonNumberHandling.AllowNamedFloatingPointLiterals;
     });
-
+    services.AddMvc().AddJsonOptions(options =>
-    services.Configure<BrotliCompressionProviderOptions>(opt => opt.Level = CompressionLevel.SmallestSize);
-    services.Configure<GzipCompressionProviderOptions>(opt => opt.Level = CompressionLevel.SmallestSize);
-    services.AddResponseCompression(opt =>
     {
-        opt.EnableForHttps = true;
+        options.JsonSerializerOptions.WriteIndented = true;
-        opt.Providers.Add<BrotliCompressionProvider>();
+        options.JsonSerializerOptions.MaxDepth = 20;
-        opt.Providers.Add<GzipCompressionProvider>();
+        options.JsonSerializerOptions.NumberHandling = System.Text.Json.Serialization.JsonNumberHandling.AllowNamedFloatingPointLiterals;
     });
-
+    services.Configure<BrotliCompressionProviderOptions>(options =>
+    {
+        options.Level = CompressionLevel.SmallestSize;
+    });
+    services.Configure<GzipCompressionProviderOptions>(options =>
+    {
+        options.Level = CompressionLevel.SmallestSize;
+    });
+    services.AddResponseCompression(options =>
+    {
+        options.EnableForHttps = true;
+        options.Providers.Add<BrotliCompressionProvider>();
+        options.Providers.Add<GzipCompressionProvider>();
+    });
+    services.AddResponseCaching();
     services.AddControllers();
+    services.AddSwaggerGen(builder.Configuration, "Core.Thalos.BFF.Api.xml", authSettings);
+    services.AddVersioning(builder.Configuration);
+    services.AddLogging();
+    services.AddProblemDetails();
     services.AddHttpContextAccessor();
-    services.AddTransient<TrackingMechanismExtension>();
+    services.AddTransient<TrackingMechanismExtension>(); // Register the TrackingIdHandler
     services.RegisterExternalLayer(builder.Configuration);
+});
 
-    services.AddApiVersioning(options => options.ReportApiVersions = true)
+builder.Services.AddCors(options =>
-           .AddApiExplorer(opt =>
+{
-           {
+    options.AddDefaultPolicy(
-               opt.GroupNameFormat = "'v'VVV";
+        builder =>
-               opt.SubstituteApiVersionInUrl = true;
+        {
-           });
+            builder.AllowAnyOrigin()
+                                .AllowAnyHeader()
+                                .AllowAnyMethod();
+        });
 });
 
 builder.Services.AddScoped<ITokenService, TokenService>();
 
-var app = builder.Build();
+builder.Services.AddOutputCache(options =>
-
-app.UseDeveloperExceptionPage();
-
-app.UseSwagger();
-
-app.UseCors(options => options.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod().WithOrigins("https://localhost:7239"));
-app.UseSwaggerUI(options =>
 {
-    foreach (var version in app.DescribeApiVersions().Select(v => v.GroupName))
+    options.AddBasePolicy(builder =>
-        options.SwaggerEndpoint($"/swagger/{version}/swagger.json", version);
+        builder.Expire(TimeSpan.FromSeconds(10)));
-
+    options.AddPolicy("Expire20", builder =>
-    options.DisplayRequestDuration();
+        builder.Expire(TimeSpan.FromSeconds(20)));
-    options.EnableTryItOutByDefault();
+    options.AddPolicy("Expire30", builder =>
-    options.DocExpansion(DocExpansion.None);
+        builder.Expire(TimeSpan.FromSeconds(30)));
-
-    options.OAuthClientId(googleClientId);
-    options.OAuthClientSecret(googleClientSecret);
-    options.OAuthUsePkce();
-    options.OAuthScopes("openid", "email", "profile");
 });
 
-app.UseResponseCompression();
+//*************************************************************************//
-app.UseResponseCaching();
+var app = builder.Build();
+app.UseLogging(builder.Configuration);
+app.UseSwaggerUI(builder.Configuration, authSettings);
+app.ConfigureSwagger(builder.Configuration);
+
+
+app.UseRouting();
+app.UseCors();
 app.UseHttpsRedirection();
+app.UseStaticFiles();
+app.UseResponseCompression();
+app.UseOutputCache();
+app.UseResponseCaching();
 
 app.UseAuthentication();
 app.UseAuthorization();
+
 app.MapControllers();
-app.UseHsts();
+//app.MapHealthChecks("/health");
-app.UseAntiforgery();
+
-app.UseLogging(builder.Configuration);
+app.Run();
-app.Run();

Core.Thalos.BFF.Api/Properties/launchSettings.json

@@ -24,7 +24,7 @@
       "dotnetRunMessages": true,
       "launchBrowser": true,
       "launchUrl": "swagger",
-      "applicationUrl": "https://localhost:7239;http://localhost:5219",
+      "applicationUrl": "https://localhost:44320;http://localhost:5219",
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Local"
       }

Core.Thalos.BFF.Api/Services/Constant.cs

@@ -1,7 +0,0 @@
-namespace Core.Thalos.BFF.Api.Services
-{
-    public static class Constant
-    {
-        public const string Scheme = "GoogleAccessToken";
-    }
-}

Core.Thalos.BFF.Api/Services/GoogleAccessTokenAuthenticationHandler.cs

@@ -1,61 +0,0 @@
-using Google.Apis.Auth;
-using Google.Apis.Auth.OAuth2.Flows;
-using Microsoft.AspNetCore.Authentication;
-using Microsoft.Extensions.Options;
-using System.Security.Claims;
-using System.Text.Encodings.Web;
-
-namespace Core.Thalos.BFF.Api.Services
-{
-    public class GoogleAccessTokenAuthenticationHandler(IOptionsMonitor<AuthenticationSchemeOptions> options,
-         ILoggerFactory logger,
-         UrlEncoder encoder,
-         IConfiguration config) : AuthenticationHandler<AuthenticationSchemeOptions>(options, logger, encoder)
-    {
-        protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
-        {
-            if (!Request.Headers.ContainsKey("Authorization"))
-                return AuthenticateResult.Fail("Missing Authorization header");
-
-            var authHeader = Request.Headers.Authorization.ToString();
-            if (!authHeader.StartsWith("Bearer ", StringComparison.OrdinalIgnoreCase))
-                return AuthenticateResult.Fail("Invalid Authorization header");
-
-            var idToken = authHeader["Bearer ".Length..].Trim();
-
-            GoogleJsonWebSignature.Payload payload;
-            try
-            {
-                payload = await GoogleJsonWebSignature.ValidateAsync(
-                    idToken,
-                    new GoogleJsonWebSignature.ValidationSettings
-                    {
-                        Audience = new[] { config["Authentication:Google:ClientId"]! }
-                    });
-            }
-            catch (InvalidJwtException)
-            {
-                return AuthenticateResult.Fail("Invalid Google token");
-            }
-
-            var claims = new List<Claim>
-            {
-                new Claim(ClaimTypes.NameIdentifier, payload.Subject),
-                new Claim(ClaimTypes.Email,          payload.Email),
-                new Claim(ClaimTypes.Name,           payload.Name ?? "")
-            };
-
-            var identity = new ClaimsIdentity(claims, Constant.Scheme);
-            var principal = new ClaimsPrincipal(identity);
-
-            var userEmail = principal.FindFirst(ClaimTypes.Email)?.Value;
-
-            if (string.IsNullOrEmpty(userEmail) || 
-                !userEmail.EndsWith("@agilewebs.com", StringComparison.OrdinalIgnoreCase))
-                return AuthenticateResult.Fail("Unauthorized Access");
-
-            var ticket = new AuthenticationTicket(principal, Constant.Scheme);
-            return AuthenticateResult.Success(ticket);
-        }
-    }
-}

Core.Thalos.BFF.Api/Services/IGoogleAuthHelper.cs

@@ -1,37 +0,0 @@
-using Google.Apis.Auth.OAuth2;
-using Google.Apis.Oauth2.v2;
-
-namespace Core.Thalos.BFF.Api.Services
-{
-    public interface IGoogleAuthHelper
-    {
-        string[] GetScopes();
-        string ScopeToString();
-        ClientSecrets GetClientSecrets();
-    }
-
-    public class GoogleAuthHelperService(IConfiguration config) : IGoogleAuthHelper
-    {
-        public ClientSecrets GetClientSecrets()
-        {
-            string clientId = config["Authentication:Google:ClientId"]!;
-            string clientSecret = config["Authentication:Google:ClientSecret"]!;
-
-            return new() { ClientId = clientId, ClientSecret = clientSecret };
-        }
-
-        public string[] GetScopes()
-        {
-            var scopes = new[]
-            {
-                Oauth2Service.Scope.Openid,
-                Oauth2Service.Scope.UserinfoEmail,
-                Oauth2Service.Scope.UserinfoProfile
-            };
-
-            return scopes;
-        }
-
-        public string ScopeToString() => string.Join(", ", GetScopes());
-    }
-}

Core.Thalos.BFF.Api/Services/IGoogleAuthorization.cs

@@ -1,42 +0,0 @@
-using Google.Apis.Auth.OAuth2;
-using Google.Apis.Auth.OAuth2.Flows;
-
-namespace Core.Thalos.BFF.Api.Services
-{
-    public interface IGoogleAuthorization
-    {
-        string GetAuthorizationUrl();
-        Task<UserCredential> ExchangeCodeForToken(string code);
-    }
-
-    public class GoogleAuthorizationService(
-        IGoogleAuthHelper googleHelper, IConfiguration config) : IGoogleAuthorization
-    {
-        private string RedirectUrl = config["Authentication:Google:RedirectUri"]!;
-
-        public async Task<UserCredential> ExchangeCodeForToken(string code)
-        {
-            var flow = new GoogleAuthorizationCodeFlow(
-                new GoogleAuthorizationCodeFlow.Initializer
-                {
-                    ClientSecrets = googleHelper.GetClientSecrets(),
-                    Scopes = googleHelper.GetScopes()
-                });
-
-            var token = await flow.ExchangeCodeForTokenAsync(
-                "user", code, RedirectUrl, CancellationToken.None);
-
-            return new UserCredential(flow, "user", token);
-        }
-
-        public string GetAuthorizationUrl() =>
-            new GoogleAuthorizationCodeFlow(
-                new GoogleAuthorizationCodeFlow.Initializer
-                {
-
-                    ClientSecrets = googleHelper.GetClientSecrets(),
-                    Scopes = googleHelper.GetScopes(),
-                    Prompt = "consent"
-                }).CreateAuthorizationCodeRequest(RedirectUrl).Build().ToString();
-    }
-}

Core.Thalos.BFF.Api/Services/Token.cs

@@ -1,4 +0,0 @@
-namespace Core.Thalos.BFF.Api.Services
-{
-    public record Token(string IdToken);
-}

Core.Thalos.BFF.Api/appsettings.Local.json

@@ -6,15 +6,20 @@
     }
   },
   "LocalGateways": {
-    "ThalosService": "https://localhost:7253/api"
+    "ThalosService": "https://localhost:44312/api"
   },
-  "Authentication": {
+  "ServiceSettings": {
-    "Google": {
+    "ApplicationName": "thalos",
-      "ClientId": "128345072002-mtfdgpcur44o9tbd7q6e0bb9qnp2crfp.apps.googleusercontent.com",
+    "LayerName": "bff"
-      "ClientSecret": "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",
+  },
-      "ApplicationName": "Thalos",
+  "Vault": {
-      "RedirectUri": "https://localhost:7239/api/v1/Authentication/callback"
+    "Address": "https://vault.dream-views.com/",
-    }
+    "Token": "hvs.TGz6P3AsKpYuODMrs11Msiza",
+    "SecretMount": "thalos"
+  },
+  "IdentityProviders": {
+    "Google": true,
+    "Azure": false
   }
 }
 

Core.Thalos.External/ClientConfiguration/RegisterClientConfiguration.cs

@@ -1,6 +1,4 @@
-using Core.Thalos.Adapters.Contracts;
+using Core.Thalos.BuildingBlocks;
-using Core.Thalos.Adapters.Handlers;
-using Core.Thalos.Adapters.TokenProvider;
 using Core.Thalos.External.GatewayConfigurations;
 using LSA.Dashboard.External.Clients.Dashboard;
 using Microsoft.AspNetCore.Http;

Core.Thalos.External/Clients/Thalos/IThalosServiceClient.cs

@@ -1,7 +1,8 @@
-using Core.Thalos.Adapters;
+using Core.Thalos.Application.UseCases.Roles.Input;
-using Core.Thalos.Application.UseCases.Roles.Input;
 using Core.Thalos.Application.UseCases.Users.Input;
+using Core.Thalos.BuildingBlocks;
 using Core.Thalos.External.Clients.Thalos.Requests.Permissions;
+using Core.Thalos.External.Clients.Thalos.Requests.Tenants;
 using Core.Thalos.External.Clients.Thalos.Requests.Users;
 using Microsoft.AspNetCore.Mvc;
 using Refit;
@@ -31,6 +32,9 @@ namespace LSA.Dashboard.External.Clients.Dashboard
         [Put("/v1/User/Update")]
         Task<ApiResponse<UserAdapter>> UpdateUserService([Header("TrackingId")][Body] UpdateUserRequest request, CancellationToken cancellationToken = default);
 
+        [Delete("/v1/User/Delete")]
+        Task<ApiResponse<UserAdapter>> DeleteUserByIdService([Header("TrackingId")][Body] DeleteUserRequest request, CancellationToken cancellationToken = default);
+
         [Patch("/v1/User/LoginUser")]
         Task<ApiResponse<UserAdapter>> LoginUserService([Header("TrackingId")][Body] LoginUserRequest request, CancellationToken cancellationToken = default);
 
@@ -40,18 +44,6 @@ namespace LSA.Dashboard.External.Clients.Dashboard
         [Patch("/v1/User/ChangeStatus")]
         Task<ApiResponse<UserAdapter>> ChangeUserStatusService([Header("TrackingId")][Body] ChangeUserStatusRequest request, CancellationToken cancellationToken = default);
 
-        [Post("/v1/User/AddCompany")]
-        Task<ApiResponse<UserAdapter>> AddCompanyToUserService([Header("TrackingId")][Body] AddCompanyToUserRequest request, CancellationToken cancellationToken = default);
-
-        [Delete("/v1/User/RemoveCompany")]
-        Task<ApiResponse<UserAdapter>> RemoveCompanyFromUserService([Header("TrackingId")][Body] RemoveCompanyFromUserRequest request, CancellationToken cancellationToken = default);
-
-        [Post("/v1/User/AddProject")]
-        Task<ApiResponse<UserAdapter>> AddProjectToUserService([Header("TrackingId")][Body] AddProjectToUserRequest request, CancellationToken cancellationToken = default);
-
-        [Delete("/v1/User/RemoveProject")]
-        Task<ApiResponse<UserAdapter>> RemoveProjectFromUserService([Header("TrackingId")][Body] RemoveProjectFromUserRequest request, CancellationToken cancellationToken = default);
-
         [Post("/v1/User/GetTokenAdapter")]
         Task<ApiResponse<TokenAdapter>> GetTokenAdapterService([Header("TrackingId")][Body] GetTokenAdapterRequest request, CancellationToken cancellationToken = default);
 
@@ -73,6 +65,9 @@ namespace LSA.Dashboard.External.Clients.Dashboard
         [Patch("/v1/Role/ChangeStatus")]
         Task<ApiResponse<RoleAdapter>> ChangeRoleStatusService([Header("TrackingId")][Body] ChangeRoleStatusRequest request, CancellationToken cancellationToken = default);
 
+        [Delete("/v1/Role/Delete")]
+        Task<ApiResponse<RoleAdapter>> DeleteRoleByIdService([Header("TrackingId")][Body] DeleteRoleRequest request, CancellationToken cancellationToken = default);
+
         [Post("/v1/Role/AddApplication")]
         Task<ApiResponse<RoleAdapter>> AddApplicationToRoleService([Header("TrackingId")][Body] AddApplicationToRoleRequest request, CancellationToken cancellationToken = default);
 
@@ -97,6 +92,9 @@ namespace LSA.Dashboard.External.Clients.Dashboard
         [Patch("/v1/Permission/ChangeStatus")]
         Task<ApiResponse<PermissionAdapter>> ChangePermissionStatusService([Header("TrackingId")][Body] ChangePermissionStatusRequest request, CancellationToken cancellationToken = default);
 
+        [Delete("/v1/Permission/Delete")]
+        Task<ApiResponse<PermissionAdapter>> DeletePermissionByIdService([Header("TrackingId")][Body] DeletePermissionRequest request, CancellationToken cancellationToken = default);
+
         [Post("/v1/Module/Create")]
         Task<ApiResponse<ModuleAdapter>> CreateModuleService([Header("TrackingId")][Body] CreateModuleRequest request, CancellationToken cancellationToken = default);
 
@@ -114,5 +112,27 @@ namespace LSA.Dashboard.External.Clients.Dashboard
 
         [Patch("/v1/Module/ChangeStatus")]
         Task<ApiResponse<ModuleAdapter>> ChangeModuleStatusService([Header("TrackingId")][Body] ChangeModuleStatusRequest request, CancellationToken cancellationToken = default);
+
+        [Delete("/v1/Module/Delete")]
+        Task<ApiResponse<ModuleAdapter>> DeleteModuleByIdService([Header("TrackingId")][Body] DeleteModuleRequest request, CancellationToken cancellationToken = default);
+
+
+        [Post("/v1/Tenant/Create")]
+        Task<ApiResponse<TenantAdapter>> CreateTenantService([Header("TrackingId")][Body] CreateTenantRequest request, CancellationToken cancellationToken = default);
+
+        [Post("/v1/Tenant/GetById")]
+        Task<ApiResponse<TenantAdapter>> GetTenantByIdService([Header("TrackingId")][Body] GetTenantRequest request, CancellationToken cancellationToken = default);
+
+        [Get("/v1/Tenant/GetAll")]
+        Task<ApiResponse<IEnumerable<TenantAdapter>>> GetAllTenantsService([Header("TrackingId")][Body] GetAllTenantsRequest request, CancellationToken cancellationToken = default);
+
+        [Put("/v1/Tenant/Update")]
+        Task<ApiResponse<TenantAdapter>> UpdateTenantService([Header("TrackingId")][Body] UpdateTenantRequest request, CancellationToken cancellationToken = default);
+
+        [Patch("/v1/Tenant/ChangeStatus")]
+        Task<ApiResponse<TenantAdapter>> ChangeTenantStatusService([Header("TrackingId")][Body] ChangeTenantStatusRequest request, CancellationToken cancellationToken = default);
+
+        [Delete("/v1/Tenant/Delete")]
+        Task<ApiResponse<UserAdapter>> DeleteTenantByIdService([Header("TrackingId")][Body] DeleteTenantRequest request, CancellationToken cancellationToken = default);
     }
 }

Core.Thalos.External/Clients/Thalos/Requests/Modules/ChangeModuleStatusRequest.cs

@@ -4,7 +4,7 @@ namespace Core.Thalos.External.Clients.Thalos.Requests.Permissions
 {
     public class ChangeModuleStatusRequest
     {
-        public string Id { get; set; }
+        public string _Id { get; set; }
         public StatusEnum Status { get; set; }
     }
 }

Core.Thalos.External/Clients/Thalos/Requests/Modules/CreateModuleRequest.cs

@@ -1,4 +1,4 @@
-using Core.Thalos.Adapters.Common.Enums;
+using Core.Thalos.BuildingBlocks;
 
 namespace Core.Thalos.External.Clients.Thalos.Requests.Permissions
 {

Core.Thalos.External/Clients/Thalos/Requests/Modules/DeleteModuleRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Thalos.External.Clients.Thalos.Requests.Permissions
+{
+    public class DeleteModuleRequest
+    {
+        public string _Id { get; set; }
+    }
+}

Core.Thalos.External/Clients/Thalos/Requests/Modules/GetModuleRequest.cs

@@ -2,6 +2,6 @@
 {
     public class GetModuleRequest
     {
-        public string Id { get; set; }
+        public string _Id { get; set; }
     }
 }

Core.Thalos.External/Clients/Thalos/Requests/Modules/UpdateModuleRequest.cs

@@ -1,12 +1,11 @@
-using Core.Blueprint.Mongo;
+using Core.Thalos.BuildingBlocks;
-using Core.Thalos.Adapters.Common.Enums;
 using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
 
 namespace Core.Thalos.External.Clients.Thalos.Requests.Permissions
 {
     public class UpdateModuleRequest
     {
-        public string Id { get; set; } = null!;
+        public string _Id { get; set; } = null!;
         public string Name { get; set; } = null!;
         public string? Description { get; set; }
         public string? Icon { get; set; }

Core.Thalos.External/Clients/Thalos/Requests/Permissions/ChangePermissionStatusRequest.cs

@@ -4,7 +4,7 @@ namespace Core.Thalos.External.Clients.Thalos.Requests.Permissions
 {
     public class ChangePermissionStatusRequest
     {
-        public string Id { get; set; }
+        public string _Id { get; set; }
         public StatusEnum Status { get; set; }
     }
 }

Core.Thalos.External/Clients/Thalos/Requests/Permissions/CreatePermissionRequest.cs

@@ -1,4 +1,4 @@
-using Core.Thalos.Adapters.Common.Constants;
+using Core.Thalos.BuildingBlocks;
 
 namespace Core.Thalos.External.Clients.Thalos.Requests.Permissions
 {

Core.Thalos.External/Clients/Thalos/Requests/Permissions/DeletePermissionRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Thalos.External.Clients.Thalos.Requests.Permissions
+{
+    public class DeletePermissionRequest
+    {
+        public string _Id { get; set; }
+    }
+}

Core.Thalos.External/Clients/Thalos/Requests/Permissions/GetPermissionRequest.cs

@@ -2,6 +2,6 @@
 {
     public class GetPermissionRequest
     {
-        public string Id { get; set; }
+        public string _Id { get; set; }
     }
 }

Core.Thalos.External/Clients/Thalos/Requests/Permissions/UpdatePermissionRequest.cs

@@ -1,11 +1,11 @@
-using Core.Thalos.Adapters.Common.Constants;
+using Core.Thalos.BuildingBlocks;
 using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
 
 namespace Core.Thalos.External.Clients.Thalos.Requests.Permissions
 {
     public class UpdatePermissionRequest
     {
-        public string Id { get; set; } = null!;
+        public string _Id { get; set; } = null!;
         public string Name { get; set; } = null!;
         public string? Description { get; set; }
         public AccessLevelEnum? AccessLevel { get; set; } = null!;

Core.Thalos.External/Clients/Thalos/Requests/Roles/AddApplicationToRoleRequest.cs

@@ -1,4 +1,4 @@
-using Core.Thalos.Adapters.Common.Enums;
+using Core.Thalos.BuildingBlocks;
 
 namespace Core.Thalos.Application.UseCases.Roles.Input
 {

Core.Thalos.External/Clients/Thalos/Requests/Roles/ChangeRoleStatusRequest.cs

@@ -4,7 +4,7 @@ namespace Core.Thalos.Application.UseCases.Roles.Input
 {
     public class ChangeRoleStatusRequest
     {
-        public string Id { get; set; }
+        public string _Id { get; set; }
         public StatusEnum Status { get; set; }
 
     }

Core.Thalos.External/Clients/Thalos/Requests/Roles/CreateRoleRequest.cs

@@ -1,4 +1,4 @@
-using Core.Thalos.Adapters.Common.Enums;
+using Core.Thalos.BuildingBlocks;
 using System.Text.Json.Serialization;
 
 namespace Core.Thalos.Application.UseCases.Roles.Input

Core.Thalos.External/Clients/Thalos/Requests/Roles/DeleteRoleRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Thalos.Application.UseCases.Roles.Input
+{
+    public class DeleteRoleRequest
+    {
+        public string _Id { get; set; }
+    }
+}

Core.Thalos.External/Clients/Thalos/Requests/Roles/GetRoleRequest.cs

@@ -2,6 +2,6 @@
 {
     public class GetRoleRequest
     {
-        public string Id { get; set; }
+        public string _Id { get; set; }
     }
 }

Core.Thalos.External/Clients/Thalos/Requests/Roles/RemoveApplicationFromRoleRequest.cs

@@ -1,4 +1,4 @@
-using Core.Thalos.Adapters.Common.Enums;
+using Core.Thalos.BuildingBlocks;
 
 namespace Core.Thalos.Application.UseCases.Roles.Input
 {

Core.Thalos.External/Clients/Thalos/Requests/Roles/UpdateRoleRequest.cs

@@ -1,4 +1,4 @@
-using Core.Thalos.Adapters.Common.Enums;
+using Core.Thalos.BuildingBlocks;
 using System.Text.Json.Serialization;
 using StatusEnum = Core.Blueprint.Mongo.StatusEnum;
 
@@ -6,7 +6,7 @@ namespace Core.Thalos.Application.UseCases.Roles.Input
 {
     public class UpdateRoleRequest
     {
-        public string Id { get; set; } = null!;
+        public string _Id { get; set; } = null!;
         public string Name { get; set; } = null!;
         public string? Description { get; set; }
         [JsonConverter(typeof(EnumArrayJsonConverter<ApplicationsEnum>))]

Core.Thalos.External/Clients/Thalos/Requests/Tenants/ChangeTenantStatusRequest.cs

@@ -0,0 +1,10 @@
+using Core.Blueprint.Mongo;
+
+namespace Core.Thalos.External.Clients.Thalos.Requests.Tenants
+{
+    public class ChangeTenantStatusRequest
+    {
+        public string _Id { get; set; }
+        public StatusEnum Status { get; set; }
+    }
+}

Core.Thalos.External/Clients/Thalos/Requests/Tenants/CreateTenantRequest.cs

@@ -0,0 +1,31 @@
+namespace Core.Thalos.External.Clients.Thalos.Requests.Tenants
+{
+    public class CreateTenantRequest
+    {
+        public string Name { get; set; } = null!;
+
+        public string TaxIdentifier { get; set; } = null!;
+
+        public string AddressLine1 { get; set; } = null!;
+
+        public string? AddressLine2 { get; set; }
+
+        public string City { get; set; } = null!;
+
+        public string State { get; set; } = null!;
+
+        public string Country { get; set; } = null!;
+
+        public string PostalCode { get; set; } = null!;
+
+        public string ContactEmail { get; set; } = null!;
+
+        public string ContactPhone { get; set; } = null!;
+
+        public string? Website { get; set; }
+
+        public string? ConnectionString { get; set; }
+
+        public bool Isolated { get; set; }
+    }
+}

Core.Thalos.External/Clients/Thalos/Requests/Tenants/DeleteTenantRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Thalos.External.Clients.Thalos.Requests.Tenants
+{
+    public class DeleteTenantRequest
+    {
+        public string _Id { get; set; }
+    }
+}

Core.Thalos.External/Clients/Thalos/Requests/Tenants/GetAllTenantsRequest.cs

@@ -0,0 +1,6 @@
+namespace Core.Thalos.External.Clients.Thalos.Requests.Tenants
+{
+    public class GetAllTenantsRequest
+    {
+    }
+}

Core.Thalos.External/Clients/Thalos/Requests/Tenants/GetTenantRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Thalos.External.Clients.Thalos.Requests.Tenants
+{
+    public class GetTenantRequest
+    {
+        public string _Id { get; set; }
+    }
+}

Core.Thalos.External/Clients/Thalos/Requests/Tenants/UpdateTenantRequest.cs

@@ -0,0 +1,39 @@
+namespace Core.Thalos.External.Clients.Thalos.Requests.Tenants
+{
+    public class UpdateTenantRequest
+    {
+        public string Name { get; set; } = null!;
+
+        public string TaxIdentifier { get; set; } = null!;
+
+        public string AddressLine1 { get; set; } = null!;
+
+        public string? AddressLine2 { get; set; }
+
+        public string City { get; set; } = null!;
+
+        public string State { get; set; } = null!;
+
+        public string Country { get; set; } = null!;
+
+        public string PostalCode { get; set; } = null!;
+
+        public string ContactEmail { get; set; } = null!;
+
+        public string ContactPhone { get; set; } = null!;
+
+        public string? Website { get; set; }
+
+        public string? ConnectionString { get; set; }
+
+        public bool Isolated { get; set; }
+        public string _Id { get; set; } = null!;
+        public string Id { get; init; } = null!;
+        public DateTime CreatedAt { get; set; }
+        public string? CreatedBy { get; set; }
+        public DateTime? UpdatedAt { get; set; }
+        public string? UpdatedBy { get; set; }
+
+        public Blueprint.Mongo.StatusEnum Status { get; set; }
+    }
+}

Core.Thalos.External/Clients/Thalos/Requests/Users/AddCompanyToUserRequest.cs

@@ -1,8 +0,0 @@
-namespace Core.Thalos.Application.UseCases.Users.Input
-{
-    public class AddCompanyToUserRequest
-    {
-        public string UserId { get; set; }
-        public string CompanyId { get; set; }
-    }
-}

Core.Thalos.External/Clients/Thalos/Requests/Users/AddProjectToUserRequest.cs

@@ -1,8 +0,0 @@
-namespace Core.Thalos.Application.UseCases.Users.Input
-{
-    public class AddProjectToUserRequest
-    {
-        public string UserId { get; set; }
-        public string ProjectId { get; set; }
-    }
-}

Core.Thalos.External/Clients/Thalos/Requests/Users/ChangeUserStatusRequest.cs

@@ -4,7 +4,7 @@ namespace Core.Thalos.Application.UseCases.Users.Input
 {
     public class ChangeUserStatusRequest
     {
-        public string Id { get; set; }
+        public string _Id { get; set; }
         public StatusEnum Status { get; set; }
     }
 }

Core.Thalos.External/Clients/Thalos/Requests/Users/CreateUserRequest.cs

@@ -7,8 +7,7 @@
         public string? MiddleName { get; set; }
         public string LastName { get; set; } = null!;
         public string RoleId { get; set; } = null!;
-        public string[] Companies { get; set; } = null!;
+        public string TenantId { get; set; } = null!;
-        public string[]? Projects { get; set; }
         public bool SendInvitation { get; set; }
     }
 }

Core.Thalos.External/Clients/Thalos/Requests/Users/DeleteUserRequest.cs

@@ -0,0 +1,7 @@
+namespace Core.Thalos.Application.UseCases.Users.Input
+{
+    public class DeleteUserRequest
+    {
+        public string _Id { get; set; }
+    }
+}

Core.Thalos.External/Clients/Thalos/Requests/Users/GetUserRequest.cs

@@ -2,6 +2,6 @@
 {
     public class GetUserRequest
     {
-        public string Id { get; set; }
+        public string _Id { get; set; }
     }
 }

Core.Thalos.External/Clients/Thalos/Requests/Users/RemoveCompanyFromUserRequest.cs

@@ -1,8 +0,0 @@
-namespace Core.Thalos.Application.UseCases.Users.Input
-{
-    public class RemoveCompanyFromUserRequest
-    {
-        public string UserId { get; set; }
-        public string CompanyId { get; set; }
-    }
-}

Core.Thalos.External/Clients/Thalos/Requests/Users/RemoveProjectFromUserRequest.cs

@@ -1,8 +0,0 @@
-namespace Core.Thalos.Application.UseCases.Users.Input
-{
-    public class RemoveProjectFromUserRequest
-    {
-        public string UserId { get; set; }
-        public string ProjectId { get; set; }
-    }
-}

Core.Thalos.External/Clients/Thalos/Requests/Users/UpdateUserRequest.cs

@@ -4,14 +4,14 @@ namespace Core.Thalos.Application.UseCases.Users.Input
 {
     public class UpdateUserRequest
     {
-        public string Id { get; set; } = null!;
+        public string _Id { get; set; } = null!;
         public string Email { get; set; } = null!;
         public string Name { get; set; } = null!;
         public string? MiddleName { get; set; }
         public string LastName { get; set; } = null!;
         public string RoleId { get; set; } = null!;
-        public string[] Companies { get; set; } = null!;
+        public string TenantId { get; set; } = null!;
-        public string[]? Projects { get; set; }
+
         public StatusEnum Status { get; set; }
     }
 }

Core.Thalos.External/Core.Thalos.External.csproj

@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Core.Thalos.BuildingBlocks" Version="1.0.2" />
+    <PackageReference Include="Core.Thalos.BuildingBlocks" Version="1.0.5" />
     <PackageReference Include="Lib.Architecture.BuildingBlocks" Version="1.0.0" />
     <PackageReference Include="Refit" Version="8.0.0" />
   </ItemGroup>

Dockerfile

@@ -0,0 +1,38 @@
+# ============ Build ============
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+WORKDIR /src
+
+# (opcional) si tienes nuget.config
+COPY nuget.config* ./
+
+# Cache de restore por proyecto
+COPY Core.Thalos.External/Core.Thalos.External.csproj Core.Thalos.External/
+COPY Core.Thalos.BFF.Api/Core.Thalos.BFF.Api.csproj Core.Thalos.BFF.Api/
+
+RUN dotnet restore Core.Thalos.BFF.Api/Core.Thalos.BFF.Api.csproj
+
+# Copia del resto + build
+COPY . .
+RUN dotnet build Core.Thalos.BFF.Api/Core.Thalos.BFF.Api.csproj -c Release -o /app/build
+
+# ============ Publish ============
+FROM build AS publish
+RUN dotnet publish Core.Thalos.BFF.Api/Core.Thalos.BFF.Api.csproj -c Release -o /app/publish --no-restore
+
+# ============ Runtime ============
+FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
+# curl (opcional) si luego cambias a healthcheck HTTP
+RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+EXPOSE 8080
+
+# Usuario no-root
+RUN useradd -m appuser
+USER appuser
+
+ENV ASPNETCORE_URLS=http://+:8080
+# La app agrega UserSecrets/ENV/KeyVault/Auth en runtime (no hornear secretos). :contentReference[oaicite:9]{index=9}
+
+COPY --from=publish /app/publish ./
+ENTRYPOINT ["dotnet", "Core.Thalos.BFF.Api.dll"]

nuget.config

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <!-- Tu BaGet primero -->
+    <add key="BaGet" value="https://nuget.dream-views.com/v3/index.json" protocolVersion="3" />
+    <!-- NuGet oficial como fallback (si quieres) -->
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+  </packageSources>
+</configuration>