passbolt-browser-extension 5.3.0 → 5.3.2

package/src/all/background_page/controller/metadata/getOrFindMetadataKeysSettingsController.test.js

@@ -0,0 +1,106 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.4.0
+ */
+
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import GetOrFindMetadataKeysController from "./getOrFindMetadataKeysSettingsController";
+import {
+  defaultMetadataKeysSettingsDto,
+} from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysSettingsEntity.test.data";
+import MetadataKeysSettingsEntity
+  from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysSettingsEntity";
+import {enableFetchMocks} from "jest-fetch-mock";
+import {
+  defaultCeOrganizationSettings
+} from "../../model/entity/organizationSettings/organizationSettingsEntity.test.data";
+
+beforeEach(() => {
+  enableFetchMocks();
+});
+
+jest.mock("../../service/passphrase/getPassphraseService");
+
+describe("GetOrFindMetadataKeysSettingsController", () => {
+  let controller, account, apiClientOptions;
+
+  beforeEach(async() => {
+    account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = defaultApiClientOptions();
+    controller = new GetOrFindMetadataKeysController(null, null, apiClientOptions, account);
+    // flush account related storage before each.
+    await controller.getOrFindMetadaSettingsService.metadataKeysSettingsLocalStorage.flush();
+  });
+
+  describe("::exec", () => {
+    it("get or find metadata keys settings for a v5.", async() => {
+      expect.assertions(3);
+
+      const metadataKeysSettingsDto = defaultMetadataKeysSettingsDto();
+      const siteSettingsDto = defaultCeOrganizationSettings();
+      jest.spyOn(controller.getOrFindMetadaSettingsService.findAndUpdateMetadataSettingsLocalStorageService.findMetadataSettingsService, "findKeysSettings")
+        .mockImplementationOnce(() => new MetadataKeysSettingsEntity(metadataKeysSettingsDto));
+      jest.spyOn(controller.getOrFindMetadaSettingsService.findAndUpdateMetadataSettingsLocalStorageService.organisationSettingsModel.organizationSettingsService, "find")
+        .mockImplementation(() => siteSettingsDto);
+
+      const metadataKeysSettings = await controller.exec();
+
+      expect(metadataKeysSettings).toBeInstanceOf(MetadataKeysSettingsEntity);
+      expect(metadataKeysSettings.toDto()).toEqual(metadataKeysSettingsDto);
+      const storageValue = await controller.getOrFindMetadaSettingsService.metadataKeysSettingsLocalStorage.get();
+      expect(storageValue).toEqual(metadataKeysSettingsDto);
+    });
+
+    it("get or find metadata keys settings with usage of the shared key for a v5.", async() => {
+      expect.assertions(3);
+
+      const metadataKeysSettingsDto = defaultMetadataKeysSettingsDto({
+        allow_usage_of_personal_keys: false,
+        zero_knowledge_key_share: true,
+      });
+      const siteSettingsDto = defaultCeOrganizationSettings();
+      jest.spyOn(controller.getOrFindMetadaSettingsService.findAndUpdateMetadataSettingsLocalStorageService.findMetadataSettingsService, "findKeysSettings")
+        .mockImplementationOnce(() => new MetadataKeysSettingsEntity(metadataKeysSettingsDto));
+      jest.spyOn(controller.getOrFindMetadaSettingsService.findAndUpdateMetadataSettingsLocalStorageService.organisationSettingsModel.organizationSettingsService, "find")
+        .mockImplementation(() => siteSettingsDto);
+
+      const metadataKeysSettings = await controller.exec();
+
+      expect(metadataKeysSettings).toBeInstanceOf(MetadataKeysSettingsEntity);
+      expect(metadataKeysSettings.toDto()).toEqual(metadataKeysSettingsDto);
+      const storageValue = await controller.getOrFindMetadaSettingsService.metadataKeysSettingsLocalStorage.get();
+      expect(storageValue).toEqual(metadataKeysSettingsDto);
+    });
+
+    it("get or find metadata keys settings for a v4 should have the default.", async() => {
+      expect.assertions(3);
+
+      const siteSettingsDto = defaultCeOrganizationSettings();
+      // disable the plugin metadata.
+      delete siteSettingsDto.passbolt.plugins.metadata;
+      jest.spyOn(controller.getOrFindMetadaSettingsService.findAndUpdateMetadataSettingsLocalStorageService.organisationSettingsModel.organizationSettingsService, "find")
+        .mockImplementation(() => siteSettingsDto);
+      jest.spyOn(controller.getOrFindMetadaSettingsService.findAndUpdateMetadataSettingsLocalStorageService.findMetadataSettingsService.metadataKeysSettingsApiService, "findSettings")
+        .mockImplementationOnce(() => {});
+
+      const metadataKeysSettings = await controller.exec();
+
+      const expectedMetadataKeysSettingsDto = MetadataKeysSettingsEntity.createFromDefault().toDto();
+      expect(metadataKeysSettings).toBeInstanceOf(MetadataKeysSettingsEntity);
+      expect(metadataKeysSettings.toDto()).toEqual(expectedMetadataKeysSettingsDto);
+      const storageValue = await controller.getOrFindMetadaSettingsService.metadataKeysSettingsLocalStorage.get();
+      expect(storageValue).toEqual(expectedMetadataKeysSettingsDto);
+    });
+  });
+});

package/src/all/background_page/controller/user/deleteDryRunUserController.js

@@ -0,0 +1,73 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.4.0
+ */
+
+import DeleteDryRunError from "../../error/deleteDryRunError";
+import GetPassphraseService from "../../service/passphrase/getPassphraseService";
+import DeleteUserService from "../../service/user/deleteUserService";
+import DecryptMetadataService from "../../service/metadata/decryptMetadataService";
+
+class DeleteDryRunUserController {
+  /**
+   * Constructor
+   * @param {Worker} worker
+   * @param {string} requestId uuid
+   * @param {ApiClientOptions} apiClientOptions The api client options
+   * @param {AccountEntity} account The account associated to the worker.
+   */
+  constructor(worker, requestId, apiClientOptions, account) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.deleteUserService = new DeleteUserService(account, apiClientOptions);
+    this.getPassphraseService = new GetPassphraseService(account);
+    this.decryptMetadataService = new DecryptMetadataService(apiClientOptions, account);
+  }
+
+  /**
+   * Controller executor.
+   * @returns {Promise<void>}
+   */
+  async _exec(userId) {
+    try {
+      await this.exec(userId);
+      this.worker.port.emit(this.requestId, 'SUCCESS');
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Delete dry run the user.
+   * @param {string} userId The user id.
+   * @return {Promise<void>}
+   * @throws {DeleteDryRunError} if the data should be transferred to someone.
+   * @throws {Error} if the data returned by the API is not a PassboltApiFetchError with error code 400.
+   */
+  async exec(userId) {
+    try {
+      await this.deleteUserService.deleteDryRun(userId);
+    } catch (error) {
+      if (error instanceof DeleteDryRunError) {
+        const resourcesCollection = error.errors.resources?.sole_owner;
+        if (resourcesCollection?.items.some(resourceEntity => !resourceEntity.isMetadataDecrypted())) {
+          const passphrase = await this.getPassphraseService.getPassphrase(this.worker);
+          await this.decryptMetadataService.decryptAllFromForeignModels(error.errors.resources.sole_owner, passphrase);
+        }
+      }
+      throw error;
+    }
+  }
+}
+
+export default DeleteDryRunUserController;

package/src/all/background_page/controller/user/deleteDryRunUserController.test.js

@@ -0,0 +1,129 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.4.0
+ */
+
+import {enableFetchMocks} from "jest-fetch-mock";
+import {mockApiResponse, mockApiResponseError} from "../../../../../test/mocks/mockApiResponse";
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import RoleEntity from "passbolt-styleguide/src/shared/models/entity/role/roleEntity";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import {defaultSharedResourcesWithEncryptedMetadataDtos, defaultResourcesDtos} from "passbolt-styleguide/src/shared/models/entity/resource/resourcesCollection.test.data";
+import {defaultDecryptedSharedMetadataKeysDtos} from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysCollection.test.data";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+import DeleteDryRunUserController from "./deleteDryRunUserController";
+import {v4 as uuidv4} from "uuid";
+import DeleteDryRunError from "../../error/deleteDryRunError";
+import {pgpKeys} from 'passbolt-styleguide/test/fixture/pgpKeys/keys';
+import MetadataKeysCollection from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysCollection";
+
+beforeEach(() => {
+  enableFetchMocks();
+});
+
+describe("DeleteDryRunUserController", () => {
+  describe("::exec", () => {
+    const accountDto = defaultAccountDto();
+    accountDto.role_name = RoleEntity.ROLE_ADMIN;
+    const account = new AccountEntity(accountDto);
+
+    it("Should delete dry run the user without transfer", async() => {
+      expect.assertions(1);
+
+      const userId = uuidv4();
+
+      fetch.doMockOnceIf(new RegExp(`/users/${userId}/dry-run.json`), () => mockApiResponse({}));
+
+      const controller = new DeleteDryRunUserController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.deleteUserService, "deleteDryRun");
+
+      await controller.exec(userId);
+
+      expect(controller.deleteUserService.deleteDryRun).toHaveBeenCalledWith(userId);
+    });
+
+    it("Should throw an error if the user has transfer and decrypt", async() => {
+      expect.assertions(2);
+
+      const userId = uuidv4();
+      const metadataKeysDtos = defaultDecryptedSharedMetadataKeysDtos();
+      const metadataKeys = new MetadataKeysCollection(metadataKeysDtos);
+      const collectionDto = defaultSharedResourcesWithEncryptedMetadataDtos(10, {
+        metadata_key_id: metadataKeysDtos[0].id
+      });
+      const body = {
+        errors: {
+          resources: {
+            sole_owner: collectionDto
+          }
+        }
+      };
+
+      fetch.doMockOnceIf(new RegExp(`/users/${userId}/dry-run.json`), () => mockApiResponseError(400, "Need transfer", body));
+
+      const controller = new DeleteDryRunUserController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.decryptMetadataService.getOrFindMetadataKeysService, "getOrFindAll").mockImplementation(() => metadataKeys);
+      jest.spyOn(controller.getPassphraseService, "getPassphrase").mockImplementationOnce(() => pgpKeys.ada.passphrase);
+
+      try {
+        await controller.exec(userId);
+      } catch (error) {
+        expect(error).toBeInstanceOf(DeleteDryRunError);
+        expect(error.errors.resources.sole_owner.items.every(resourceEntity => resourceEntity.isMetadataDecrypted())).toBeTruthy();
+      }
+    });
+
+    it("Should throw an error if the user has transfer without decryption", async() => {
+      expect.assertions(4);
+
+      const userId = uuidv4();
+      const collectionDto = defaultResourcesDtos();
+      const body = {
+        errors: {
+          resources: {
+            sole_owner: collectionDto
+          }
+        }
+      };
+
+      fetch.doMockOnceIf(new RegExp(`/users/${userId}/dry-run.json`), () => mockApiResponseError(400, "Need transfer", body));
+
+      const controller = new DeleteDryRunUserController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.decryptMetadataService.getOrFindMetadataKeysService, "getOrFindAll");
+      jest.spyOn(controller.getPassphraseService, "getPassphrase");
+
+      try {
+        await controller.exec(userId);
+      } catch (error) {
+        expect(error).toBeInstanceOf(DeleteDryRunError);
+        expect(error.errors.resources.sole_owner.items.every(resourceEntity => resourceEntity.isMetadataDecrypted())).toBeTruthy();
+        expect(controller.decryptMetadataService.getOrFindMetadataKeysService.getOrFindAll).not.toHaveBeenCalled();
+        expect(controller.getPassphraseService.getPassphrase).not.toHaveBeenCalled();
+      }
+    });
+
+    it("Should throw an error if something wrong happens on the API", async() => {
+      expect.assertions(1);
+
+      const userId = uuidv4();
+      fetch.doMockOnceIf(new RegExp(`/users/${userId}/dry-run.json`), async() => mockApiResponseError(500, "Something went wrong"));
+
+      const controller = new DeleteDryRunUserController(null, null, defaultApiClientOptions(), account);
+      try {
+        await controller.exec(userId);
+      } catch (e) {
+        expect(e).toBeInstanceOf(PassboltApiFetchError);
+      }
+    });
+  });
+});

package/src/all/background_page/controller/user/deleteUserController.js

@@ -0,0 +1,76 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.4.0
+ */
+
+import DeleteDryRunError from "../../error/deleteDryRunError";
+import GetPassphraseService from "../../service/passphrase/getPassphraseService";
+import DeleteUserService from "../../service/user/deleteUserService";
+import DecryptMetadataService from "../../service/metadata/decryptMetadataService";
+import UserDeleteTransferEntity from "../../model/entity/user/transfer/userDeleteTransferEntity";
+
+class DeleteUserController {
+  /**
+   * Constructor
+   * @param {Worker} worker
+   * @param {string} requestId uuid
+   * @param {ApiClientOptions} apiClientOptions The api client options
+   * @param {AccountEntity} account The account associated to the worker.
+   */
+  constructor(worker, requestId, apiClientOptions, account) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.deleteUserService = new DeleteUserService(account, apiClientOptions);
+    this.getPassphraseService = new GetPassphraseService(account);
+    this.decryptMetadataService = new DecryptMetadataService(apiClientOptions, account);
+  }
+
+  /**
+   * Controller executor.
+   * @returns {Promise<void>}
+   */
+  async _exec(userId, transferDto) {
+    try {
+      await this.exec(userId, transferDto);
+      this.worker.port.emit(this.requestId, 'SUCCESS');
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Delete dry run the user.
+   * @param {string} userId The user id.
+   * @param {object} [transferDto = null] The transfer dto.
+   * @return {Promise<void>}
+   * @throws {DeleteDryRunError} if the data should be transferred to someone.
+   * @throws {Error} if the data returned by the API is not a PassboltApiFetchError with error code 400.
+   */
+  async exec(userId, transferDto = null) {
+    try {
+      const transferEntity = transferDto ? new UserDeleteTransferEntity(transferDto) : null;
+      await this.deleteUserService.delete(userId, transferEntity);
+    } catch (error) {
+      if (error instanceof DeleteDryRunError) {
+        const resourcesCollection = error.errors.resources?.sole_owner;
+        if (resourcesCollection?.items.some(resourceEntity => !resourceEntity.isMetadataDecrypted())) {
+          const passphrase = this.getPassphraseService.getPassphrase(this.worker);
+          await this.decryptMetadataService.decryptAllFromForeignModels(error.errors.resources.sole_owner, passphrase);
+        }
+      }
+      throw error;
+    }
+  }
+}
+
+export default DeleteUserController;

package/src/all/background_page/controller/user/deleteUserController.test.js

@@ -0,0 +1,141 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.4.0
+ */
+
+import {enableFetchMocks} from "jest-fetch-mock";
+import {mockApiResponse, mockApiResponseError} from "../../../../../test/mocks/mockApiResponse";
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import RoleEntity from "passbolt-styleguide/src/shared/models/entity/role/roleEntity";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import {defaultSharedResourcesWithEncryptedMetadataDtos, defaultResourcesDtos} from "passbolt-styleguide/src/shared/models/entity/resource/resourcesCollection.test.data";
+import {defaultDecryptedSharedMetadataKeysDtos} from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysCollection.test.data";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+import {v4 as uuidv4} from "uuid";
+import DeleteDryRunError from "../../error/deleteDryRunError";
+import {pgpKeys} from 'passbolt-styleguide/test/fixture/pgpKeys/keys';
+import MetadataKeysCollection from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysCollection";
+import {defaultUserDto} from "passbolt-styleguide/src/shared/models/entity/user/userEntity.test.data";
+import DeleteUserController from "./deleteUserController";
+import UserLocalStorage from "../../service/local_storage/userLocalStorage";
+import UsersCollection from "../../model/entity/user/usersCollection";
+
+beforeEach(() => {
+  enableFetchMocks();
+});
+
+describe("DeleteUserController", () => {
+  describe("::exec", () => {
+    const accountDto = defaultAccountDto();
+    accountDto.role_name = RoleEntity.ROLE_ADMIN;
+    const account = new AccountEntity(accountDto);
+
+    it("Should delete the user without transfer", async() => {
+      expect.assertions(2);
+
+      const userDto = defaultUserDto();
+      await UserLocalStorage.set(new UsersCollection([userDto]));
+
+      fetch.doMockOnceIf(new RegExp(`/users/${userDto.id}.json`), () => mockApiResponse({}));
+
+      const controller = new DeleteUserController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.deleteUserService, "delete");
+      jest.spyOn(UserLocalStorage, "delete");
+
+      await controller.exec(userDto.id);
+
+      expect(controller.deleteUserService.delete).toHaveBeenCalledWith(userDto.id, null);
+      expect(UserLocalStorage.delete).toHaveBeenCalledWith(userDto.id);
+    });
+
+    it("Should throw an error if the user has transfer and decrypt", async() => {
+      expect.assertions(3);
+
+      const userDto = defaultUserDto();
+      await UserLocalStorage.set(new UsersCollection([userDto]));
+      const metadataKeysDtos = defaultDecryptedSharedMetadataKeysDtos();
+      const metadataKeys = new MetadataKeysCollection(metadataKeysDtos);
+      const collectionDto = defaultSharedResourcesWithEncryptedMetadataDtos(10, {
+        metadata_key_id: metadataKeysDtos[0].id
+      });
+      const body = {
+        errors: {
+          resources: {
+            sole_owner: collectionDto
+          }
+        }
+      };
+
+      fetch.doMockOnceIf(new RegExp(`/users/${userDto.id}.json`), () => mockApiResponseError(400, "Need transfer", body));
+
+      const controller = new DeleteUserController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.decryptMetadataService.getOrFindMetadataKeysService, "getOrFindAll").mockImplementation(() => metadataKeys);
+      jest.spyOn(controller.getPassphraseService, "getPassphrase").mockImplementationOnce(() => pgpKeys.ada.passphrase);
+      jest.spyOn(UserLocalStorage, "delete");
+
+      try {
+        await controller.exec(userDto.id);
+      } catch (error) {
+        expect(error).toBeInstanceOf(DeleteDryRunError);
+        expect(error.errors.resources.sole_owner.items.every(resourceEntity => resourceEntity.isMetadataDecrypted())).toBeTruthy();
+        expect(UserLocalStorage.delete).not.toHaveBeenCalledWith(userDto.id);
+      }
+    });
+
+    it("Should throw an error if the user has transfer without decryption", async() => {
+      expect.assertions(5);
+
+      const userDto = defaultUserDto();
+      await UserLocalStorage.set(new UsersCollection([userDto]));
+      const collectionDto = defaultResourcesDtos();
+      const body = {
+        errors: {
+          resources: {
+            sole_owner: collectionDto
+          }
+        }
+      };
+
+      fetch.doMockOnceIf(new RegExp(`/users/${userDto.id}.json`), () => mockApiResponseError(400, "Need transfer", body));
+
+      const controller = new DeleteUserController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.decryptMetadataService.getOrFindMetadataKeysService, "getOrFindAll");
+      jest.spyOn(controller.getPassphraseService, "getPassphrase");
+      jest.spyOn(UserLocalStorage, "delete");
+
+      try {
+        await controller.exec(userDto.id);
+      } catch (error) {
+        expect(error).toBeInstanceOf(DeleteDryRunError);
+        expect(error.errors.resources.sole_owner.items.every(resourceEntity => resourceEntity.isMetadataDecrypted())).toBeTruthy();
+        expect(controller.decryptMetadataService.getOrFindMetadataKeysService.getOrFindAll).not.toHaveBeenCalled();
+        expect(controller.getPassphraseService.getPassphrase).not.toHaveBeenCalled();
+        expect(UserLocalStorage.delete).not.toHaveBeenCalledWith(userDto.id);
+      }
+    });
+
+    it("Should throw an error if something wrong happens on the API", async() => {
+      expect.assertions(1);
+
+      const userId = uuidv4();
+      fetch.doMockOnceIf(new RegExp(`/users/${userId}.json`), async() => mockApiResponseError(500, "Something went wrong"));
+
+      const controller = new DeleteUserController(null, null, defaultApiClientOptions(), account);
+      try {
+        await controller.exec(userId);
+      } catch (e) {
+        expect(e).toBeInstanceOf(PassboltApiFetchError);
+      }
+    });
+  });
+});

package/src/all/background_page/event/actionLogEvents.js

@@ -10,14 +10,14 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-import ActionLogModel from "../model/actionLog/actionLogModel";
+import FindAllForActionLogController from "./findAllForActionLogController";
 
 /**
  * Listens to the action logs events
  * @param {Worker} worker The worker
  * @param {ApiClientOptions} apiClientOptions The api client options
  */
-const listen = function(worker, apiClientOptions) {
+const listen = function(worker, apiClientOptions, account) {
   /*
    * Find all action logs for a given instance
    *
@@ -25,16 +25,9 @@ const listen = function(worker, apiClientOptions) {
    * @param requestId {uuid} The request identifier
    * @param options {object} The options to apply to the find
    */
-  worker.port.on('passbolt.actionlogs.find-all-for', async(requestId, foreignModel, foreignId, options) => {
-    try {
-      const actionLogModel = new ActionLogModel(apiClientOptions);
-      const {limit, page} = options;
-      const actionLogs = await actionLogModel.findAllFor(foreignModel, foreignId, page, limit);
-      worker.port.emit(requestId, 'SUCCESS', actionLogs);
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.actionlogs.find-all-for', async(requestId, foreignModel, foreignId, {page, limit}) => {
+    const controller = new FindAllForActionLogController(worker, requestId, apiClientOptions, account);
+    await controller._exec(foreignModel, foreignId, {page, limit});
   });
 };
 

package/src/all/background_page/event/appEvents.js

@@ -67,6 +67,8 @@ import FindMetadataMigrateResourcesController from "../controller/migrateMetadat
 import MigrateMetadataResourcesController from "../controller/migrateMetadata/migrateMetadataResourcesController";
 import DownloadOrganizationGeneratedKey from "../controller/accountRecovery/downloadOrganizationGenerateKeyController";
 import ShareMetadataKeyPrivateController from "../controller/metadata/shareMetadataKeyPrivateController";
+import CopyToClipboardController from "../controller/clipboard/copyToClipboardController";
+import CopyTemporarilyToClipboardController from "../controller/clipboard/copyTemporarilyToClipboardController";
 
 const listen = function(worker, apiClientOptions, account) {
   /*
@@ -433,5 +435,36 @@ const listen = function(worker, apiClientOptions, account) {
     const controller = new ShareMetadataKeyPrivateController(worker, requestId, apiClientOptions, account);
     await controller._exec(userId);
   });
+
+
+  /*
+   * ==================================================================================
+   *  Clipboard events.
+   * ==================================================================================
+   */
+
+  /**
+   * Copies the given content into the clipboard and clear any clipboard flush alarms.
+   *
+   * @listens assbolt.clipboard.copy
+   * @param {string} requestId The request identifier
+   * @param {string} text the content to copy
+   */
+  worker.port.on('passbolt.clipboard.copy', async(requestId, text) => {
+    const clipboardController = new CopyToClipboardController(worker, requestId);
+    await clipboardController._exec(text);
+  });
+
+  /**
+   * Copies temporarily the given content into the clipboard and set a clipboard flush alarm.
+   *
+   * @listens assbolt.clipboard.copy-temporarily
+   * @param {string} requestId The request identifier
+   * @param {string} text the content to copy
+   */
+  worker.port.on('passbolt.clipboard.copy-temporarily', async(requestId, text) => {
+    const clipboardController = new CopyTemporarilyToClipboardController(worker, requestId);
+    await clipboardController._exec(text);
+  });
 };
 export const AppEvents = {listen};

package/src/all/background_page/event/findAllForActionLogController.js

@@ -0,0 +1,58 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         5.4.0
+ */
+import FindActionLogService from "../model/actionLog/findActionLogService";
+
+class FindAllForActionLogController {
+  /**
+   * @constructor
+   * @param {Worker} worker The worker
+   * @param {string} requestId uuid
+   * @param {ApiClientOptions} apiClientOptions The api client options
+   * @param {AccountEntity} account the user account
+   */
+  constructor(worker, requestId, apiClientOptions, account) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.findAllForActionLogService = new FindActionLogService(apiClientOptions, account);
+  }
+
+  /**
+   * Controller executor.
+   * @param {string} foreignModel The foreign model
+   * @param {string} foreignId The foreign ID
+   * @param {object} options Options
+   * @param {number} options.page The page number
+   * @param {number} options.limit The limit of activities per page
+   * @returns {Promise<void>}
+   */
+  async _exec(foreignModel, foreignId, {page, limit}) {
+    try {
+      const result = await this.exec(foreignModel, foreignId, {page, limit});
+      this.worker.port.emit(this.requestId, 'SUCCESS', result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Find all action logs
+   * @returns {Promise<*>}
+   */
+  async exec(foreignModel, foreignId, {page, limit}) {
+    return this.findAllForActionLogService.findAllFor(foreignModel, foreignId, page, limit);
+  }
+}
+
+export default FindAllForActionLogController;