@kumori/aurora-backend-handler 1.0.50 → 1.0.52

package/api/user-api-service.ts

@@ -4,7 +4,23 @@ 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 {
+  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";
 
 type Security = string;
 
@@ -30,7 +46,7 @@ export const isUserLogged = async (security: Security) => {
       {},
       30000,
       "GET",
-      "USER_INFO"
+      "USER_INFO",
     );
     userLogged = true;
   } catch (error) {
@@ -54,9 +70,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) {
@@ -64,10 +80,11 @@ 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", {});
@@ -79,13 +96,7 @@ 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: [],
@@ -102,11 +113,12 @@ 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({
@@ -121,26 +133,18 @@ 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;
@@ -157,22 +161,18 @@ 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,10 +193,7 @@ 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: {
@@ -255,7 +252,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}`,
@@ -265,10 +262,7 @@ 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: [],
@@ -277,9 +271,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: {
@@ -335,6 +329,7 @@ export const loadUserData = async () => {
 
               tenantAccounts.push(newAccount);
             }
+
             const kinds = [
               "ca",
               "certificate",
@@ -343,18 +338,14 @@ export const loadUserData = async () => {
               "secret",
               "volume",
             ];
-
             for (const kind of kinds) {
               try {
                 const resourcesResponse = await makeGlobalWebSocketRequest(
                   "resource:list_resources",
-                  {
-                    tenant: tenant.name,
-                    kind: kind,
-                  },
+                  { tenant: tenant.name, kind },
                   30000,
                   "GET",
-                  "ALL_RESOURCES"
+                  "ALL_RESOURCES",
                 );
                 const resourcesData = resourcesResponse.data;
                 if (
@@ -362,7 +353,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;
                 }
@@ -372,28 +363,21 @@ export const loadUserData = async () => {
                     const resourceName = resource.id.name;
                     const resourceResponse = await makeGlobalWebSocketRequest(
                       "resource:resource_info",
-                      {
-                        tenant: tenant.name,
-                        kind: kind,
-                        resource: resourceName,
-                      },
+                      { tenant: tenant.name, 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 &&
-                      resourceDataJson.status.requested
-                    ) {
-                      const requestedKeys = Object.keys(
-                        resourceDataJson.status.requested
-                      );
-                      if (requestedKeys.length > 0) {
+                    if (resourceDataJson.status?.requested) {
+                      if (
+                        Object.keys(resourceDataJson.status.requested).length >
+                        0
+                      ) {
                         resourceStatus = "used";
                       }
                     }
@@ -417,10 +401,7 @@ export const loadUserData = async () => {
                         status: resourceStatus,
                       } as Resource);
                     } else if (
-                      resourceType === "domain" ||
-                      resourceType === "port" ||
-                      resourceType === "ca" ||
-                      resourceType === "secret"
+                      ["domain", "port", "ca", "secret"].includes(resourceType)
                     ) {
                       tenant.resources.push({
                         type: kind,
@@ -432,26 +413,25 @@ 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);
@@ -464,6 +444,7 @@ export const loadUserData = async () => {
                 timestamp: "",
                 args: [],
               };
+
               const serviceResponse = await makeGlobalWebSocketRequest(
                 "service:describe_service",
                 {
@@ -473,10 +454,11 @@ export const loadUserData = async () => {
                 },
                 30000,
                 "GET",
-                (serviceValue as any).name
+                (serviceValue as any).name,
               );
               const serviceData = serviceResponse.data;
-              let revisionData;
+
+              let revisionData: any;
               try {
                 const revisionResponse = await makeGlobalWebSocketRequest(
                   "revision:revision_info",
@@ -487,7 +469,7 @@ export const loadUserData = async () => {
                   },
                   30000,
                   "GET_REVISION",
-                  (serviceValue as any).name
+                  (serviceValue as any).name,
                 );
                 revisionData = revisionResponse.data;
               } catch (revisionError) {
@@ -496,48 +478,76 @@ 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;
-              let revisionsData;
+
+              // revisionData.revision is a string ID, revisionData.intensives has the resource limits
+              const revisionId: string = revisionData.revision;
+              const intensives = revisionData.intensives ?? {};
+
+              let rawHistoryData: any[] = [];
               try {
                 const revisionsResponse = await makeGlobalWebSocketRequest(
                   "service:report_history_service",
-                  {
-                    tenant: tenant.name,
-                    service: serviceName,
-                  },
+                  { tenant: tenant.name, service: serviceName },
                   30000,
                   "GET_HISTORY",
-                  serviceName
+                  serviceName,
                 );
-                revisionsData = revisionsResponse.data;
+                rawHistoryData = 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: string[] = [];
-              for (const revision of revisionsData) {
-                revisions.push(revision.revision);
-              }
+              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 serviceRoles: { name: string; instances: Instance[] }[] =
                 [];
@@ -558,13 +568,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 [
@@ -620,27 +630,15 @@ 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 });
@@ -650,10 +648,10 @@ export const loadUserData = async () => {
                     message: "",
                     timestamp: "",
                     args: [],
-                  },
+                  };
                   console.warn(
                     `Error obteniendo instancias para el rol ${roleName}:`,
-                    instanceError
+                    instanceError,
                   );
                 }
               }
@@ -676,7 +674,7 @@ export const loadUserData = async () => {
                 name: (serviceValue as any).name,
                 logo: "",
                 description: "",
-                revisions: revisions,
+                revisions,
                 status: serviceStatus,
                 role: serviceRoles,
                 links: [],
@@ -693,57 +691,53 @@ export const loadUserData = async () => {
                   },
                   limit: {
                     cpu: {
-                      max: revisionData.revision.spec.intensives.vcpu / 1000,
-                      min: revisionData.revision.spec.intensives.vcpu / 1000,
+                      max: intensives.vcpu / 1000,
+                      min: intensives.vcpu / 1000,
                     },
                     memory: {
-                      max: revisionData.revision.spec.intensives.ram / 1000,
-                      min: revisionData.revision.spec.intensives.ram / 1000,
+                      max: intensives.ram / 1000,
+                      min: intensives.ram / 1000,
                     },
                     storage: {
-                      max: revisionData.revision.spec.intensives.shared_disk,
-                      min: revisionData.revision.spec.intensives.shared_disk,
+                      max: intensives.shared_disk,
+                      min: intensives.shared_disk,
                     },
                     volatileStorage: {
-                      max: revisionData.revision.spec.intensives.volatile_disk,
-                      min: revisionData.revision.spec.intensives.volatile_disk,
+                      max: intensives.volatile_disk,
+                      min: intensives.volatile_disk,
                     },
                     nonReplicatedStorage: {
-                      max: revisionData.revision.spec.intensives
-                        .nrpersistent_disk,
-                      min: revisionData.revision.spec.intensives
-                        .nrpersistent_disk,
+                      max: intensives.nrpersistent_disk,
+                      min: intensives.nrpersistent_disk,
                     },
                     persistentStorage: {
-                      max: revisionData.revision.spec.intensives
-                        .persistent_disk,
-                      min: revisionData.revision.spec.intensives
-                        .persistent_disk,
+                      max: intensives.persistent_disk,
+                      min: intensives.persistent_disk,
                     },
                   },
                   cost: 0,
                 },
                 minReplicas: 0,
                 maxReplicas: 0,
-                lastDeployed: `${revisionData.revision.spec.tstamp}`,
+                lastDeployed: `${revisionData.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: revisionData.revision.id.name,
+                currentRevision: revisionId,
               };
 
               userServices.push(newService);
@@ -751,27 +745,25 @@ 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 environment of tenantEnvironments) {
-            environment.services = userServices
-              .filter((service) => service.environment === environment.name)
+          for (const env of tenantEnvironments) {
+            env.services = userServices
+              .filter((service) => service.environment === env.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[] = [];
@@ -779,36 +771,31 @@ 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]);
-                }
               });
-              const item: MarketplaceItem = {
+              tenantItems.push({
                 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: cpu,
-                  memory: memory,
-                },
+                requirements: { cpu, 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 = [];
           }
@@ -824,17 +811,14 @@ export const loadUserData = async () => {
       try {
         const organizationsResponse = await makeGlobalWebSocketRequest(
           "organization:list_organizations",
-          {
-            strict: true,
-          },
+          { strict: true },
           30000,
           "GET",
-          "ORGANIZATIONS"
+          "ORGANIZATIONS",
         );
         const organizationsData = organizationsResponse.data;
-        const organizationsEntries = Object.entries(organizationsData);
-        for (const [, organizationValue] of organizationsEntries) {
-          const newOrg = {
+        for (const [, organizationValue] of Object.entries(organizationsData)) {
+          userOrganizations.push({
             id: (organizationValue as any).spec.companyName,
             name: (organizationValue as any).id.name,
             usersIds: Object.keys((organizationValue as any).spec.users),
@@ -851,8 +835,7 @@ export const loadUserData = async () => {
               zipcode: (organizationValue as any).spec.billing.zip,
             },
             invoices: [],
-          };
-          userOrganizations.push(newOrg);
+          });
         }
       } catch (organizationError) {
         console.error("Error obteniendo organizaciones:", organizationError);
@@ -864,9 +847,8 @@ export const loadUserData = async () => {
           {},
           30000,
           "GET",
-          "PLATFORM"
+          "PLATFORM",
         );
-
         const platformData: Platform = {
           instanceName: String(platformResponse.instanceName),
           platformVersion: String(platformResponse.platformVersion),
@@ -885,72 +867,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),
             },
@@ -969,30 +951,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),
             },
@@ -1008,9 +990,8 @@ 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);
@@ -1064,6 +1045,7 @@ const extractCloudProviderInfo = (accountSpec: any) => {
     credentialSecret: "",
   };
 };
+
 export const updateUser = async (user: User) => {
   try {
     const userBody = {
@@ -1075,25 +1057,22 @@ export const updateUser = async (user: User) => {
         companyRole: user.rol,
       },
     };
-    const response = await makeGlobalWebSocketRequest(
+    await makeGlobalWebSocketRequest(
       "user:modify_user_info",
       userBody,
       30000,
       "PUT",
-      "UPDATE_USER"
+      "UPDATE_USER",
     );
     eventHelper.user.publish.updated(user);
-    const userUpdatedNotification: Notification = {
+    eventHelper.notification.publish.creation({
       type: "success",
       subtype: "user-updated",
       date: Date.now().toString(),
       status: "unread",
       callToAction: false,
-      data: {
-        user: user.name
-      }
-    };
-    eventHelper.notification.publish.creation(userUpdatedNotification);
+      data: { user: user.name },
+    });
   } catch (error) {
     console.error("Error updating user:", {
       error,
@@ -1101,65 +1080,56 @@ export const updateUser = async (user: User) => {
       stack: error instanceof Error ? error.stack : undefined,
     });
     eventHelper.user.publish.updateError(user);
-    const userUpdatedNotificationError: Notification = {
+    eventHelper.notification.publish.creation({
       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
-      }
-    };
-    eventHelper.notification.publish.creation(userUpdatedNotificationError);
+      data: { user: user.name },
+    });
     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",
     );
-    
-    const userDeletedNotification: Notification = {
+    eventHelper.notification.publish.creation({
       type: "success",
       subtype: "user-deleted",
       date: Date.now().toString(),
       status: "unread",
       callToAction: false,
-      data: {
-        user: user.name
-      }
-    };
-    eventHelper.notification.publish.creation(userDeletedNotification);
+      data: { user: user.name },
+    });
     return response;
   } catch (error) {
     console.error("Error deleting user:", error);
-    const userDeletedNotificationError: Notification = {
+    eventHelper.notification.publish.creation({
       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
-      }
-    };
-    eventHelper.notification.publish.creation(userDeletedNotificationError);
+      data: { user: user.name },
+    });
     throw error;
   }
-};
+};