@kumori/aurora-backend-handler 1.0.49 → 1.0.51

package/api/user-api-service.ts

@@ -4,23 +4,7 @@ import {
   makeGlobalWebSocketRequest,
 } from "../websocket-manager.ts";
 import { environment } from "../environment.ts";
-import {
-  Account,
-  Container,
-  Environment,
-  Instance,
-  MarketplaceItem,
-  Notification,
-  Organization,
-  Platform,
-  Registry,
-  Resource,
-  Service,
-  Tenant,
-  User,
-  UserData,
-} from "@kumori/aurora-interfaces";
-import { Revision } from "@kumori/aurora-interfaces/interfaces/revision-interface.ts";
+import { Account, Container, Environment, Instance, MarketplaceItem, Notification, Organization, Platform, Registry, Resource, Service, Tenant, User, UserData } from "@kumori/aurora-interfaces";
 
 type Security = string;
 
@@ -46,7 +30,7 @@ export const isUserLogged = async (security: Security) => {
       {},
       30000,
       "GET",
-      "USER_INFO",
+      "USER_INFO"
     );
     userLogged = true;
   } catch (error) {
@@ -70,9 +54,9 @@ export const createUser = async (user: User) => {
     {
       method: "POST",
       body: JSON.stringify(userBody),
-    },
+    }
   );
-  if (response.ok) {
+  if(response.ok){
     eventHelper.user.publish.created(user);
   }
   if (!response.ok) {
@@ -80,11 +64,10 @@ export const createUser = async (user: User) => {
     user.name = error.code;
     eventHelper.user.publish.creationError(user);
     throw new Error(
-      `HTTP Error ${response.status}: ${error.message || "Unknown error"}`,
+      `HTTP Error ${response.status}: ${error.message || "Unknown error"}`
     );
   }
 };
-
 export const loadUserData = async () => {
   try {
     const response = await makeGlobalWebSocketRequest("user:user_info", {});
@@ -96,7 +79,13 @@ export const loadUserData = async () => {
       id: userResponse.userRecord.id.name,
       name: userResponse.userRecord.spec.userinfo.name,
       surname: userResponse.userRecord.spec.userinfo.surname,
-      provider: [{ name: provider, email: email || "", password: "" }],
+      provider: [
+        {
+          name: provider,
+          email: email || "",
+          password: "",
+        },
+      ],
       notificationsEnabled: "true",
       organizations: [],
       clusterTokens: [],
@@ -113,12 +102,11 @@ export const loadUserData = async () => {
         { strict: true },
         30000,
         "GET",
-        "ALL_TENANTS",
+        "ALL_TENANTS"
       );
       const tenantsData = tenantsResponse.data;
       const userTenants: Tenant[] = [];
       const userOrganizations: Organization[] = [];
-
       for (const [_, value] of Object.entries(tenantsData)) {
         const parts = (value as any).toString().split(",");
         userTenants.push({
@@ -133,18 +121,26 @@ export const loadUserData = async () => {
           role: parts[1],
           status: "healthy",
           users: [],
-          registry: [{ name: "", public: false, credentials: "", domain: "" }],
+          registry: [
+            {
+              name: "",
+              public: false,
+              credentials: "",
+              domain: "",
+            },
+          ],
         });
       }
-
       for (const tenant of userTenants) {
         try {
           const tenantResponse = await makeGlobalWebSocketRequest(
             "tenant:tenant_info",
-            { tenant: tenant.name },
+            {
+              tenant: tenant.name,
+            },
             30000,
             "GET",
-            tenant.name,
+            tenant.name
           );
           const tenantData = tenantResponse.data;
           const registries = tenantData?.registries?.registries;
@@ -161,18 +157,22 @@ export const loadUserData = async () => {
               extra: {},
               password: "",
             };
-            if (tenantOptions?.endpoint)
+            if (tenantOptions?.endpoint) {
               registry.domain = tenantOptions.endpoint;
-            if (tenantOptions?.credentials)
+            }
+            if (tenantOptions?.credentials) {
               registry.credentials = tenantOptions.credentials;
-            if (typeof tenantOptions?.public === "boolean")
+            }
+            if (typeof tenantOptions?.public === "boolean") {
               registry.public = tenantOptions.public;
-            if (tenantData?.domains && Object.keys(tenantData.domains)[0])
+            }
+            if (tenantData?.domains && Object.keys(tenantData.domains)[0]) {
               registry.name = Object.keys(tenantData.domains)[0];
+            }
             tenant.registry.push(registry);
           } else {
             console.warn(
-              `No se encontró información de registry para el tenant ${tenant.name}`,
+              `No se encontró información de registry para el tenant ${tenant.name}`
             );
           }
 
@@ -193,7 +193,10 @@ export const loadUserData = async () => {
                     name: env.id.name,
                     account: `${account.account.id.parent.name}-${account.account.id.name}`,
                     tenant: account.account.id.parent.name.split("tenant/")[1],
-                    logo: `${env.logo || "https://kumori.systems/wp-content/uploads/2023/07/cropped-favicon-kumori.png"}`,
+                    logo: `${
+                      env.logo ||
+                      "https://kumori.systems/wp-content/uploads/2023/07/cropped-favicon-kumori.png"
+                    }`,
                     services: [],
                     domains: [],
                     status: {
@@ -252,7 +255,7 @@ export const loadUserData = async () => {
               }
 
               const cloudProviderInfo = extractCloudProviderInfo(
-                account.account.spec,
+                account.account.spec
               );
               const newAccount: Account = {
                 id: `${account.account.id.parent.name}-${account.account.id.name}`,
@@ -262,7 +265,10 @@ export const loadUserData = async () => {
                   name: account.account.spec.api,
                   ...cloudProviderInfo,
                 },
-                logo: `${account.account.spec.api || "https://kumori.systems/wp-content/uploads/2023/07/cropped-favicon-kumori.png"}`,
+                logo: `${
+                  account.account.spec.api ||
+                  "https://kumori.systems/wp-content/uploads/2023/07/cropped-favicon-kumori.png"
+                }`,
                 environments: environmentsIds,
                 services: [],
                 domains: [],
@@ -271,9 +277,9 @@ export const loadUserData = async () => {
                     "InvalidCredentials"
                     ? "InvalidCredentials"
                     : !account.account.status.validCredentials?.status &&
-                        account.account.id !== "kumori"
-                      ? "pending"
-                      : "healthy"
+                      account.account.id !== "kumori"
+                    ? "pending"
+                    : "healthy"
                   : "",
                 usage: {
                   current: {
@@ -329,7 +335,6 @@ export const loadUserData = async () => {
 
               tenantAccounts.push(newAccount);
             }
-
             const kinds = [
               "ca",
               "certificate",
@@ -338,14 +343,18 @@ export const loadUserData = async () => {
               "secret",
               "volume",
             ];
+
             for (const kind of kinds) {
               try {
                 const resourcesResponse = await makeGlobalWebSocketRequest(
                   "resource:list_resources",
-                  { tenant: tenant.name, kind },
+                  {
+                    tenant: tenant.name,
+                    kind: kind,
+                  },
                   30000,
                   "GET",
-                  "ALL_RESOURCES",
+                  "ALL_RESOURCES"
                 );
                 const resourcesData = resourcesResponse.data;
                 if (
@@ -353,7 +362,7 @@ export const loadUserData = async () => {
                   !Array.isArray(resourcesData[kind])
                 ) {
                   console.warn(
-                    `No se encontraron recursos de tipo ${kind} o no es un array`,
+                    `No se encontraron recursos de tipo ${kind} o no es un array`
                   );
                   continue;
                 }
@@ -363,21 +372,28 @@ export const loadUserData = async () => {
                     const resourceName = resource.id.name;
                     const resourceResponse = await makeGlobalWebSocketRequest(
                       "resource:resource_info",
-                      { tenant: tenant.name, kind, resource: resourceName },
+                      {
+                        tenant: tenant.name,
+                        kind: kind,
+                        resource: resourceName,
+                      },
                       30000,
                       "GET",
-                      resourceName,
+                      resourceName
                     );
                     const resourceDataJson = resourceResponse.data;
                     const resourceType = resourceDataJson.id.kind;
                     let resourceStatus: "used" | "available" | "error" =
                       "available";
 
-                    if (resourceDataJson.status?.requested) {
-                      if (
-                        Object.keys(resourceDataJson.status.requested).length >
-                        0
-                      ) {
+                    if (
+                      resourceDataJson.status &&
+                      resourceDataJson.status.requested
+                    ) {
+                      const requestedKeys = Object.keys(
+                        resourceDataJson.status.requested
+                      );
+                      if (requestedKeys.length > 0) {
                         resourceStatus = "used";
                       }
                     }
@@ -401,7 +417,10 @@ export const loadUserData = async () => {
                         status: resourceStatus,
                       } as Resource);
                     } else if (
-                      ["domain", "port", "ca", "secret"].includes(resourceType)
+                      resourceType === "domain" ||
+                      resourceType === "port" ||
+                      resourceType === "ca" ||
+                      resourceType === "secret"
                     ) {
                       tenant.resources.push({
                         type: kind,
@@ -413,25 +432,26 @@ export const loadUserData = async () => {
                   } catch (resourceError) {
                     console.error(
                       `Error procesando recurso individual de tipo ${kind}:`,
-                      resourceError,
+                      resourceError
                     );
                   }
                 }
               } catch (error) {
                 console.error(
                   `Error procesando recursos de tipo ${kind}:`,
-                  error,
+                  error
                 );
               }
             }
           }
-
           const servicesResponse = await makeGlobalWebSocketRequest(
             "service:list_services",
-            { tenant: tenant.name },
+            {
+              tenant: tenant.name,
+            },
             30000,
             "GET",
-            "ALL_SERVICES",
+            "ALL_SERVICES"
           );
           const servicesData = servicesResponse.data;
           const serviceEntries = Object.entries(servicesData);
@@ -444,7 +464,6 @@ export const loadUserData = async () => {
                 timestamp: "",
                 args: [],
               };
-
               const serviceResponse = await makeGlobalWebSocketRequest(
                 "service:describe_service",
                 {
@@ -454,11 +473,10 @@ export const loadUserData = async () => {
                 },
                 30000,
                 "GET",
-                (serviceValue as any).name,
+                (serviceValue as any).name
               );
               const serviceData = serviceResponse.data;
-
-              let revisionData: any;
+              let revisionData;
               try {
                 const revisionResponse = await makeGlobalWebSocketRequest(
                   "revision:revision_info",
@@ -469,7 +487,7 @@ export const loadUserData = async () => {
                   },
                   30000,
                   "GET_REVISION",
-                  (serviceValue as any).name,
+                  (serviceValue as any).name
                 );
                 revisionData = revisionResponse.data;
               } catch (revisionError) {
@@ -478,76 +496,48 @@ export const loadUserData = async () => {
                   message: "",
                   timestamp: "",
                   args: [],
-                };
+                },
                 console.warn(
-                  `No se pudo obtener la revisión para el servicio ${(serviceValue as any).name}:`,
-                  revisionError,
+                  `No se pudo obtener la revisión para el servicio ${
+                    (serviceValue as any).name
+                  }:`,
+                  revisionError
                 );
                 continue;
               }
 
               const serviceName = revisionData.solution.top;
-
-              // revisionData.revision is a string ID, revisionData.intensives has the resource limits
-              const revisionId: string = revisionData.revision;
-              const intensives = revisionData.intensives ?? {};
-
-              let rawHistoryData: any[] = [];
+              let revisionsData;
               try {
                 const revisionsResponse = await makeGlobalWebSocketRequest(
                   "service:report_history_service",
-                  { tenant: tenant.name, service: serviceName },
+                  {
+                    tenant: tenant.name,
+                    service: serviceName,
+                  },
                   30000,
                   "GET_HISTORY",
-                  serviceName,
+                  serviceName
                 );
-                rawHistoryData = revisionsResponse.data ?? [];
+                revisionsData = revisionsResponse.data;
               } catch (historyError) {
                 serviceStatus = {
                   code: "PENDING",
                   message: "",
                   timestamp: "",
                   args: [],
-                };
+                },
                 console.warn(
                   `No se pudo obtener el historial para el servicio ${serviceName}:`,
-                  historyError,
+                  historyError
                 );
                 continue;
               }
 
-              const revisions: Revision[] = (rawHistoryData as any[]).map(
-                (entry: any) => ({
-                  id: String(entry.revision ?? entry.id ?? ""),
-                  schema: entry.spec ?? {},
-                  usage: {
-                    current: {
-                      cpu: 0,
-                      memory: 0,
-                      storage: 0,
-                      volatileStorage: 0,
-                      nonReplicatedStorage: 0,
-                      persistentStorage: 0,
-                    },
-                    limit: {
-                      cpu: { max: 0, min: 0 },
-                      memory: { max: 0, min: 0 },
-                      storage: { max: 0, min: 0 },
-                      volatileStorage: { max: 0, min: 0 },
-                      nonReplicatedStorage: { max: 0, min: 0 },
-                      persistentStorage: { max: 0, min: 0 },
-                    },
-                    cost: 0,
-                  },
-                  status: entry.status ?? {
-                    code: "",
-                    message: "",
-                    timestamp: "",
-                    args: [],
-                  },
-                  createdAt: entry.createdAt ?? "",
-                }),
-              );
+              const revisions: string[] = [];
+              for (const revision of revisionsData) {
+                revisions.push(revision.revision);
+              }
 
               const serviceRoles: { name: string; instances: Instance[] }[] =
                 [];
@@ -568,13 +558,13 @@ export const loadUserData = async () => {
                     },
                     30000,
                     "GET_ROLE",
-                    `${serviceName}_${roleName}`,
+                    serviceName + "_" + roleName
                   );
                   const instancesData = instancesResponse.data;
                   const instances: Instance[] = [];
 
                   for (const [instanceName, instanceValue] of Object.entries(
-                    instancesData.instances,
+                    instancesData.instances
                   )) {
                     const containers: Container[] = [];
                     for (const [
@@ -630,15 +620,27 @@ export const loadUserData = async () => {
                                 .artifact.description.code[roleName]?.size
                                 ?.memory?.size / 1000,
                           },
-                          storage: { max: 0, min: 0 },
-                          volatileStorage: { max: 0, min: 0 },
-                          nonReplicatedStorage: { max: 0, min: 0 },
-                          persistentStorage: { max: 0, min: 0 },
+                          storage: {
+                            max: 0,
+                            min: 0,
+                          },
+                          volatileStorage: {
+                            max: 0,
+                            min: 0,
+                          },
+                          nonReplicatedStorage: {
+                            max: 0,
+                            min: 0,
+                          },
+                          persistentStorage: {
+                            max: 0,
+                            min: 0,
+                          },
                         },
                         cost: 0,
                       },
                       logs: [],
-                      containers,
+                      containers: containers,
                     });
                   }
                   serviceRoles.push({ name: roleName, instances });
@@ -648,10 +650,10 @@ export const loadUserData = async () => {
                     message: "",
                     timestamp: "",
                     args: [],
-                  };
+                  },
                   console.warn(
                     `Error obteniendo instancias para el rol ${roleName}:`,
-                    instanceError,
+                    instanceError
                   );
                 }
               }
@@ -674,7 +676,7 @@ export const loadUserData = async () => {
                 name: (serviceValue as any).name,
                 logo: "",
                 description: "",
-                revisions,
+                revisions: revisions,
                 status: serviceStatus,
                 role: serviceRoles,
                 links: [],
@@ -691,53 +693,57 @@ export const loadUserData = async () => {
                   },
                   limit: {
                     cpu: {
-                      max: intensives.vcpu / 1000,
-                      min: intensives.vcpu / 1000,
+                      max: revisionData.revision.spec.intensives.vcpu / 1000,
+                      min: revisionData.revision.spec.intensives.vcpu / 1000,
                     },
                     memory: {
-                      max: intensives.ram / 1000,
-                      min: intensives.ram / 1000,
+                      max: revisionData.revision.spec.intensives.ram / 1000,
+                      min: revisionData.revision.spec.intensives.ram / 1000,
                     },
                     storage: {
-                      max: intensives.shared_disk,
-                      min: intensives.shared_disk,
+                      max: revisionData.revision.spec.intensives.shared_disk,
+                      min: revisionData.revision.spec.intensives.shared_disk,
                     },
                     volatileStorage: {
-                      max: intensives.volatile_disk,
-                      min: intensives.volatile_disk,
+                      max: revisionData.revision.spec.intensives.volatile_disk,
+                      min: revisionData.revision.spec.intensives.volatile_disk,
                     },
                     nonReplicatedStorage: {
-                      max: intensives.nrpersistent_disk,
-                      min: intensives.nrpersistent_disk,
+                      max: revisionData.revision.spec.intensives
+                        .nrpersistent_disk,
+                      min: revisionData.revision.spec.intensives
+                        .nrpersistent_disk,
                     },
                     persistentStorage: {
-                      max: intensives.persistent_disk,
-                      min: intensives.persistent_disk,
+                      max: revisionData.revision.spec.intensives
+                        .persistent_disk,
+                      min: revisionData.revision.spec.intensives
+                        .persistent_disk,
                     },
                   },
                   cost: 0,
                 },
                 minReplicas: 0,
                 maxReplicas: 0,
-                lastDeployed: `${revisionData.tstamp ?? ""}`,
+                lastDeployed: `${revisionData.revision.spec.tstamp}`,
                 project: "",
                 registry:
                   roles[firstRoleName].artifact.description.code[containerName]
-                    ?.image?.hub?.name ?? "",
+                    .image.hub.name,
                 imageName:
                   roles[firstRoleName].artifact.description.code[containerName]
-                    ?.image?.tag ?? "",
+                    .image.tag,
                 entrypoint:
                   roles[firstRoleName].artifact.description.code[containerName]
-                    ?.entrypoint ?? "",
-                cmd:
-                  roles[firstRoleName].artifact.description.code[containerName]
-                    ?.cmd ?? "",
+                    .entrypoint,
+                cmd: roles[firstRoleName].artifact.description.code[
+                  containerName
+                ].cmd,
                 serverChannels: [],
                 clientChannels: [],
                 duplexChannels: [],
                 cloudProvider: "",
-                currentRevision: revisionId,
+                currentRevision: revisionData.revision.id.name,
               };
 
               userServices.push(newService);
@@ -745,25 +751,27 @@ export const loadUserData = async () => {
               console.error("Error al obtener los datos del servicio:", error);
             }
           }
-
           for (const account of tenantAccounts) {
             account.services = userServices
               .filter((service) => service.account === account.name)
               .map((service) => service.name);
           }
-          for (const env of tenantEnvironments) {
-            env.services = userServices
-              .filter((service) => service.environment === env.name)
+          for (const environment of tenantEnvironments) {
+            environment.services = userServices
+              .filter((service) => service.environment === environment.name)
               .map((service) => service.name);
           }
 
           try {
             const marketplaceResponse = await makeGlobalWebSocketRequest(
               "marketplace:search_marketplace",
-              { tenant: tenant.name, name: "" },
+              {
+                tenant: tenant.name,
+                name: "",
+              },
               30000,
               "GET",
-              "MARKETPLACE",
+              "MARKETPLACE"
             );
             const marketplaceData = marketplaceResponse.data;
             const tenantItems: MarketplaceItem[] = [];
@@ -771,31 +779,36 @@ export const loadUserData = async () => {
               let cpu = 0;
               let memory = 0;
               (value as any).tags.forEach((tag: string) => {
-                if (tag.includes("cpu"))
+                if (tag.includes("cpu")) {
                   cpu = Number(tag.split("::")[1].split("vCPU")[0]);
-                else if (tag.includes("memory"))
+                } else if (tag.includes("memory")) {
                   memory = Number(tag.split("::")[1].split("MB")[0]);
+                }
               });
-              tenantItems.push({
+              const item: MarketplaceItem = {
                 tenant: tenant.toString(),
                 name: (value as any).name,
                 logo: (value as any).icon,
                 description: (value as any).name,
                 version: (value as any).version,
-                requirements: { cpu, memory },
+                requirements: {
+                  cpu: cpu,
+                  memory: memory,
+                },
                 status: "",
                 instances: [],
                 links: [],
                 resources: [],
                 domain: (value as any).domain,
                 type: (value as any).artifactTypes[0],
-              });
+              };
+              tenantItems.push(item);
             });
             tenant.marketplaceItems = tenantItems;
           } catch (marketplaceError) {
             console.error(
               `Error obteniendo marketplace para tenant ${tenant.name}:`,
-              marketplaceError,
+              marketplaceError
             );
             tenant.marketplaceItems = [];
           }
@@ -811,14 +824,17 @@ export const loadUserData = async () => {
       try {
         const organizationsResponse = await makeGlobalWebSocketRequest(
           "organization:list_organizations",
-          { strict: true },
+          {
+            strict: true,
+          },
           30000,
           "GET",
-          "ORGANIZATIONS",
+          "ORGANIZATIONS"
         );
         const organizationsData = organizationsResponse.data;
-        for (const [, organizationValue] of Object.entries(organizationsData)) {
-          userOrganizations.push({
+        const organizationsEntries = Object.entries(organizationsData);
+        for (const [, organizationValue] of organizationsEntries) {
+          const newOrg = {
             id: (organizationValue as any).spec.companyName,
             name: (organizationValue as any).id.name,
             usersIds: Object.keys((organizationValue as any).spec.users),
@@ -835,7 +851,8 @@ export const loadUserData = async () => {
               zipcode: (organizationValue as any).spec.billing.zip,
             },
             invoices: [],
-          });
+          };
+          userOrganizations.push(newOrg);
         }
       } catch (organizationError) {
         console.error("Error obteniendo organizaciones:", organizationError);
@@ -847,8 +864,9 @@ export const loadUserData = async () => {
           {},
           30000,
           "GET",
-          "PLATFORM",
+          "PLATFORM"
         );
+
         const platformData: Platform = {
           instanceName: String(platformResponse.instanceName),
           platformVersion: String(platformResponse.platformVersion),
@@ -867,72 +885,72 @@ export const loadUserData = async () => {
           freemiumAdvancedLimits: {
             vcpu: {
               lowmark: Number(
-                platformResponse.freemiumAdvancedLimits.vcpu.lowmark,
+                platformResponse.freemiumAdvancedLimits.vcpu.lowmark
               ),
               highmark: Number(
-                platformResponse.freemiumAdvancedLimits.vcpu.highmark,
+                platformResponse.freemiumAdvancedLimits.vcpu.highmark
               ),
               unit: String(platformResponse.freemiumAdvancedLimits.vcpu.unit),
             },
             memory: {
               lowmark: Number(
-                platformResponse.freemiumAdvancedLimits.memory.lowmark,
+                platformResponse.freemiumAdvancedLimits.memory.lowmark
               ),
               highmark: Number(
-                platformResponse.freemiumAdvancedLimits.memory.highmark,
+                platformResponse.freemiumAdvancedLimits.memory.highmark
               ),
               unit: String(platformResponse.freemiumAdvancedLimits.memory.unit),
             },
             vstorage: {
               lowmark: Number(
-                platformResponse.freemiumAdvancedLimits.vstorage.lowmark,
+                platformResponse.freemiumAdvancedLimits.vstorage.lowmark
               ),
               highmark: Number(
-                platformResponse.freemiumAdvancedLimits.vstorage.highmark,
+                platformResponse.freemiumAdvancedLimits.vstorage.highmark
               ),
               unit: String(
-                platformResponse.freemiumAdvancedLimits.vstorage.unit,
+                platformResponse.freemiumAdvancedLimits.vstorage.unit
               ),
             },
             nrstorage: {
               lowmark: Number(
-                platformResponse.freemiumAdvancedLimits.nrstorage.lowmark,
+                platformResponse.freemiumAdvancedLimits.nrstorage.lowmark
               ),
               highmark: Number(
-                platformResponse.freemiumAdvancedLimits.nrstorage.highmark,
+                platformResponse.freemiumAdvancedLimits.nrstorage.highmark
               ),
               unit: String(
-                platformResponse.freemiumAdvancedLimits.nrstorage.unit,
+                platformResponse.freemiumAdvancedLimits.nrstorage.unit
               ),
             },
             rstorage: {
               lowmark: Number(
-                platformResponse.freemiumAdvancedLimits.rstorage.lowmark,
+                platformResponse.freemiumAdvancedLimits.rstorage.lowmark
               ),
               highmark: Number(
-                platformResponse.freemiumAdvancedLimits.rstorage.highmark,
+                platformResponse.freemiumAdvancedLimits.rstorage.highmark
               ),
               unit: String(
-                platformResponse.freemiumAdvancedLimits.rstorage.unit,
+                platformResponse.freemiumAdvancedLimits.rstorage.unit
               ),
             },
             storage: {
               lowmark: Number(
-                platformResponse.freemiumAdvancedLimits.storage.lowmark,
+                platformResponse.freemiumAdvancedLimits.storage.lowmark
               ),
               highmark: Number(
-                platformResponse.freemiumAdvancedLimits.storage.highmark,
+                platformResponse.freemiumAdvancedLimits.storage.highmark
               ),
               unit: String(
-                platformResponse.freemiumAdvancedLimits.storage.unit,
+                platformResponse.freemiumAdvancedLimits.storage.unit
               ),
             },
             cost: {
               lowmark: Number(
-                platformResponse.freemiumAdvancedLimits.cost.lowmark,
+                platformResponse.freemiumAdvancedLimits.cost.lowmark
               ),
               highmark: Number(
-                platformResponse.freemiumAdvancedLimits.cost.highmark,
+                platformResponse.freemiumAdvancedLimits.cost.highmark
               ),
               unit: String(platformResponse.freemiumAdvancedLimits.cost.unit),
             },
@@ -951,30 +969,30 @@ export const loadUserData = async () => {
             vstorage: {
               lowmark: Number(platformResponse.freemiumLimits.vstorage.lowmark),
               highmark: Number(
-                platformResponse.freemiumLimits.vstorage.highmark,
+                platformResponse.freemiumLimits.vstorage.highmark
               ),
               unit: String(platformResponse.freemiumLimits.vstorage.unit),
             },
             nrstorage: {
               lowmark: Number(
-                platformResponse.freemiumLimits.nrstorage.lowmark,
+                platformResponse.freemiumLimits.nrstorage.lowmark
               ),
               highmark: Number(
-                platformResponse.freemiumLimits.nrstorage.highmark,
+                platformResponse.freemiumLimits.nrstorage.highmark
               ),
               unit: String(platformResponse.freemiumLimits.nrstorage.unit),
             },
             rstorage: {
               lowmark: Number(platformResponse.freemiumLimits.rstorage.lowmark),
               highmark: Number(
-                platformResponse.freemiumLimits.rstorage.highmark,
+                platformResponse.freemiumLimits.rstorage.highmark
               ),
               unit: String(platformResponse.freemiumLimits.rstorage.unit),
             },
             storage: {
               lowmark: Number(platformResponse.freemiumLimits.storage.lowmark),
               highmark: Number(
-                platformResponse.freemiumLimits.storage.highmark,
+                platformResponse.freemiumLimits.storage.highmark
               ),
               unit: String(platformResponse.freemiumLimits.storage.unit),
             },
@@ -990,8 +1008,9 @@ export const loadUserData = async () => {
         };
         if (eventHelper.user) {
           eventHelper.user.publish.loaded(
-            new User(userData, userTenants, userOrganizations, platformData),
+            new User(userData, userTenants, userOrganizations, platformData)
           );
+        } else {
         }
       } catch (error) {
         console.error("Error al obtener los datos del tenant:", error);
@@ -1045,7 +1064,6 @@ const extractCloudProviderInfo = (accountSpec: any) => {
     credentialSecret: "",
   };
 };
-
 export const updateUser = async (user: User) => {
   try {
     const userBody = {
@@ -1057,22 +1075,25 @@ export const updateUser = async (user: User) => {
         companyRole: user.rol,
       },
     };
-    await makeGlobalWebSocketRequest(
+    const response = await makeGlobalWebSocketRequest(
       "user:modify_user_info",
       userBody,
       30000,
       "PUT",
-      "UPDATE_USER",
+      "UPDATE_USER"
     );
     eventHelper.user.publish.updated(user);
-    eventHelper.notification.publish.creation({
+    const userUpdatedNotification: Notification = {
       type: "success",
       subtype: "user-updated",
       date: Date.now().toString(),
       status: "unread",
       callToAction: false,
-      data: { user: user.name },
-    });
+      data: {
+        user: user.name
+      }
+    };
+    eventHelper.notification.publish.creation(userUpdatedNotification);
   } catch (error) {
     console.error("Error updating user:", {
       error,
@@ -1080,56 +1101,65 @@ export const updateUser = async (user: User) => {
       stack: error instanceof Error ? error.stack : undefined,
     });
     eventHelper.user.publish.updateError(user);
-    eventHelper.notification.publish.creation({
+    const userUpdatedNotificationError: Notification = {
       type: "error",
       subtype: "tenant-update-error",
       date: Date.now().toString(),
       status: "unread",
       callToAction: false,
-      info_content: {
+      info_content:{
         code: (error as any).error.code,
-        message: (error as any).error.content,
+        message: (error as any).error.content
       },
-      data: { user: user.name },
-    });
+      data: {
+        user: user.name
+      }
+    };
+    eventHelper.notification.publish.creation(userUpdatedNotificationError);
     throw error;
   }
 };
-
 export const deleteUSer = async (user: User, security: string) => {
   try {
     await initializeGlobalWebSocketClient(security);
     const response = await makeGlobalWebSocketRequest(
       "user:delete_user",
       {},
-      30000,
+      30000,  
       "DELETE",
       "DELETE_USER",
-      "user",
+      "user"
     );
-    eventHelper.notification.publish.creation({
+    
+    const userDeletedNotification: Notification = {
       type: "success",
       subtype: "user-deleted",
       date: Date.now().toString(),
       status: "unread",
       callToAction: false,
-      data: { user: user.name },
-    });
+      data: {
+        user: user.name
+      }
+    };
+    eventHelper.notification.publish.creation(userDeletedNotification);
     return response;
   } catch (error) {
     console.error("Error deleting user:", error);
-    eventHelper.notification.publish.creation({
+    const userDeletedNotificationError: Notification = {
       type: "error",
       subtype: "user-delete-error",
       date: Date.now().toString(),
       status: "unread",
       callToAction: false,
-      info_content: {
+      info_content:{
         code: (error as any).error.code,
-        message: (error as any).error.content,
+        message: (error as any).error.content
       },
-      data: { user: user.name },
-    });
+      data: {
+        user: user.name
+      }
+    };
+    eventHelper.notification.publish.creation(userDeletedNotificationError);
     throw error;
   }
-};
+};