Merge remote-tracking branch 'refs/remotes/origin/development' into development

Reviewed-on: #12
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.DAL.API/Core.Thalos.DAL.API.csproj

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

Core.Thalos.DAL.API/HealthCheck/MongoConnectionHealthCheck.cs

@@ -0,0 +1,31 @@
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using MongoDB.Bson;
+using MongoDB.Driver;
+
+namespace Core.Thalos.DAL.API.HealthCheck
+{
+    public class MongoConnectionHealthCheck(string connectionString, string databaseName) : IHealthCheck
+    {
+
+        public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
+        {
+            var settings = MongoClientSettings.FromConnectionString(connectionString);
+
+            try
+            {
+                var mongoClient = new MongoClient(settings);
+
+                var database = mongoClient.GetDatabase(databaseName);
+                var command = new BsonDocument("ping", 1);
+
+                await database.RunCommandAsync<BsonDocument>(command);
+
+                return HealthCheckResult.Healthy($"MongoDB is healthy, {databaseName} database from {settings.Server} is reachable.");
+            }
+            catch (Exception ex)
+            {
+                return HealthCheckResult.Degraded($"MongoDB is Degraded, {databaseName} database from {settings?.Server?.Host} is unreachable.", ex);
+            }
+        }
+    }
+}

Core.Thalos.DAL.API/HealthCheck/RedisConnectionHealthCheck.cs

@@ -0,0 +1,30 @@
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using StackExchange.Redis;
+
+public sealed class RedisConnectionHealthCheck : IHealthCheck
+{
+    private readonly string _connectionString;
+    public RedisConnectionHealthCheck(string connectionString) => _connectionString = connectionString;
+
+    public async Task<HealthCheckResult> CheckHealthAsync(
+        HealthCheckContext context,
+        CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var options = ConfigurationOptions.Parse(_connectionString);
+            options.AbortOnConnectFail = false;
+            options.ConnectTimeout = 2000;   // optional, be snappy
+
+            using var mux = await ConnectionMultiplexer.ConnectAsync(options);
+            if (!mux.IsConnected) return HealthCheckResult.Unhealthy("Redis not connected.");
+
+            var ping = await mux.GetDatabase().PingAsync();
+            return HealthCheckResult.Healthy($"Redis OK (ping {ping.TotalMilliseconds:N0} ms)");
+        }
+        catch (Exception ex)
+        {
+            return HealthCheckResult.Unhealthy("Redis check failed.", ex);
+        }
+    }
+}

Core.Thalos.DAL.API/HealthCheck/Writer/HealthCheckResponseWriter.cs

@@ -0,0 +1,50 @@
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using System.Text.Json;
+
+namespace Core.Thalos.DAL.API.HealthCheck.Writer
+{
+    public static class HealthCheckResponseWriter
+    {
+        public static Task WriteResponse(HttpContext context, HealthReport result)
+        {
+            context.Response.ContentType = "application/json";
+
+            context.Response.StatusCode = result.Status switch
+            {
+                HealthStatus.Healthy => StatusCodes.Status200OK,
+                HealthStatus.Degraded => StatusCodes.Status500InternalServerError,
+                HealthStatus.Unhealthy => StatusCodes.Status503ServiceUnavailable,
+                _ => StatusCodes.Status500InternalServerError
+            };
+
+            var options = new JsonSerializerOptions
+            {
+                WriteIndented = true,
+                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+            };
+
+            var json = new
+            {
+                status = result.Status.ToString(),
+                services = result.Entries.Select(e => new
+                {
+                    key = e.Key,
+                    status = e.Value.Status.ToString(),
+                    description = e.Value.Description ?? string.Empty,
+                    exception = e.Value.Exception?.Message,
+                    duration = e.Value.Duration.ToString(),
+
+                    statusCode = e.Value.Status switch
+                    {
+                        HealthStatus.Healthy => StatusCodes.Status200OK,
+                        HealthStatus.Degraded => StatusCodes.Status500InternalServerError,
+                        HealthStatus.Unhealthy => StatusCodes.Status503ServiceUnavailable,
+                        _ => StatusCodes.Status500InternalServerError
+                    }
+                })
+            };
+
+            return context.Response.WriteAsync(JsonSerializer.Serialize(json, options));
+        }
+    }
+}

Core.Thalos.DAL.API/Program.cs

@@ -4,8 +4,12 @@ using Core.Blueprint.Logging.Configuration;
 using Core.Blueprint.Redis.Configuration;
 using Core.Thalos.BuildingBlocks;
 using Core.Thalos.BuildingBlocks.Configuration;
+using Core.Thalos.DAL.API.HealthCheck;
+using Core.Thalos.DAL.API.HealthCheck.Writer;
 using Core.Thalos.Provider;
+using Microsoft.AspNetCore.Diagnostics.HealthChecks;
 using Microsoft.AspNetCore.HttpLogging;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
 using System.Reflection;
 using System.Text.Json.Serialization;
 
@@ -64,6 +68,21 @@ builder.Host.ConfigureServices((context, services) =>
     });
 });
 
+// Add health checks
+builder.Services.AddHealthChecks()
+    .AddCheck(
+        "mongodb",
+        new MongoConnectionHealthCheck(
+            connectionString: builder.Configuration.GetConnectionString("MongoDB")!,
+            databaseName: builder.Configuration.GetSection("MongoDb:DatabaseName").Value!),
+        failureStatus: HealthStatus.Unhealthy,
+        tags: new[] { "db", "mongo" })
+    .AddCheck(
+        "redis",
+        new RedisConnectionHealthCheck(builder.Configuration.GetConnectionString("Redis")!),
+        failureStatus: HealthStatus.Unhealthy,
+        tags: new[] { "db", "redis" });
+
 var app = builder.Build();
 
 app.UseLogging(builder.Configuration);
@@ -82,6 +101,10 @@ app.UseAuthentication();
 app.UseAuthorization();
 
 app.MapControllers();
-app.MapHealthChecks("/health");
+app.MapHealthChecks("/health", new HealthCheckOptions
+{
+    ResponseWriter = HealthCheckResponseWriter.WriteResponse,
+    AllowCachingResponses = false
+});
 
 app.Run();

Core.Thalos.DAL.API/Properties/launchSettings.json

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

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

@@ -7,15 +7,16 @@
   },
   "AllowedHosts": "*",
   "ConnectionStrings": {
-    "MongoDB": "mongodb://admin_agile:Admin%40agileWebs@portainer.white-enciso.pro:27017/?authMechanism=SCRAM-SHA-256",
-    "Redis": "100.123.31.103:6379"
+    "MongoDB": "mongodb://admin_agile:AdminAgileWebs@portainer.dream-views.com:27017/?authMechanism=SCRAM-SHA-256",
+    //"MongoDB": "mongodb://admin_agile:Admin%40agileWebs@portainer.white-enciso.pro:27017/?authMechanism=SCRAM-SHA-256",
+    "Redis": "172.22.0.2:6379"
   },
   "MongoDb": {
     "DatabaseName": "Thalos",
     "LocalAudience": ""
   },
   "DetailedErrors": true,
-  "UseRedisCache": true,
+  "UseRedisCache": false,
   "CacheSettings": {
     "DefaultCacheDurationInMinutes": 3
   },
@@ -24,12 +25,12 @@
     "LayerName": "dal"
   },
   "Vault": {
-    "Address": "http://100.123.31.103:8200",
-    "Token": "hvs.e37LQvLuPhTd5ALS5QQ03Cwm",
-    "SecretMount": "secret"
+    "Address": "https://vault.dream-views.com/",
+    "Token": "hvs.TGz6P3AsKpYuODMrs11Msiza",
+    "SecretMount": "thalos"
   },
   "IdentityProviders": {
     "Google": true,
-    "Azure":  true
+    "Azure": false
   }
 }

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

@@ -54,5 +54,13 @@ namespace Core.Thalos.Domain.Contexts.Onboarding.Request
         [BsonRepresentation(BsonType.ObjectId)]
         [JsonPropertyName("roleId")]
         public string RoleId { get; set; } = null!;
+
+        /// <summary>
+        /// Gets or sets the tenant ID of the user.
+        /// </summary>
+        [BsonElement("tenantId")]
+        [BsonRepresentation(BsonType.ObjectId)]
+        [JsonPropertyName("tenantId")]
+        public string TenantId { get; set; } = null!;
     }
 }

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

@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Core.Blueprint.KeyVault" Version="1.0.3" />
-    <PackageReference Include="Core.Thalos.BuildingBlocks" Version="1.1.2" />
+    <PackageReference Include="Core.Blueprint.KeyVault" Version="1.0.0" />
+    <PackageReference Include="Core.Thalos.BuildingBlocks" Version="1.0.5" />
   </ItemGroup>
 
 </Project>

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

@@ -11,8 +11,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Core.Blueprint.Mongo" Version="1.0.1" />
-    <PackageReference Include="Core.Blueprint.Redis" Version="1.0.2" />
+    <PackageReference Include="Core.Blueprint.Mongo" Version="1.0.0" />
+    <PackageReference Include="Core.Blueprint.Redis" Version="1.0.0" />
     <PackageReference Include="Mapster" Version="7.4.2-pre02" />
   </ItemGroup>
 

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

@@ -82,7 +82,7 @@ namespace Core.Thalos.Provider.Providers.Onboarding
             var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllUsers");
             var cachedData = await cacheProvider.GetAsync<IEnumerable<UserAdapter>>(cacheKey) ?? [];
 
-            //if (cachedData.Any()) return cachedData;
+            if (cachedData.Any()) return cachedData;
 
             var users = await repository.AsQueryable();
 
@@ -221,116 +221,144 @@ namespace Core.Thalos.Provider.Providers.Onboarding
             {
                 var pipeline = new[]
                 {
-                    new BsonDocument("$match", new BsonDocument
+            new BsonDocument("$match", new BsonDocument
+            {
+                { "email", new BsonDocument
                     {
-                        { "email", new BsonDocument
-                            {
-                                { "$regex", $"^{Regex.Escape(email)}$" },
-                                { "$options", "i" }
-                            }
-                        },
-                        { "status", Core.Blueprint.Mongo.StatusEnum.Active.ToString() }
-                    }),
-
-                    new BsonDocument("$lookup", new BsonDocument
+                        { "$regex", $"^{Regex.Escape(email)}$" },
+                        { "$options", "i" }
+                    }
+                },
+                { "status", Core.Blueprint.Mongo.StatusEnum.Active.ToString() }
+            }),
+            new BsonDocument("$lookup", new BsonDocument
+            {
+                { "from", "Roles" },
+                { "localField", "roleId" },
+                { "foreignField", "_id" },
+                { "as", "role" }
+            }),
+            new BsonDocument("$unwind", "$role"),
+            new BsonDocument("$match", new BsonDocument("role.status", Core.Blueprint.Mongo.StatusEnum.Active.ToString())),
+            new BsonDocument("$lookup", new BsonDocument
+            {
+                { "from", "Tenants" },
+                { "localField", "tenantId" },
+                { "foreignField", "_id" },
+                { "as", "tenant" }
+            }),
+            new BsonDocument("$unwind", "$tenant"),
+            new BsonDocument("$addFields", new BsonDocument
+            {
+                { "role.permissions", new BsonDocument("$map", new BsonDocument
                     {
-                        { "from", "Roles" },
-                        { "localField", "roleId" },
-                        { "foreignField", "_id" },
-                        { "as", "role" }
-                    }),
-
-                    new BsonDocument("$unwind", "$role"),
-                    new BsonDocument("$match", new BsonDocument("role.status", Core.Blueprint.Mongo.StatusEnum.Active.ToString())),
-
-                    new BsonDocument("$addFields", new BsonDocument
-                    {
-                        { "role.permissions", new BsonDocument("$map", new BsonDocument
-                            {
-                                { "input", "$role.permissions" },
-                                { "as", "perm" },
-                                { "in", new BsonDocument("$toObjectId", "$$perm") }
-                            })
-                        },
-                        { "role.modules", new BsonDocument("$map", new BsonDocument
-                            {
-                                { "input", "$role.modules" },
-                                { "as", "mod" },
-                                { "in", new BsonDocument("$toObjectId", "$$mod") }
-                            })
-                        }
-                    }),
-
-                    new BsonDocument("$lookup", new BsonDocument
-                    {
-                        { "from", "Permissions" },
-                        { "localField", "role.permissions" },
-                        { "foreignField", "_id" },
-                        { "as", "permissions" }
-                    }),
-                    new BsonDocument("$lookup", new BsonDocument
-                    {
-                        { "from", "Modules" },
-                        { "localField", "role.modules" },
-                        { "foreignField", "_id" },
-                        { "as", "modules" }
-                    }),
-                    new BsonDocument("$project", new BsonDocument
-                    {
-                        { "_id", 1 },
-                        { "guid", 1 },
-                        { "email", 1 },
-                        { "name", 1 },
-                        { "middleName", 1 },
-                        { "lastName", 1 },
-                        { "displayName", 1 },
-                        { "roleId", 1 },
-                        { "companies", 1 },
-                        { "projects", 1 },
-                        { "lastLogIn", 1 },
-                        { "lastLogOut", 1 },
-                        { "createdBy", 1 },
-                        { "updatedBy", 1 },
-                        { "status", 1 },
-                        { "createdAt", 1 },
-                        { "updatedAt", 1 },
-                        { "role._id", 1 },
-                        { "role.name", 1 },
-                        { "role.description", 1 },
-                        { "role.applications", 1 },
-                        { "role.permissions", 1 },
-                        { "role.modules", 1 },
-                        { "role.status", 1 },
-                        { "role.createdAt", 1 },
-                        { "role.updatedAt", 1 },
-                        { "role.createdBy", 1 },
-                        { "role.updatedBy", 1 },
-                        { "permissions", 1 },
-                        { "modules", 1 }
+                        { "input", "$role.permissions" },
+                        { "as", "perm" },
+                        { "in", new BsonDocument("$toObjectId", "$$perm") }
                     })
-                };
+                },
+                { "role.modules", new BsonDocument("$map", new BsonDocument
+                    {
+                        { "input", "$role.modules" },
+                        { "as", "mod" },
+                        { "in", new BsonDocument("$toObjectId", "$$mod") }
+                    })
+                }
+            }),
+            new BsonDocument("$lookup", new BsonDocument
+            {
+                { "from", "Permissions" },
+                { "localField", "role.permissions" },
+                { "foreignField", "_id" },
+                { "as", "permissions" }
+            }),
+            new BsonDocument("$lookup", new BsonDocument
+            {
+                { "from", "Modules" },
+                { "localField", "role.modules" },
+                { "foreignField", "_id" },
+                { "as", "modules" }
+            }),
+            new BsonDocument("$project", new BsonDocument
+            {
+                { "_id", 1 },
+                { "guid", 1 },
+                { "email", 1 },
+                { "name", 1 },
+                { "middleName", 1 },
+                { "lastName", 1 },
+                { "displayName", 1 },
+                { "roleId", 1 },
+                { "companies", 1 },
+                { "projects", 1 },
+                { "lastLogIn", 1 },
+                { "lastLogOut", 1 },
+                { "createdBy", 1 },
+                { "updatedBy", 1 },
+                { "status", 1 },
+                { "createdAt", 1 },
+                { "updatedAt", 1 },
+                { "role._id", 1 },
+                { "role.name", 1 },
+                { "role.description", 1 },
+                { "role.applications", 1 },
+                { "role.permissions", 1 },
+                { "role.modules", 1 },
+                { "role.status", 1 },
+                { "role.createdAt", 1 },
+                { "role.updatedAt", 1 },
+                { "role.createdBy", 1 },
+                { "role.updatedBy", 1 },
+                { "tenant._id", 1 },
+                { "tenant.name", 1 },
+                { "tenant.taxIdentifier", 1 },
+                { "tenant.addressLine1", 1 },
+                { "tenant.addressLine2", 1 },
+                { "tenant.city", 1 },
+                { "tenant.state", 1 },
+                { "tenant.country", 1 },
+                { "tenant.postalCode", 1 },
+                { "tenant.contactEmail", 1 },
+                { "tenant.contactPhone", 1 },
+                { "tenant.website", 1 },
+                { "tenant.connectionString", 1 },
+                { "tenant.isolated", 1 },
+                { "tenant.status", 1 },
+                { "tenant.createdAt", 1 },
+                { "tenant.updatedAt", 1 },
+                { "tenant.createdBy", 1 },
+                { "tenant.updatedBy", 1 },
+                { "permissions", 1 },
+                { "modules", 1 }
+            })
+        };
 
                 var result = await repository.FindOnePipelineAsync<BsonDocument>(pipeline);
 
                 if (result is null) return null;
 
+                DateTime SafeToUtc(BsonValue value)
+                {
+                    if (value == null || value.IsBsonNull) return DateTime.MinValue;
+                    return value.IsBsonDateTime ? value.ToUniversalTime() : DateTime.MinValue;
+                }
+
                 var tokenAdapter = new TokenAdapter
                 {
                     User = new UserAdapter
                     {
-                        Id = result["_id"]?.ToString() ?? "",
-                        Guid = result.Contains("guid") && !result["guid"].IsBsonNull ? result["guid"].AsString : string.Empty,
+                        _Id = result["_id"]?.ToString() ?? "",
                         Email = result.Contains("email") && !result["email"].IsBsonNull ? result["email"].AsString : string.Empty,
                         Name = result.Contains("name") && !result["name"].IsBsonNull ? result["name"].AsString : string.Empty,
                         MiddleName = result.Contains("middleName") && !result["middleName"].IsBsonNull ? result["middleName"].AsString : string.Empty,
                         LastName = result.Contains("lastName") && !result["lastName"].IsBsonNull ? result["lastName"].AsString : string.Empty,
                         DisplayName = result.Contains("displayName") && !result["displayName"].IsBsonNull ? result["displayName"].AsString : string.Empty,
                         RoleId = result.Contains("roleId") && !result["roleId"].IsBsonNull ? result["roleId"].ToString() : string.Empty,
-                        LastLogIn = result.Contains("lastLogIn") && !result["lastLogIn"].IsBsonNull ? result["lastLogIn"].ToUniversalTime() : DateTime.MinValue,
-                        LastLogOut = result.Contains("lastLogOut") && !result["lastLogOut"].IsBsonNull ? result["lastLogOut"].ToUniversalTime() : DateTime.MinValue,
-                        CreatedAt = result.Contains("createdAt") && !result["createdAt"].IsBsonNull ? result["createdAt"].ToUniversalTime() : DateTime.MinValue,
+                        LastLogIn = SafeToUtc(result.Contains("lastLogIn") ? result["lastLogIn"] : null),
+                        LastLogOut = SafeToUtc(result.Contains("lastLogOut") ? result["lastLogOut"] : null),
+                        CreatedAt = SafeToUtc(result.Contains("createdAt") ? result["createdAt"] : null),
+                        UpdatedAt = SafeToUtc(result.Contains("updatedAt") ? result["updatedAt"] : null),
                         CreatedBy = result.Contains("createdBy") && !result["createdBy"].IsBsonNull ? result["createdBy"].AsString : string.Empty,
-                        UpdatedAt = result.Contains("updatedAt") && !result["updatedAt"].IsBsonNull ? result["updatedAt"].ToUniversalTime() : DateTime.MinValue,
                         UpdatedBy = result.Contains("updatedBy") && !result["updatedBy"].IsBsonNull ? result["updatedBy"].AsString : string.Empty,
                         Status = result.Contains("status") && !result["status"].IsBsonNull
                             ? (Core.Blueprint.Mongo.StatusEnum)Enum.Parse(typeof(Core.Blueprint.Mongo.StatusEnum), result["status"].AsString)
@@ -376,39 +404,100 @@ namespace Core.Thalos.Provider.Providers.Onboarding
                              !result["role"]["status"].IsBsonNull
                             ? (Core.Blueprint.Mongo.StatusEnum)Enum.Parse(typeof(Core.Blueprint.Mongo.StatusEnum), result["role"]["status"].AsString)
                             : Core.Blueprint.Mongo.StatusEnum.Inactive,
-                        CreatedAt = result.Contains("role") && result["role"].IsBsonDocument &&
-                            result["role"].AsBsonDocument.Contains("createdAt") &&
-                            !result["role"]["createdAt"].IsBsonNull
-                            ? result["role"]["createdAt"].ToUniversalTime()
-                            : DateTime.MinValue,
-                        UpdatedAt = result.Contains("role") && result["role"].IsBsonDocument &&
-                            result["role"].AsBsonDocument.Contains("updatedAt") &&
-                            !result["role"]["updatedAt"].IsBsonNull
-                            ? result["role"]["updatedAt"].ToUniversalTime()
-                            : DateTime.MinValue,
+                        CreatedAt = SafeToUtc(result.Contains("role") && result["role"].IsBsonDocument && result["role"].AsBsonDocument.Contains("createdAt")
+                            ? result["role"]["createdAt"]
+                            : null),
+                        UpdatedAt = SafeToUtc(result.Contains("role") && result["role"].IsBsonDocument && result["role"].AsBsonDocument.Contains("updatedAt")
+                            ? result["role"]["updatedAt"]
+                            : null),
                         CreatedBy = result.Contains("role") && result["role"].IsBsonDocument &&
-                            result["role"].AsBsonDocument.Contains("createdBy") &&
-                            !result["role"]["createdBy"].IsBsonNull
+                            result["role"].AsBsonDocument.Contains("createdBy") && !result["role"]["createdBy"].IsBsonNull
                             ? result["role"]["createdBy"].AsString
                             : string.Empty,
                         UpdatedBy = result.Contains("role") && result["role"].IsBsonDocument &&
-                            result["role"].AsBsonDocument.Contains("updatedBy") &&
-                            !result["role"]["updatedBy"].IsBsonNull
+                            result["role"].AsBsonDocument.Contains("updatedBy") && !result["role"]["updatedBy"].IsBsonNull
                             ? result["role"]["updatedBy"].AsString
                             : string.Empty
                     },
+                    Tenant = result.Contains("tenant") && result["tenant"].IsBsonDocument
+                    ? new TenantAdapter
+                    {
+                        Id = result.Contains("tenant") && result["tenant"].IsBsonDocument && result["tenant"].AsBsonDocument.Contains("_id")
+                            ? result["tenant"]["_id"]?.ToString() ?? ""
+                            : string.Empty,
+                        Name = result["tenant"].AsBsonDocument.Contains("name") && !result["tenant"]["name"].IsBsonNull
+                            ? result["tenant"]["name"].AsString
+                            : string.Empty,
+                        TaxIdentifier = result["tenant"].AsBsonDocument.Contains("taxIdentifier") && !result["tenant"]["taxIdentifier"].IsBsonNull
+                            ? result["tenant"]["taxIdentifier"].AsString
+                            : string.Empty,
+                        AddressLine1 = result["tenant"].AsBsonDocument.Contains("addressLine1") && !result["tenant"]["addressLine1"].IsBsonNull
+                            ? result["tenant"]["addressLine1"].AsString
+                            : string.Empty,
+                        AddressLine2 = result["tenant"].AsBsonDocument.Contains("addressLine2") && !result["tenant"]["addressLine2"].IsBsonNull
+                            ? result["tenant"]["addressLine2"].AsString
+                            : null,
+                        City = result["tenant"].AsBsonDocument.Contains("city") && !result["tenant"]["city"].IsBsonNull
+                            ? result["tenant"]["city"].AsString
+                            : string.Empty,
+                        State = result["tenant"].AsBsonDocument.Contains("state") && !result["tenant"]["state"].IsBsonNull
+                            ? result["tenant"]["state"].AsString
+                            : string.Empty,
+                        Country = result["tenant"].AsBsonDocument.Contains("country") && !result["tenant"]["country"].IsBsonNull
+                            ? result["tenant"]["country"].AsString
+                            : string.Empty,
+                        PostalCode = result["tenant"].AsBsonDocument.Contains("postalCode") && !result["tenant"]["postalCode"].IsBsonNull
+                            ? result["tenant"]["postalCode"].AsString
+                            : string.Empty,
+                        ContactEmail = result["tenant"].AsBsonDocument.Contains("contactEmail") && !result["tenant"]["contactEmail"].IsBsonNull
+                            ? result["tenant"]["contactEmail"].AsString
+                            : string.Empty,
+                        ContactPhone = result["tenant"].AsBsonDocument.Contains("contactPhone") && !result["tenant"]["contactPhone"].IsBsonNull
+                            ? result["tenant"]["contactPhone"].AsString
+                            : string.Empty,
+                        Website = result["tenant"].AsBsonDocument.Contains("website") && !result["tenant"]["website"].IsBsonNull
+                            ? result["tenant"]["website"].AsString
+                            : null,
+                        ConnectionString = result["tenant"].AsBsonDocument.Contains("connectionString") && !result["tenant"]["connectionString"].IsBsonNull
+                            ? result["tenant"]["connectionString"].AsString
+                            : null,
+                        Isolated = result["tenant"].AsBsonDocument.Contains("isolated") && !result["tenant"]["isolated"].IsBsonNull
+                            ? result["tenant"]["isolated"].ToBoolean()
+                            : false,
+                        CreatedAt = SafeToUtc(result.Contains("tenant") && result["tenant"].IsBsonDocument && result["tenant"].AsBsonDocument.Contains("createdAt")
+                            ? result["tenant"]["createdAt"]
+                            : null),
+                        UpdatedAt = SafeToUtc(result.Contains("tenant") && result["tenant"].IsBsonDocument && result["tenant"].AsBsonDocument.Contains("updatedAt")
+                            ? result["tenant"]["updatedAt"]
+                            : null),
+                        CreatedBy = result["tenant"].AsBsonDocument.Contains("createdBy") && !result["tenant"]["createdBy"].IsBsonNull
+                            ? result["tenant"]["createdBy"].AsString
+                            : string.Empty,
+                        UpdatedBy = result["tenant"].AsBsonDocument.Contains("updatedBy") && !result["tenant"]["updatedBy"].IsBsonNull
+                            ? result["tenant"]["updatedBy"].AsString
+                            : string.Empty,
+                        Status = result["tenant"].AsBsonDocument.Contains("status") && !result["tenant"]["status"].IsBsonNull
+                            ? (Core.Blueprint.Mongo.StatusEnum)Enum.Parse(typeof(Core.Blueprint.Mongo.StatusEnum), result["tenant"]["status"].AsString)
+                            : Core.Blueprint.Mongo.StatusEnum.Active
+                    }
+                    : null,
                     Permissions = result.Contains("permissions") && result["permissions"].IsBsonArray
                         ? result["permissions"].AsBsonArray
                             .Where(p => p != null && p.IsBsonDocument)
                             .Select(p => BsonSerializer.Deserialize<PermissionAdapter>(p.AsBsonDocument))
                             .Where(p => p.Status == Core.Blueprint.Mongo.StatusEnum.Active)
                             .ToList()
-                        : new List<PermissionAdapter>()
+                        : new List<PermissionAdapter>(),
+                    Modules = result.Contains("modules") && result["modules"].IsBsonArray
+                    ? result["modules"].AsBsonArray
+                        .Where(p => p != null && p.IsBsonDocument)
+                        .Select(p => BsonSerializer.Deserialize<ModuleAdapter>(p.AsBsonDocument))
+                        .Where(p => p.Status == Core.Blueprint.Mongo.StatusEnum.Active)
+                        .ToList()
+                    : new List<ModuleAdapter>()
                 };
 
-
                 return tokenAdapter;
-
             }
             catch (Exception ex)
             {
@@ -416,6 +505,7 @@ namespace Core.Thalos.Provider.Providers.Onboarding
             }
         }
 
+
         /// <summary>
         /// Deletes an User by _id.
         /// </summary>

Dockerfile

@@ -0,0 +1,40 @@
+# ============ Build ============
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+WORKDIR /src
+
+# Copia opcional del nuget.config si existe en el root
+COPY nuget.config* ./
+
+# Copiamos csprojs primero para aprovechar caché de restore
+COPY Core.Thalos.Domain/Core.Thalos.Domain.csproj Core.Thalos.Domain/
+COPY Core.Thalos.Provider/Core.Thalos.Provider.csproj Core.Thalos.Provider/
+COPY Core.Thalos.Infraestructure/Core.Thalos.Infrastructure.csproj Core.Thalos.Infraestructure/
+COPY Core.Thalos.DAL.API/Core.Thalos.DAL.API.csproj Core.Thalos.DAL.API/
+
+RUN dotnet restore Core.Thalos.DAL.API/Core.Thalos.DAL.API.csproj
+
+# Copiamos el resto y compilamos
+COPY . .
+RUN dotnet build Core.Thalos.DAL.API/Core.Thalos.DAL.API.csproj -c Release -o /app/build
+
+# ============ Publish ============
+FROM build AS publish
+RUN dotnet publish Core.Thalos.DAL.API/Core.Thalos.DAL.API.csproj -c Release -o /app/publish \
+    --no-restore
+
+# ============ Runtime ============
+FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
+# (Opcional) instalar curl para 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
+# Usa env vars y/o UserSecrets; no guardes tokens en la imagen.  :contentReference[oaicite:4]{index=4}
+
+COPY --from=publish /app/publish ./
+ENTRYPOINT ["dotnet", "Core.Thalos.DAL.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>