@kumori/aurora-backend-handler 1.0.100 → 1.0.111

package/backend-handler.ts

@@ -1,4 +1,11 @@
-import { createUser, loadUser, isUserLogged, updateUser, deleteUSer } from "./api/user-api-service";
+import {
+  createUser,
+  loadUser,
+  isUserLogged,
+  updateUser,
+  deleteUSer,
+  getUserHTTP,
+} from "./api/user-api-service";
 import {
   changeRevision,
   deleteService,
@@ -13,6 +20,7 @@ import {
 import {
   deployMarketplaceItem,
   getMarketplaceItems,
+  getMarketplaceSchema,
 } from "./api/marketplace-api-service";
 import {
   clearAccount,
@@ -46,48 +54,68 @@ import {
 } from "./api/environment-api-service";
 import EventHelper, { RegistryUpdatePayload } from "./event-helper";
 import { environment } from "./environment";
-import { initializeGlobalWebSocketClient, updateUserComplete } from "./websocket-manager";
+import {
+  fetchAndStoreMarketplaceSchema,
+  initializeGlobalWebSocketClient,
+  updateUserComplete,
+} from "./websocket-manager";
 import {
   createResource,
   deleteResource,
   updateResource,
 } from "./api/resources-api-service";
-import { getPlanProviders } from './api/planProvider-api-service';
-import { Account, Environment, Link, MarketplaceService, Notification, Organization, Resource, Service, Tenant, tenantRole, UserData } from "@kumori/aurora-interfaces";
+import { getPlanProviders } from "./api/planProvider-api-service";
+import {
+  Account,
+  Environment,
+  errors,
+  Link,
+  MarketplaceItem,
+  MarketplaceService,
+  Notification,
+  Organization,
+  Resource,
+  Service,
+  Tenant,
+  tenantRole,
+  User,
+  UserData,
+} from "@kumori/aurora-interfaces";
 
 export let eventHelper: EventHelper;
-const token =
-  "";
+const token = "";
 export class BackendHandler {
   private unsubscribeFunctions: (() => void)[] = [];
   constructor(
     route: string,
     globalEventHandler: any,
     baseUrl: string,
-    apiVersion: string
+    apiVersion: string,
   ) {
     if (
       !globalEventHandler ||
       typeof globalEventHandler.subscribe !== "function"
     ) {
       throw new Error(
-        "globalEventHandler inválido. Asegúrate de pasar una instancia correcta de EventHandler."
+        "globalEventHandler inválido. Asegúrate de pasar una instancia correcta de EventHandler.",
       );
     }
     eventHelper = new EventHelper(globalEventHandler);
-    eventHelper.user.subscribe.load((data: UserData) => {
-      initializeGlobalWebSocketClient(token, "", "", data);
-    });
-    const loadedCb = (data: UserData) => {
-      updateUserComplete(data);
-    };
-    eventHelper.user.subscribe.loaded(loadedCb);
-   
-    this.changeRoute(route);
     environment.apiServer.baseUrl = baseUrl;
     environment.apiServer.apiVersion = apiVersion;
+    getUserHTTP().then(() => {
+      eventHelper.user.subscribe.load((data: UserData) => {
+        initializeGlobalWebSocketClient(token, "", "", data);
+      });
+      const loadedCb = (data: UserData) => {
+        updateUserComplete(data);
+      };
+      eventHelper.user.subscribe.loaded(loadedCb);
+      this.changeRoute(route);
+      eventHelper.user.publish.load({} as UserData);
+    })
   }
-  
+
   /**
    * Function to change the route and subscribe to the new route events
    * @param newRoute string with the new route
@@ -135,7 +163,6 @@ export class BackendHandler {
     this.subscribeMarketplaceEvents();
     this.subscribeResourceEvents();
     this.subscribeOrganizationEvents();
-    
   }
   public async isUserLoggedIn(): Promise<boolean> {
     const loggedIn = await isUserLogged(token);
@@ -157,21 +184,19 @@ export class BackendHandler {
     };
     eventHelper.tenant.subscribe.creation(creationCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.creation(creationCb)
+      eventHelper.tenant.unsubscribe.creation(creationCb),
     );
 
-    const createdCb = (data: Tenant) => {
-    };
+    const createdCb = (data: Tenant) => {};
     eventHelper.tenant.subscribe.created(createdCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.created(createdCb)
+      eventHelper.tenant.unsubscribe.created(createdCb),
     );
 
-    const creationErrorCb = (data: Tenant) => {
-    };
+    const creationErrorCb = (data: Tenant) => {};
     eventHelper.tenant.subscribe.creationError(creationErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.creationError(creationErrorCb)
+      eventHelper.tenant.unsubscribe.creationError(creationErrorCb),
     );
 
     const updateCb = (data: Tenant) => {
@@ -179,21 +204,19 @@ export class BackendHandler {
     };
     eventHelper.tenant.subscribe.update(updateCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.update(updateCb)
+      eventHelper.tenant.unsubscribe.update(updateCb),
     );
 
-    const updatedCb = (data: Tenant) => {
-    };
+    const updatedCb = (data: Tenant) => {};
     eventHelper.tenant.subscribe.updated(updatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.updated(updatedCb)
+      eventHelper.tenant.unsubscribe.updated(updatedCb),
     );
 
-    const updateErrorCb = (data: Tenant) => {
-    };
+    const updateErrorCb = (data: Tenant) => {};
     eventHelper.tenant.subscribe.updateError(updateErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.updateError(updateErrorCb)
+      eventHelper.tenant.unsubscribe.updateError(updateErrorCb),
     );
 
     const deleteCb = (data: Tenant) => {
@@ -202,196 +225,221 @@ export class BackendHandler {
     };
     eventHelper.tenant.subscribe.delete(deleteCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.delete(deleteCb)
+      eventHelper.tenant.unsubscribe.delete(deleteCb),
     );
 
-    const deletedCb = (data: Tenant) => {
-    };
+    const deletedCb = (data: Tenant) => {};
     eventHelper.tenant.subscribe.deleted(deletedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.deleted(deletedCb)
+      eventHelper.tenant.unsubscribe.deleted(deletedCb),
     );
 
-    const deletionErrorCb = (data: Tenant) => {
-    };
+    const deletionErrorCb = (data: Tenant) => {};
     eventHelper.tenant.subscribe.deletionError(deletionErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.deletionError(deletionErrorCb)
+      eventHelper.tenant.unsubscribe.deletionError(deletionErrorCb),
     );
     const createRegistryCb = (payload: RegistryUpdatePayload) => {
       createRegistry(payload.tenant, token, payload.registry);
-    }
+    };
     eventHelper.tenant.subscribe.createRegistry(createRegistryCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.createRegistry(createRegistryCb)
+      eventHelper.tenant.unsubscribe.createRegistry(createRegistryCb),
     );
-    const registryCreatedCb = (payload: RegistryUpdatePayload) => {
-    }
+    const registryCreatedCb = (payload: RegistryUpdatePayload) => {};
     eventHelper.tenant.subscribe.registryCreated(registryCreatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.registryCreated(registryCreatedCb)
+      eventHelper.tenant.unsubscribe.registryCreated(registryCreatedCb),
     );
-    const registryCreationErrorCb = (payload: RegistryUpdatePayload) => {
-    }
+    const registryCreationErrorCb = (payload: RegistryUpdatePayload) => {};
     eventHelper.tenant.subscribe.registryCreationError(registryCreationErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.registryCreationError(registryCreationErrorCb)
+      eventHelper.tenant.unsubscribe.registryCreationError(
+        registryCreationErrorCb,
+      ),
     );
     const updateRegistryCb = (payload: RegistryUpdatePayload) => {
       updateRegistry(payload.tenant, payload.registry, token);
-    }
+    };
     eventHelper.tenant.subscribe.updateRegistry(updateRegistryCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.updateRegistry(updateRegistryCb)
+      eventHelper.tenant.unsubscribe.updateRegistry(updateRegistryCb),
     );
-    const registryUpdatedCb = (payload: RegistryUpdatePayload) => {
-    }
+    const registryUpdatedCb = (payload: RegistryUpdatePayload) => {};
     eventHelper.tenant.subscribe.registryUpdated(registryUpdatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.registryUpdated(registryUpdatedCb)
+      eventHelper.tenant.unsubscribe.registryUpdated(registryUpdatedCb),
     );
-    const registryUpdateErrorCb = (payload: RegistryUpdatePayload) => {
-    }
+    const registryUpdateErrorCb = (payload: RegistryUpdatePayload) => {};
     eventHelper.tenant.subscribe.registryUpdateError(registryUpdateErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.registryUpdateError(registryUpdateErrorCb)
+      eventHelper.tenant.unsubscribe.registryUpdateError(registryUpdateErrorCb),
     );
     const deleteRegistryCb = (payload: RegistryUpdatePayload) => {
       deleteRegistry(payload.tenant, payload.registry, token);
-    }
+    };
     eventHelper.tenant.subscribe.deleteRegistry(deleteRegistryCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.deleteRegistry(deleteRegistryCb)
+      eventHelper.tenant.unsubscribe.deleteRegistry(deleteRegistryCb),
     );
-    const registryDeletedCb = (payload: RegistryUpdatePayload) => {
-    }
+    const registryDeletedCb = (payload: RegistryUpdatePayload) => {};
     eventHelper.tenant.subscribe.registryDeleted(registryDeletedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.registryDeleted(registryDeletedCb)
+      eventHelper.tenant.unsubscribe.registryDeleted(registryDeletedCb),
     );
-    const registryDeletionErrorCb = (payload: RegistryUpdatePayload) => {
-    }
+    const registryDeletionErrorCb = (payload: RegistryUpdatePayload) => {};
     eventHelper.tenant.subscribe.registryDeletionError(registryDeletionErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.registryDeletionError(registryDeletionErrorCb)
+      eventHelper.tenant.unsubscribe.registryDeletionError(
+        registryDeletionErrorCb,
+      ),
     );
-    const inviteUserCb = (payload: { user: string; tenant: string; role: tenantRole }) => {
+    const inviteUserCb = (payload: {
+      user: string;
+      tenant: string;
+      role: tenantRole;
+    }) => {
       inviteUser(payload.tenant, payload.user, payload.role, token);
     };
     eventHelper.tenant.subscribe.inviteUser(inviteUserCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.inviteUser(inviteUserCb)
+      eventHelper.tenant.unsubscribe.inviteUser(inviteUserCb),
     );
-    const userInvitedCb = (payload: { user: string; tenant: string; role: tenantRole }) => {
+    const userInvitedCb = (payload: {
+      user: string;
+      tenant: string;
+      role: tenantRole;
+    }) => {
       updateUserRole(payload.user, payload.tenant, payload.role, token);
     };
     eventHelper.tenant.subscribe.userInvited(userInvitedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.userInvited(userInvitedCb)
+      eventHelper.tenant.unsubscribe.userInvited(userInvitedCb),
     );
-    const userInviteErrorCb = (payload: { user: string; tenant: string; role: tenantRole }) => {
-    };
+    const userInviteErrorCb = (payload: {
+      user: string;
+      tenant: string;
+      role: tenantRole;
+    }) => {};
     eventHelper.tenant.subscribe.inviteError(userInviteErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.inviteError(userInviteErrorCb)
+      eventHelper.tenant.unsubscribe.inviteError(userInviteErrorCb),
     );
-    const removeUserFromTenantCb = (payload: { user: string; tenant: string }) => {
-      removeUser(payload.tenant,payload.user, token)
-    }
+    const removeUserFromTenantCb = (payload: {
+      user: string;
+      tenant: string;
+    }) => {
+      removeUser(payload.tenant, payload.user, token);
+    };
     eventHelper.tenant.subscribe.removeUser(removeUserFromTenantCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.removeUser(removeUserFromTenantCb)
+      eventHelper.tenant.unsubscribe.removeUser(removeUserFromTenantCb),
     );
-    const userRemovedFromTenantCb = (payload: { user: string; tenant: string }) => {
-    }
+    const userRemovedFromTenantCb = (payload: {
+      user: string;
+      tenant: string;
+    }) => {};
     eventHelper.tenant.subscribe.userRemoved(userRemovedFromTenantCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.userRemoved(userRemovedFromTenantCb)
+      eventHelper.tenant.unsubscribe.userRemoved(userRemovedFromTenantCb),
     );
-    const userRemoveErrorCb = (payload: { user: string; tenant: string }) => {
-    }
+    const userRemoveErrorCb = (payload: { user: string; tenant: string }) => {};
     eventHelper.tenant.subscribe.removeUserError(userRemoveErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.removeUserError(userRemoveErrorCb)
+      eventHelper.tenant.unsubscribe.removeUserError(userRemoveErrorCb),
     );
-    const updateInviteCb = (payload: { user: string; role: tenantRole; tenant: string }) => {
-      updateUserRole(payload.tenant, payload.user, payload.role, token)
-    }
+    const updateInviteCb = (payload: {
+      user: string;
+      role: tenantRole;
+      tenant: string;
+    }) => {
+      updateUserRole(payload.tenant, payload.user, payload.role, token);
+    };
     eventHelper.tenant.subscribe.updateInvite(updateInviteCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.updateInvite(updateInviteCb)
+      eventHelper.tenant.unsubscribe.updateInvite(updateInviteCb),
     );
-    const inviteUpdatedCb = (payload: { user: string; role: string; tenant: string }) => {
-    }
+    const inviteUpdatedCb = (payload: {
+      user: string;
+      role: string;
+      tenant: string;
+    }) => {};
     eventHelper.tenant.subscribe.inviteUpdated(inviteUpdatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.inviteUpdated(inviteUpdatedCb)
+      eventHelper.tenant.unsubscribe.inviteUpdated(inviteUpdatedCb),
     );
-    const inviteUpdateErrorCb = (payload: { user: string; role: string; tenant: string }) => {
-    }
+    const inviteUpdateErrorCb = (payload: {
+      user: string;
+      role: string;
+      tenant: string;
+    }) => {};
     eventHelper.tenant.subscribe.inviteUpdateError(inviteUpdateErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.inviteUpdateError(inviteUpdateErrorCb)
+      eventHelper.tenant.unsubscribe.inviteUpdateError(inviteUpdateErrorCb),
     );
     const acceptInviteCb = (payload: { tenant: string }) => {
       acceptInvite(payload.tenant, token);
-    }
+    };
     eventHelper.tenant.subscribe.acceptInvite(acceptInviteCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.acceptInvite(acceptInviteCb)
+      eventHelper.tenant.unsubscribe.acceptInvite(acceptInviteCb),
     );
-    const inviteAcceptedCb = (payload: { tenant: string}) => {
-    }
+    const inviteAcceptedCb = (payload: { tenant: string }) => {};
     eventHelper.tenant.subscribe.inviteAccepted(inviteAcceptedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.inviteAccepted(inviteAcceptedCb)
+      eventHelper.tenant.unsubscribe.inviteAccepted(inviteAcceptedCb),
     );
-    const inviteAcceptErrorCb = (payload: { tenant: string }) => {
-    }
+    const inviteAcceptErrorCb = (payload: { tenant: string }) => {};
     eventHelper.tenant.subscribe.acceptInviteError(inviteAcceptErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.acceptInviteError(inviteAcceptErrorCb)
+      eventHelper.tenant.unsubscribe.acceptInviteError(inviteAcceptErrorCb),
     );
-    const rejectInviteCb = (payload: { tenant: string }) => {
-      rejectInvite(payload.tenant, token);
-    }
+    const rejectInviteCb = (payload: { tenant: string; leave: boolean }) => {
+      rejectInvite(payload.tenant, token, payload.leave);
+    };
     eventHelper.tenant.subscribe.rejectInvite(rejectInviteCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.rejectInvite(rejectInviteCb)
+      eventHelper.tenant.unsubscribe.rejectInvite(rejectInviteCb),
     );
-    const inviteRejectedCb = (payload: { user: string; tenant: string }) => {
-    }
+    const inviteRejectedCb = (payload: { user: string; tenant: string }) => {};
     eventHelper.tenant.subscribe.inviteRejected(inviteRejectedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.inviteRejected(inviteRejectedCb)
+      eventHelper.tenant.unsubscribe.inviteRejected(inviteRejectedCb),
     );
-    const inviteRejectErrorCb = (payload: { tenant: string }) => {
-    }
+    const inviteRejectErrorCb = (payload: { tenant: string }) => {};
     eventHelper.tenant.subscribe.inviteRejectError(inviteRejectErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.inviteRejectError(inviteRejectErrorCb)
+      eventHelper.tenant.unsubscribe.inviteRejectError(inviteRejectErrorCb),
     );
     const getPlanProvidersCb = () => {
       getPlanProviders(token);
-    }
+    };
     eventHelper.planProviders.subscribe.loadPlans(getPlanProvidersCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.planProviders.unsubscribe.loadPlans(getPlanProvidersCb)
-    );
-    const crateTokenCb = (payload: { tenant: string; expiration: string; description: string }) => {
-      createToken(payload.tenant, payload.description, payload.expiration, token);
-      
-    }
+      eventHelper.planProviders.unsubscribe.loadPlans(getPlanProvidersCb),
+    );
+    const crateTokenCb = (payload: {
+      tenant: string;
+      expiration: string;
+      description: string;
+    }) => {
+      createToken(
+        payload.tenant,
+        payload.description,
+        payload.expiration,
+        token,
+      );
+    };
     eventHelper.tenant.subscribe.createToken(crateTokenCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.createToken(crateTokenCb)
+      eventHelper.tenant.unsubscribe.createToken(crateTokenCb),
     );
     const deleteTokenCb = (payload: { tenant: string; token: string }) => {
       deleteToken(payload.tenant, payload.token, token);
-    }
+    };
     eventHelper.tenant.subscribe.deleteToken(deleteTokenCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.tenant.unsubscribe.deleteToken(deleteTokenCb)
+      eventHelper.tenant.unsubscribe.deleteToken(deleteTokenCb),
     );
   }
   /**
@@ -403,21 +451,19 @@ export class BackendHandler {
     };
     eventHelper.user.subscribe.creation(creationCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.user.unsubscribe.creation(creationCb)
+      eventHelper.user.unsubscribe.creation(creationCb),
     );
 
-    const createdCb = (data: UserData) => {
-    };
+    const createdCb = (data: UserData) => {};
     eventHelper.user.subscribe.created(createdCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.user.unsubscribe.created(createdCb)
+      eventHelper.user.unsubscribe.created(createdCb),
     );
 
-    const creationErrorCb = (data: UserData) => {
-    };
+    const creationErrorCb = (data: UserData) => {};
     eventHelper.user.subscribe.creationError(creationErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.user.unsubscribe.creationError(creationErrorCb)
+      eventHelper.user.unsubscribe.creationError(creationErrorCb),
     );
 
     const updateCb = (data: UserData) => {
@@ -425,21 +471,19 @@ export class BackendHandler {
     };
     eventHelper.user.subscribe.update(updateCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.user.unsubscribe.update(updateCb)
+      eventHelper.user.unsubscribe.update(updateCb),
     );
 
-    const updatedCb = (data: UserData) => {
-    };
+    const updatedCb = (data: UserData) => {};
     eventHelper.user.subscribe.updated(updatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.user.unsubscribe.updated(updatedCb)
+      eventHelper.user.unsubscribe.updated(updatedCb),
     );
 
-    const updateErrorCb = (data: UserData) => {
-    };
+    const updateErrorCb = (data: UserData) => {};
     eventHelper.user.subscribe.updateError(updateErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.user.unsubscribe.updateError(updateErrorCb)
+      eventHelper.user.unsubscribe.updateError(updateErrorCb),
     );
 
     const loadCb = (data: UserData) => {
@@ -447,7 +491,7 @@ export class BackendHandler {
     };
     eventHelper.user.subscribe.load(loadCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.user.unsubscribe.load(loadCb)
+      eventHelper.user.unsubscribe.load(loadCb),
     );
 
     // const loadedCb = (data: UserData) => {
@@ -458,11 +502,10 @@ export class BackendHandler {
     //   eventHelper.user.unsubscribe.loaded(loadedCb)
     // );
 
-    const loadErrorCb = (data: UserData) => {
-    };
+    const loadErrorCb = (data: UserData) => {};
     eventHelper.user.subscribe.loadError(loadErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.user.unsubscribe.loadError(loadErrorCb)
+      eventHelper.user.unsubscribe.loadError(loadErrorCb),
     );
 
     const deleteCb = (data: UserData) => {
@@ -470,21 +513,19 @@ export class BackendHandler {
     };
     eventHelper.user.subscribe.delete(deleteCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.user.unsubscribe.delete(deleteCb)
+      eventHelper.user.unsubscribe.delete(deleteCb),
     );
 
-    const deletedCb = (data: UserData) => {
-    };
+    const deletedCb = (data: UserData) => {};
     eventHelper.user.subscribe.deleted(deletedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.user.unsubscribe.deleted(deletedCb)
+      eventHelper.user.unsubscribe.deleted(deletedCb),
     );
 
-    const deletionErrorCb = (data: UserData) => {
-    };
+    const deletionErrorCb = (data: UserData) => {};
     eventHelper.user.subscribe.deletionError(deletionErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.user.unsubscribe.deletionError(deletionErrorCb)
+      eventHelper.user.unsubscribe.deletionError(deletionErrorCb),
     );
   }
   /**
@@ -496,21 +537,19 @@ export class BackendHandler {
     };
     eventHelper.account.subscribe.creation(creationCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.account.unsubscribe.creation(creationCb)
+      eventHelper.account.unsubscribe.creation(creationCb),
     );
 
-    const createdCb = (data: Account) => {
-    };
+    const createdCb = (data: Account) => {};
     eventHelper.account.subscribe.created(createdCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.account.unsubscribe.created(createdCb)
+      eventHelper.account.unsubscribe.created(createdCb),
     );
 
-    const creationErrorCb = (data: Account) => {
-    };
+    const creationErrorCb = (data: Account) => {};
     eventHelper.account.subscribe.creationError(creationErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.account.unsubscribe.creationError(creationErrorCb)
+      eventHelper.account.unsubscribe.creationError(creationErrorCb),
     );
 
     const updateCb = (data: Account) => {
@@ -518,21 +557,19 @@ export class BackendHandler {
     };
     eventHelper.account.subscribe.update(updateCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.account.unsubscribe.update(updateCb)
+      eventHelper.account.unsubscribe.update(updateCb),
     );
 
-    const updatedCb = (data: Account) => {
-    };
+    const updatedCb = (data: Account) => {};
     eventHelper.account.subscribe.updated(updatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.account.unsubscribe.updated(updatedCb)
+      eventHelper.account.unsubscribe.updated(updatedCb),
     );
 
-    const updateErrorCb = (data: Account) => {
-    };
+    const updateErrorCb = (data: Account) => {};
     eventHelper.account.subscribe.updateError(updateErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.account.unsubscribe.updateError(updateErrorCb)
+      eventHelper.account.unsubscribe.updateError(updateErrorCb),
     );
 
     const deleteCb = (data: Account) => {
@@ -540,96 +577,90 @@ export class BackendHandler {
     };
     eventHelper.account.subscribe.delete(deleteCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.account.unsubscribe.delete(deleteCb)
+      eventHelper.account.unsubscribe.delete(deleteCb),
     );
 
-    const deletedCb = (data: Account) => {
-    };
+    const deletedCb = (data: Account) => {};
     eventHelper.account.subscribe.deleted(deletedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.account.unsubscribe.deleted(deletedCb)
+      eventHelper.account.unsubscribe.deleted(deletedCb),
     );
 
-    const deletionErrorCb = (data: Account) => {
-    };
+    const deletionErrorCb = (data: Account) => {};
     eventHelper.account.subscribe.deletionError(deletionErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.account.unsubscribe.deletionError(deletionErrorCb)
+      eventHelper.account.unsubscribe.deletionError(deletionErrorCb),
     );
     const cleanCb = (data: Account) => {
       clearAccount(data, token);
     };
     eventHelper.account.subscribe.clean(cleanCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.account.unsubscribe.clean(cleanCb)
+      eventHelper.account.unsubscribe.clean(cleanCb),
     );
   }
   /**
    * Function to subscribe to the plan events
    */
   private subscribePlanEvents(): void {
-    const updateCb = (data: string) => {
-    };
+    const updateCb = (data: string) => {};
     eventHelper.plan.subscribe.upgrade(updateCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.plan.unsubscribe.upgrade(updateCb)
+      eventHelper.plan.unsubscribe.upgrade(updateCb),
     );
 
     const updatedCb = (data: string) => {
       const upgradeNotification: Notification = {
         type: "success",
-        subtype: "plan-upgrade",
+        subtype: errors.user.planUpgraded.subtype,
         date: Date.now().toString(),
         status: "unread",
         callToAction: false,
         data: {
-          plan: data
-        }
+          plan: data,
+        },
       };
       eventHelper.notification.publish.creation(upgradeNotification);
     };
     eventHelper.plan.subscribe.upgraded(updatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.plan.unsubscribe.upgraded(updatedCb)
+      eventHelper.plan.unsubscribe.upgraded(updatedCb),
     );
 
-    const updateErrorCb = (data: string) => {
-    };
+    const updateErrorCb = (data: string) => {};
     eventHelper.plan.subscribe.upgradeError(updateErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.plan.unsubscribe.upgradeError(updateErrorCb)
+      eventHelper.plan.unsubscribe.upgradeError(updateErrorCb),
     );
 
-    const downgradeCb = (data: string) => {
-    };
+    const downgradeCb = (data: string) => {};
     eventHelper.plan.subscribe.downgrade(downgradeCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.plan.unsubscribe.downgrade(downgradeCb)
+      eventHelper.plan.unsubscribe.downgrade(downgradeCb),
     );
 
     const downgradedCb = (data: string) => {
       const downgradeNotification: Notification = {
         type: "success",
-        subtype: "plan-downgrade",
+        subtype: errors.user.planDowngraded.subtype,
         date: Date.now().toString(),
         status: "unread",
         callToAction: false,
         data: {
-          plan: data
-        }
+          plan: data,
+        },
       };
       eventHelper.notification.publish.creation(downgradeNotification);
     };
     eventHelper.plan.subscribe.downgraded(downgradedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.plan.unsubscribe.downgraded(downgradedCb)
+      eventHelper.plan.unsubscribe.downgraded(downgradedCb),
     );
 
-    const downgradeErrorCb = (data: string) => {
-    };
+    const downgradeErrorCb = (data: string) => {};
     eventHelper.plan.subscribe.downgradeError(downgradeErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.plan.unsubscribe.downgradeError(downgradeErrorCb)
+      eventHelper.plan.unsubscribe.downgradeError(downgradeErrorCb),
     );
   }
   /**
@@ -641,34 +672,33 @@ export class BackendHandler {
     };
     eventHelper.environment.subscribe.creation(creationCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.environment.unsubscribe.creation(creationCb)
+      eventHelper.environment.unsubscribe.creation(creationCb),
     );
 
     const createdCb = (data: Environment) => {
       const envNotification: Notification = {
         type: "success",
-        subtype: "environment-created",
+        subtype: errors.environment.created.subtype,
         date: Date.now().toString(),
         status: "unread",
         callToAction: false,
-        data : {
+        data: {
           environment: data.name,
           account: data.account,
-          tenant: data.tenant
-        }
+          tenant: data.tenant,
+        },
       };
       eventHelper.notification.publish.creation(envNotification);
     };
     eventHelper.environment.subscribe.created(createdCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.environment.unsubscribe.created(createdCb)
+      eventHelper.environment.unsubscribe.created(createdCb),
     );
 
-    const creationErrorCb = (data: Environment) => {
-    };
+    const creationErrorCb = (data: Environment) => {};
     eventHelper.environment.subscribe.creationError(creationErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.environment.unsubscribe.creationError(creationErrorCb)
+      eventHelper.environment.unsubscribe.creationError(creationErrorCb),
     );
 
     const updateCb = (data: Environment) => {
@@ -676,21 +706,19 @@ export class BackendHandler {
     };
     eventHelper.environment.subscribe.update(updateCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.environment.unsubscribe.update(updateCb)
+      eventHelper.environment.unsubscribe.update(updateCb),
     );
 
-    const updatedCb = (data: Environment) => {
-    };
+    const updatedCb = (data: Environment) => {};
     eventHelper.environment.subscribe.updated(updatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.environment.unsubscribe.updated(updatedCb)
+      eventHelper.environment.unsubscribe.updated(updatedCb),
     );
 
-    const updateErrorCb = (data: Environment) => {
-    };
+    const updateErrorCb = (data: Environment) => {};
     eventHelper.environment.subscribe.updateError(updateErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.environment.unsubscribe.updateError(updateErrorCb)
+      eventHelper.environment.unsubscribe.updateError(updateErrorCb),
     );
 
     const deleteCb = (data: Environment) => {
@@ -698,37 +726,34 @@ export class BackendHandler {
     };
     eventHelper.environment.subscribe.delete(deleteCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.environment.unsubscribe.delete(deleteCb)
+      eventHelper.environment.unsubscribe.delete(deleteCb),
     );
 
-    const deletedCb = (data: Environment) => {
-    };
+    const deletedCb = (data: Environment) => {};
     eventHelper.environment.subscribe.deleted(deletedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.environment.unsubscribe.deleted(deletedCb)
+      eventHelper.environment.unsubscribe.deleted(deletedCb),
     );
 
-    const deletionErrorCb = (data: Environment) => {
-    };
+    const deletionErrorCb = (data: Environment) => {};
     eventHelper.environment.subscribe.deletionError(deletionErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.environment.unsubscribe.deletionError(deletionErrorCb)
+      eventHelper.environment.unsubscribe.deletionError(deletionErrorCb),
     );
     const cleanCb = (data: Environment) => {
       clearEnvironment(data, token);
     };
     eventHelper.environment.subscribe.clean(cleanCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.environment.unsubscribe.clean(cleanCb)
+      eventHelper.environment.unsubscribe.clean(cleanCb),
     );
     const scaleCb = (data: Environment) => {
-      console.log('Scale called', data)
       scaleEnvironment(data, token);
-    }
+    };
     eventHelper.environment.subscribe.scale(scaleCb);
-    this.unsubscribeFunctions.push(() => 
-      eventHelper.environment.unsubscribe.scale(scaleCb)
-    )
+    this.unsubscribeFunctions.push(() =>
+      eventHelper.environment.unsubscribe.scale(scaleCb),
+    );
   }
   /**
    * Function to subscribe to the service events
@@ -737,14 +762,14 @@ export class BackendHandler {
     const deployedCb = (data: Service) => {
       const deploymentSuccessNotification: Notification = {
         type: "success",
-        subtype: "deployment-success",
+        subtype: errors.deployment.success.subtype,
         date: Date.now().toString(),
         status: "unread",
         callToAction: false,
         data: {
           service: data.name,
-          tenant: data.tenant
-        }
+          tenant: data.tenant,
+        },
       };
       eventHelper.notification.publish.creation(deploymentSuccessNotification);
     };
@@ -752,19 +777,19 @@ export class BackendHandler {
     const deploymentErrorCb = (data: Service) => {
       const deploymentErrorNotification: Notification = {
         type: "error",
-        subtype: "deployment-error",
+        subtype: errors.deployment.error.subtype,
         date: Date.now().toString(),
         status: "unread",
         info_content: {
-          code: data.error?.code || '',
-          message: data.error?.message || '',
-          timestamp: data.error?.timestamp || '',
+          code: data.error?.code || "",
+          message: data.error?.message || "",
+          timestamp: data.error?.timestamp || "",
         },
         callToAction: false,
         data: {
           service: data.name,
-          tenant: data.tenant
-        }
+          tenant: data.tenant,
+        },
       };
       eventHelper.notification.publish.creation(deploymentErrorNotification);
     };
@@ -773,143 +798,152 @@ export class BackendHandler {
       deployService(data, token);
       const deploymentSuccessNotification: Notification = {
         type: "info",
-        subtype: "deployment-in-progress",
+        subtype: errors.deployment.inProgress.subtype,
         date: Date.now().toString(),
         status: "unread",
         callToAction: false,
         data: {
           service: data.name,
-          tenant: data.tenant
-        }
+          tenant: data.tenant,
+        },
       };
-      data.download ? '' : eventHelper.notification.publish.creation(deploymentSuccessNotification);
+      data.download
+        ? ""
+        : eventHelper.notification.publish.creation(
+            deploymentSuccessNotification,
+          );
     };
     eventHelper.service.subscribe.deploy(deployCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.deploy(deployCb)
+      eventHelper.service.unsubscribe.deploy(deployCb),
     );
 
-
     const updateCb = (data: Service) => {
       updateService(data, token);
     };
     eventHelper.service.subscribe.update(updateCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.update(updateCb)
+      eventHelper.service.unsubscribe.update(updateCb),
     );
 
     const updatedCb = (data: Service) => {
       const deploymentNotification: Notification = {
         type: "success",
-        subtype: "deployment-updated",
+        subtype: errors.deployment.updated.subtype,
         date: Date.now().toString(),
         status: "unread",
         callToAction: false,
         data: {
           service: data.name,
-          tenant: data.tenant
-        }
+          tenant: data.tenant,
+        },
       };
       eventHelper.notification.publish.creation(deploymentNotification);
     };
     eventHelper.service.subscribe.updated(updatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.updated(updatedCb)
+      eventHelper.service.unsubscribe.updated(updatedCb),
     );
 
-    const updateErrorCb = (data: Service) => {
-    };
+    const updateErrorCb = (data: Service) => {};
     eventHelper.service.subscribe.updateError(updateErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.updateError(updateErrorCb)
+      eventHelper.service.unsubscribe.updateError(updateErrorCb),
     );
 
     const deleteCb = (data: Service) => {
       const deploymentNotification: Notification = {
         type: "info",
-        subtype: "deployment-deleting",
+        subtype: errors.deployment.deleting.subtype,
         date: Date.now().toString(),
         status: "unread",
         callToAction: false,
         data: {
           service: data.name,
-          tenant: data.tenant
-        }
+          tenant: data.tenant,
+        },
       };
       eventHelper.notification.publish.creation(deploymentNotification);
       deleteService(data, token);
     };
     eventHelper.service.subscribe.delete(deleteCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.delete(deleteCb)
+      eventHelper.service.unsubscribe.delete(deleteCb),
     );
 
     const deletedCb = (data: Service) => {
       const deploymentNotification: Notification = {
         type: "success",
-        subtype: "deployment-deleted",
+        subtype: errors.deployment.deleted.subtype,
         date: Date.now().toString(),
         status: "unread",
         callToAction: false,
         data: {
           service: data.name,
-          tenant: data.tenant
-        }
+          tenant: data.tenant,
+        },
       };
       eventHelper.notification.publish.creation(deploymentNotification);
     };
     eventHelper.service.subscribe.deleted(deletedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.deleted(deletedCb)
+      eventHelper.service.unsubscribe.deleted(deletedCb),
     );
 
-    const deletionErrorCb = (data: Service) => {
-    };
+    const deletionErrorCb = (data: Service) => {};
     eventHelper.service.subscribe.deletionError(deletionErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.deletionError(deletionErrorCb)
+      eventHelper.service.unsubscribe.deletionError(deletionErrorCb),
     );
 
-    const requestLogsCb = (data: Service) => {
-    };
+    const requestLogsCb = (data: Service) => {};
     eventHelper.service.subscribe.requestLogs(requestLogsCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.requestLogs(requestLogsCb)
+      eventHelper.service.unsubscribe.requestLogs(requestLogsCb),
     );
     const restartCb = (data: Service) => {
       restartService(data, token);
     };
     eventHelper.service.subscribe.restart(restartCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.restart(restartCb)
+      eventHelper.service.unsubscribe.restart(restartCb),
     );
     const requestRevisionCb = (data: Service) => {
       requestRevisionData(data, token);
-    }
+    };
     eventHelper.service.subscribe.requestRevisionData(requestRevisionCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.requestRevisionData(requestRevisionCb)
+      eventHelper.service.unsubscribe.requestRevisionData(requestRevisionCb),
     );
     const updateServiceLinksCb = (data: Link) => {
       updateServiceLinks(data, token);
-    }
+    };
     eventHelper.service.subscribe.updateServiceLinks(updateServiceLinksCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.updateServiceLinks(updateServiceLinksCb)
+      eventHelper.service.unsubscribe.updateServiceLinks(updateServiceLinksCb),
     );
     const changeRevisionCb = (data: Service) => {
       changeRevision(data, token);
-    }
+    };
     eventHelper.service.subscribe.changeRevision(changeRevisionCb);
     this.unsubscribeFunctions.push(() => {
       eventHelper.service.unsubscribe.changeRevision(changeRevisionCb);
-    })
-    const restartInstanceCb = (payload: { service: Service; roleId: string; instanceId: string; }) => {
-      restartInstance(payload.service, payload.roleId, payload.instanceId, token);
-    }
+    });
+    const restartInstanceCb = (payload: {
+      service: Service;
+      roleId: string;
+      instanceId: string;
+    }) => {
+      restartInstance(
+        payload.service,
+        payload.roleId,
+        payload.instanceId,
+        token,
+      );
+    };
     eventHelper.service.subscribe.restartInstance(restartInstanceCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.service.unsubscribe.restartInstance(restartInstanceCb)
+      eventHelper.service.unsubscribe.restartInstance(restartInstanceCb),
     );
   }
   /**
@@ -921,69 +955,60 @@ export class BackendHandler {
     };
     eventHelper.marketplace.subscribe.deployItem(deployItemCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.marketplace.unsubscribe.deployItem(deployItemCb)
+      eventHelper.marketplace.unsubscribe.deployItem(deployItemCb),
     );
 
-    const itemDeployedCb = (data: Service) => {
-    };
+    const itemDeployedCb = (data: Service) => {};
     eventHelper.marketplace.subscribe.itemDeployed(itemDeployedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.marketplace.unsubscribe.itemDeployed(itemDeployedCb)
+      eventHelper.marketplace.unsubscribe.itemDeployed(itemDeployedCb),
     );
 
-    const deploymentErrorCb = (data: Service) => {
-    };
+    const deploymentErrorCb = (data: Service) => {};
     eventHelper.marketplace.subscribe.deploymentError(deploymentErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.marketplace.unsubscribe.deploymentError(deploymentErrorCb)
+      eventHelper.marketplace.unsubscribe.deploymentError(deploymentErrorCb),
     );
 
-    const updateItemCb = (data: Service) => {
-    };
+    const updateItemCb = (data: Service) => {};
     eventHelper.marketplace.subscribe.updateItem(updateItemCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.marketplace.unsubscribe.updateItem(updateItemCb)
+      eventHelper.marketplace.unsubscribe.updateItem(updateItemCb),
     );
 
-    const itemUpdatedCb = (data: Service) => {
-    };
+    const itemUpdatedCb = (data: Service) => {};
     eventHelper.marketplace.subscribe.itemUpdated(itemUpdatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.marketplace.unsubscribe.itemUpdated(itemUpdatedCb)
+      eventHelper.marketplace.unsubscribe.itemUpdated(itemUpdatedCb),
     );
 
-    const updateErrorCb = (data: Service) => {
-    };
+    const updateErrorCb = (data: Service) => {};
     eventHelper.marketplace.subscribe.updateError(updateErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.marketplace.unsubscribe.updateError(updateErrorCb)
+      eventHelper.marketplace.unsubscribe.updateError(updateErrorCb),
     );
 
-    const deleteItemCb = (data: Service) => {
-    };
+    const deleteItemCb = (data: Service) => {};
     eventHelper.marketplace.subscribe.deleteItem(deleteItemCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.marketplace.unsubscribe.deleteItem(deleteItemCb)
+      eventHelper.marketplace.unsubscribe.deleteItem(deleteItemCb),
     );
 
-    const itemDeletedCb = (data: Service) => {
-    };
+    const itemDeletedCb = (data: Service) => {};
     eventHelper.marketplace.subscribe.itemDeleted(itemDeletedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.marketplace.unsubscribe.itemDeleted(itemDeletedCb)
+      eventHelper.marketplace.unsubscribe.itemDeleted(itemDeletedCb),
     );
 
-    const deletionErrorCb = (data: Service) => {
-    };
+    const deletionErrorCb = (data: Service) => {};
     eventHelper.marketplace.subscribe.deletionError(deletionErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.marketplace.unsubscribe.deletionError(deletionErrorCb)
+      eventHelper.marketplace.unsubscribe.deletionError(deletionErrorCb),
     );
 
     const loadItemsCb = (data: string[]) => {
       // getMarketplaceItems(data, token)
       //   .then((result) => {
-
       //     eventHelper.marketplace.publish.itemsLoaded(result.items);
       //   })
       //   .catch((err) => {
@@ -992,7 +1017,22 @@ export class BackendHandler {
     };
     eventHelper.marketplace.subscribe.loadItems(loadItemsCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.marketplace.unsubscribe.loadItems(loadItemsCb)
+      eventHelper.marketplace.unsubscribe.loadItems(loadItemsCb),
+    );
+    const loadSchemaCb = async (payload: string) => {
+  try {
+    const { item } = JSON.parse(payload) as { item: MarketplaceItem };
+    await fetchAndStoreMarketplaceSchema(item);
+    eventHelper.marketplace.publish.schemaLoaded(item);
+  } catch (error) {
+    console.error(`Error loading schema for marketplace item:`, error);
+    eventHelper.marketplace.publish.schemaLoadError(payload);
+  }
+};
+
+    eventHelper.marketplace.subscribe.loadSchema(loadSchemaCb);
+    this.unsubscribeFunctions.push(() =>
+      eventHelper.marketplace.unsubscribe.loadSchema(loadSchemaCb),
     );
   }
   /**
@@ -1004,21 +1044,19 @@ export class BackendHandler {
     };
     eventHelper.resource.subscribe.creation(creationCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.resource.unsubscribe.creation(creationCb)
+      eventHelper.resource.unsubscribe.creation(creationCb),
     );
 
-    const createdCb = (data: Resource) => {
-    };
+    const createdCb = (data: Resource) => {};
     eventHelper.resource.subscribe.created(createdCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.resource.unsubscribe.created(createdCb)
+      eventHelper.resource.unsubscribe.created(createdCb),
     );
 
-    const creationErrorCb = (data: Resource) => {
-    };
+    const creationErrorCb = (data: Resource) => {};
     eventHelper.resource.subscribe.creationError(creationErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.resource.unsubscribe.creationError(creationErrorCb)
+      eventHelper.resource.unsubscribe.creationError(creationErrorCb),
     );
 
     const updateCb = (data: Resource) => {
@@ -1026,21 +1064,19 @@ export class BackendHandler {
     };
     eventHelper.resource.subscribe.update(updateCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.resource.unsubscribe.update(updateCb)
+      eventHelper.resource.unsubscribe.update(updateCb),
     );
 
-    const updatedCb = (data: Resource) => {
-    };
+    const updatedCb = (data: Resource) => {};
     eventHelper.resource.subscribe.updated(updatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.resource.unsubscribe.updated(updatedCb)
+      eventHelper.resource.unsubscribe.updated(updatedCb),
     );
 
-    const updateErrorCb = (data: Resource) => {
-    };
+    const updateErrorCb = (data: Resource) => {};
     eventHelper.resource.subscribe.updateError(updateErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.resource.unsubscribe.updateError(updateErrorCb)
+      eventHelper.resource.unsubscribe.updateError(updateErrorCb),
     );
 
     const deleteCb = (data: Resource) => {
@@ -1048,101 +1084,91 @@ export class BackendHandler {
     };
     eventHelper.resource.subscribe.delete(deleteCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.resource.unsubscribe.delete(deleteCb)
+      eventHelper.resource.unsubscribe.delete(deleteCb),
     );
 
     const deletedCb = (data: Resource) => {
       const resourceNotification: Notification = {
-      type: "success",
-      subtype: "resource-deleted",
-      date: Date.now().toString(),
-      status: "unread",
-      callToAction: false,
-      data: {
-        resource: data.name,
-        type: data.type,
-        tenant: data.tenant
-      }
-    };
-    eventHelper.notification.publish.creation(resourceNotification);
+        type: "success",
+        subtype: errors.resource.deleted.subtype,
+        date: Date.now().toString(),
+        status: "unread",
+        callToAction: false,
+        data: {
+          resource: data.name,
+          type: data.type,
+          tenant: data.tenant,
+        },
+      };
+      eventHelper.notification.publish.creation(resourceNotification);
     };
     eventHelper.resource.subscribe.deleted(deletedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.resource.unsubscribe.deleted(deletedCb)
+      eventHelper.resource.unsubscribe.deleted(deletedCb),
     );
 
-    const deletionErrorCb = (data: Resource) => {
-    };
+    const deletionErrorCb = (data: Resource) => {};
     eventHelper.resource.subscribe.deletionError(deletionErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.resource.unsubscribe.deletionError(deletionErrorCb)
+      eventHelper.resource.unsubscribe.deletionError(deletionErrorCb),
     );
   }
   /**
    * Function to subscribe to the organization events
    */
   private subscribeOrganizationEvents(): void {
-    const creationCb = (data: Organization) => {
-    };
+    const creationCb = (data: Organization) => {};
     eventHelper.organization.subscribe.creation(creationCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.organization.unsubscribe.creation(creationCb)
+      eventHelper.organization.unsubscribe.creation(creationCb),
     );
 
-    const createdCb = (data: Organization) => {
-    };
+    const createdCb = (data: Organization) => {};
     eventHelper.organization.subscribe.created(createdCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.organization.unsubscribe.created(createdCb)
+      eventHelper.organization.unsubscribe.created(createdCb),
     );
 
-    const creationErrorCb = (data: Organization) => {
-    };
+    const creationErrorCb = (data: Organization) => {};
     eventHelper.organization.subscribe.creationError(creationErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.organization.unsubscribe.creationError(creationErrorCb)
+      eventHelper.organization.unsubscribe.creationError(creationErrorCb),
     );
 
-    const updateCb = (data: Organization) => {
-    };
+    const updateCb = (data: Organization) => {};
     eventHelper.organization.subscribe.update(updateCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.organization.unsubscribe.update(updateCb)
+      eventHelper.organization.unsubscribe.update(updateCb),
     );
 
-    const updatedCb = (data: Organization) => {
-    };
+    const updatedCb = (data: Organization) => {};
     eventHelper.organization.subscribe.updated(updatedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.organization.unsubscribe.updated(updatedCb)
+      eventHelper.organization.unsubscribe.updated(updatedCb),
     );
 
-    const updateErrorCb = (data: Organization) => {
-    };
+    const updateErrorCb = (data: Organization) => {};
     eventHelper.organization.subscribe.updateError(updateErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.organization.unsubscribe.updateError(updateErrorCb)
+      eventHelper.organization.unsubscribe.updateError(updateErrorCb),
     );
 
-    const deleteCb = (data: Organization) => {
-    };
+    const deleteCb = (data: Organization) => {};
     eventHelper.organization.subscribe.delete(deleteCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.organization.unsubscribe.delete(deleteCb)
+      eventHelper.organization.unsubscribe.delete(deleteCb),
     );
 
-    const deletedCb = (data: Organization) => {
-    };
+    const deletedCb = (data: Organization) => {};
     eventHelper.organization.subscribe.deleted(deletedCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.organization.unsubscribe.deleted(deletedCb)
+      eventHelper.organization.unsubscribe.deleted(deletedCb),
     );
 
-    const deletionErrorCb = (data: Organization) => {
-    };
+    const deletionErrorCb = (data: Organization) => {};
     eventHelper.organization.subscribe.deletionError(deletionErrorCb);
     this.unsubscribeFunctions.push(() =>
-      eventHelper.organization.unsubscribe.deletionError(deletionErrorCb)
+      eventHelper.organization.unsubscribe.deletionError(deletionErrorCb),
     );
   }
 }