passbolt-browser-extension 5.3.0 → 5.3.2

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

@@ -0,0 +1,43 @@
+/**
+ * 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 FindAllForActionLogController from "./findAllForActionLogController";
+import {defaultActionLogsCollection} from "../model/entity/actionLog/actionLogsCollection.test.data";
+import ActionLogsCollection from "../model/entity/actionLog/actionLogsCollection";
+import {v4 as uuid} from "uuid";
+
+describe("FindAllForActionLogController", () => {
+  let controller, account, apiClientOptions;
+
+  beforeEach(async() => {
+    account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = defaultApiClientOptions();
+    controller = new FindAllForActionLogController(null, null, apiClientOptions, account);
+  });
+
+  describe("FindAllForActionLogController::exec", () => {
+    it("Find all action logs for the resource", async() => {
+      expect.assertions(2);
+
+      const actionLogsDto = defaultActionLogsCollection;
+      jest.spyOn(controller.findAllForActionLogService, "findAllFor").mockImplementationOnce(() => new ActionLogsCollection(actionLogsDto));
+
+      const actionLogsCollection = await controller.exec("Resource", uuid(), {page: 1, limit: 5});
+      expect(actionLogsCollection).toBeInstanceOf(ActionLogsCollection);
+      expect(actionLogsCollection.toDto()).toEqual(actionLogsDto);
+    });
+  });
+});

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

@@ -13,6 +13,8 @@ import GetOrFindPasswordPoliciesController from "../controller/passwordPolicies/
 import AutofillController from "../controller/autofill/AutofillController";
 import GetOrFindPasswordExpirySettingsController from "../controller/passwordExpiry/getOrFindPasswordExpirySettingsController";
 import GetOrFindMetadataTypesController from "../controller/metadata/getMetadataTypesSettingsController";
+import CopyToClipboardController from "../controller/clipboard/copyToClipboardController";
+import CopyTemporarilyToClipboardController from "../controller/clipboard/copyTemporarilyToClipboardController";
 
 /**
  * Listens to the quickaccess application events
@@ -158,6 +160,36 @@ const listen = function(worker, apiClientOptions, account) {
     const controller = new GetOrFindMetadataTypesController(worker, requestId, apiClientOptions, account);
     await controller._exec();
   });
+
+  /*
+   * ==================================================================================
+   *  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 QuickAccessEvents = {listen};

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

@@ -9,13 +9,14 @@
 import UserModel from "../model/user/userModel";
 import AccountModel from "../model/account/accountModel";
 import UpdatePrivateKeyController from "../controller/account/updatePrivateKeyController";
-import UserDeleteTransferEntity from "../model/entity/user/transfer/userDeleteTransferEntity";
 import UserEntity from "../model/entity/user/userEntity";
 import SecurityTokenEntity from "../model/entity/securityToken/securityTokenEntity";
 import AvatarUpdateEntity from "../model/entity/avatar/update/avatarUpdateEntity";
 import UpdateUserLocalStorageController from "../controller/user/updateUserLocalStorageController";
 import GetOrFindLoggedInUserController from "../controller/user/getOrFindLoggedInUserController";
 import UpdateUserController from "../controller/user/updateUserController";
+import DeleteDryRunUserController from "../controller/user/deleteDryRunUserController";
+import DeleteUserController from "../controller/user/deleteUserController";
 
 /**
  * Listens the user events
@@ -154,16 +155,9 @@ const listen = function(worker, apiClientOptions, account) {
    * @param {string} requestId The request identifier uuid
    * @param {string} userId The user uuid
    */
-  worker.port.on('passbolt.users.delete-dry-run', async(requestId, userId, transferDto) => {
-    try {
-      const userModel = new UserModel(apiClientOptions, account);
-      const transferEntity = transferDto ? new UserDeleteTransferEntity(transferDto) : null;
-      await userModel.deleteDryRun(userId, transferEntity);
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.users.delete-dry-run', async(requestId, userId) => {
+    const controller = new DeleteDryRunUserController(worker, requestId, apiClientOptions, account);
+    await controller._exec(userId);
   });
 
   /*
@@ -174,15 +168,8 @@ const listen = function(worker, apiClientOptions, account) {
    * @param {object} [transferDto] optional data ownership transfer
    */
   worker.port.on('passbolt.users.delete', async(requestId, userId, transferDto) => {
-    try {
-      const userModel = new UserModel(apiClientOptions, account);
-      const transferEntity = transferDto ? new UserDeleteTransferEntity(transferDto) : null;
-      await userModel.delete(userId, transferEntity);
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+    const controller = new DeleteUserController(worker, requestId, apiClientOptions, account);
+    await controller._exec(userId, transferDto);
   });
 
   /*

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

@@ -12,6 +12,7 @@
  */
 import WebIntegrationController from "../controller/webIntegration/webIntegrationController";
 import RemovePortController from "../controller/port/removePortController";
+import CancelClipboardContentFlushController from "../controller/clipboard/cancelClipboardContentFlushController";
 
 /**
  * Listens the web integration events
@@ -33,6 +34,16 @@ const listen = function(worker) {
     const removePortController = new RemovePortController(worker);
     await removePortController._exec(applicationName);
   });
+
+  /*
+   * Whenever a cut or a copy event happens on a web page to ensure the clipboard flush alarm is not triggered
+   * @listens passbolt.clipboard.cancel-content-flush
+   * @param requestId {uuid} The request identifier
+   */
+  worker.port.on('passbolt.clipboard.cancel-content-flush', async requestId => {
+    const clipboardController = new CancelClipboardContentFlushController(worker, requestId);
+    await clipboardController._exec();
+  });
 };
 
 export const WebIntegrationEvents = {listen};

package/src/all/background_page/model/actionLog/{actionLogModel.js → findActionLogService.js}

@@ -11,9 +11,11 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  */
 import ActionLogsCollection from "../entity/actionLog/actionLogsCollection";
-import ActionLogService from "../../service/api/actionLog/actionLogService";
+import {assertUuid, assertNonEmptyString, assertNumber} from "../../utils/assertions";
+import AbstractActionLogEntity from "../entity/actionLog/abstractActionLogEntity";
+import ActionLogApiService from "../../service/api/actionLog/actionLogApiService";
 
-class ActionLogModel {
+class FindActionLogService {
   /**
    * Constructor
    *
@@ -21,7 +23,7 @@ class ActionLogModel {
    * @public
    */
   constructor(apiClientOptions) {
-    this.actionLogService = new ActionLogService(apiClientOptions);
+    this.actionLogApiService = new ActionLogApiService(apiClientOptions);
   }
 
   /*
@@ -42,9 +44,27 @@ class ActionLogModel {
    * @public
    */
   async findAllFor(foreignModel, foreignId, page, limit) {
-    const actionLogsDto = await this.actionLogService.findAllFor(foreignModel, foreignId, page, limit);
+    this.assertValidForeignModel(foreignModel);
+    assertUuid(foreignId);
+    assertNumber(page);
+    assertNumber(limit);
+    const actionLogsDto = await this.actionLogApiService.findAllFor(foreignModel, foreignId, page, limit);
     return new ActionLogsCollection(actionLogsDto);
   }
+
+  /**
+   * Assert a foreign model name is supported by the API
+   *
+   * @param {string} foreignModel for example 'Resource'
+   * @throw {TypeError} if the name is not a valid string or is not supported
+   * @public
+   */
+  assertValidForeignModel(foreignModel) {
+    assertNonEmptyString(foreignModel, 'ActionLog foreign model should be a valid string.');
+    if (!AbstractActionLogEntity.ALLOWED_FOREIGN_MODELS.includes(foreignModel)) {
+      throw new TypeError(`ActionLog foreign model ${foreignModel} is not in the list of supported models.`);
+    }
+  }
 }
 
-export default ActionLogModel;
+export default FindActionLogService;

package/src/all/background_page/model/actionLog/findActionLogService.test.js

@@ -0,0 +1,61 @@
+/**
+ * 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 BuildApiClientOptionsService from "../../service/account/buildApiClientOptionsService";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import {v4 as uuidv4} from "uuid";
+import {enableFetchMocks} from "jest-fetch-mock";
+import ActionLogApiService from "../../service/api/actionLog/actionLogApiService";
+import FindActionLogService from "./findActionLogService";
+import {defaultActionLogsCollection} from "../../model/entity/actionLog/actionLogsCollection.test.data";
+
+describe("FindActionLogService", () => {
+  let apiClientOptions, account,
+    service;
+
+  beforeEach(async() => {
+    enableFetchMocks();
+    jest.clearAllMocks();
+    fetch.resetMocks();
+    account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+    service = new FindActionLogService(apiClientOptions, account);
+  });
+
+  describe('::findAllFor', () => {
+    it("Should call the actionLog service API to get the acitonlog collection", async() => {
+      expect.assertions(1);
+      const foreignId = uuidv4();
+      const actionLogsDto = defaultActionLogsCollection;
+
+      jest.spyOn(ActionLogApiService.prototype, "findAllFor").mockImplementation(() => actionLogsDto);
+
+      const actionLogs = await service.findAllFor("Resource", foreignId, 1, 5);
+      expect(actionLogs).toHaveLength(actionLogsDto.length);
+    });
+
+    it("should throw an error if id is not defined", async() => {
+      expect.assertions(1);
+      const promise = service.findAllFor({unknown: true});
+      await expect(promise).rejects.toThrowError("ActionLog foreign model should be a valid string.");
+    });
+
+    it("should throw an error if foreign model is unsupported", async() => {
+      expect.assertions(1);
+      const foreignId = uuidv4();
+      const promise = service.findAllFor("ChangeTheme", foreignId, 1, 5);
+      await expect(promise).rejects.toThrowError("ActionLog foreign model ChangeTheme is not in the list of supported models.");
+    });
+  });
+});

package/src/all/background_page/model/comment/commentModel.js

@@ -13,7 +13,7 @@
  */
 import CommentEntity from "../entity/comment/commentEntity";
 import CommentsCollection from "../entity/comment/commentsCollection";
-import CommentService from "../../service/api/comment/commentService";
+import CommentApiService from "../../service/api/comment/commentApiService";
 
 class CommentModel {
   /**
@@ -23,7 +23,7 @@ class CommentModel {
    * @public
    */
   constructor(apiClientOptions) {
-    this.commentService = new CommentService(apiClientOptions);
+    this.commentApiService = new CommentApiService(apiClientOptions);
   }
 
   /**
@@ -35,7 +35,7 @@ class CommentModel {
    */
   async findAllByResourceId(resourceId) {
     const foreignKey = 'Resource';
-    const commentsDtos = await this.commentService.findAll(foreignKey, resourceId, {creator: true, modifier: false});
+    const commentsDtos = await this.commentApiService.findAll(foreignKey, resourceId, {creator: true, modifier: false});
     return new CommentsCollection(commentsDtos);
   }
 
@@ -46,7 +46,7 @@ class CommentModel {
    * @returns {Promise<CommentEntity>}
    */
   async create(commentEntity) {
-    const commentDto = await this.commentService.create(commentEntity.toDto({creator: false, modifier: false}));
+    const commentDto = await this.commentApiService.create(commentEntity.toDto({creator: false, modifier: false}));
     return new CommentEntity(commentDto);
   }
 
@@ -57,7 +57,7 @@ class CommentModel {
    * @returns {Promise<void>}
    */
   async delete(commentId) {
-    await this.commentService.delete(commentId);
+    await this.commentApiService.delete(commentId);
   }
 }
 

package/src/all/background_page/model/entity/actionLog/actionLogsCollection.test.data.js

@@ -0,0 +1,18 @@
+/**
+ * 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 {defaultData} from "./defaultActionLogEntity.test.data";
+
+export const defaultActionLogsCollection = [
+  defaultData
+];

package/src/all/background_page/model/entity/actionLog/defaultActionLogEntity.test.data.js

@@ -0,0 +1,34 @@
+/**
+ * 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 {v4 as uuidv4} from "uuid";
+
+export const defaultData = {
+  "id": uuidv4(),
+  "action_log_id": uuidv4(),
+  "type": "Resources.created",
+  "creator": {
+    "id": uuidv4(),
+    "username": "ada@passbolt.com",
+    "profile": {
+      "first_name": "Ada",
+      "last_name": "Lovelace",
+      "avatar": {
+        "url": {
+          "medium": "img\/public\/Avatar\/22\/47\/85\/50adf80e3534413abdd8e34c9be6d1b6\/50adf80e3534413abdd8e34c9be6d1b6.a99472d5.png",
+          "small": "img\/public\/Avatar\/22\/47\/85\/50adf80e3534413abdd8e34c9be6d1b6\/50adf80e3534413abdd8e34c9be6d1b6.65a0ba70.png"
+        }
+      }
+    },
+  }
+};

package/src/all/background_page/model/import/resources/resourcesKdbxImportParser.test.js

@@ -371,7 +371,6 @@ describe("ResourcesKdbxImportParser", () => {
     const importEntity = new ImportResourcesFileEntity(importDto);
     const parser = new ResourcesKdbxImportParser(importEntity, resourceTypesCollection, metadataTypesSettings);
     await parser.parseImport();
-    console.log(importEntity);
 
     // Assert resources
     expect(importEntity.importResources.items).toHaveLength(2);

package/src/all/background_page/model/user/userModel.js

@@ -12,12 +12,9 @@
  * @since         3.0.0
  */
 import UserLocalStorage from "../../service/local_storage/userLocalStorage";
-import DeleteDryRunError from "../../error/deleteDryRunError";
 import UserService from "../../service/api/user/userService";
-import UserDeleteTransferEntity from "../entity/user/transfer/userDeleteTransferEntity";
 import UserEntity from "../entity/user/userEntity";
 import UsersCollection from "../entity/user/usersCollection";
-import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
 import Validator from "validator";
 import RoleEntity from "passbolt-styleguide/src/shared/models/entity/role/roleEntity";
 import UserMeSessionStorageService from "../../service/sessionStorage/userMeSessionStorageService";
@@ -208,63 +205,6 @@ class UserModel {
     return  new UserEntity(userDto, {ignoreInvalidEntity});
   }
 
-  /**
-   * Check if a user can be deleted
-   *
-   * A user can not be deleted if:
-   * - they are the only owner of a shared resource
-   * - they are the only group manager of a group that owns a shared resource
-   * In such case ownership transfer is required.
-   *
-   * @param {string} userId The user id
-   * @param {UserDeleteTransferEntity} [transfer] optional ownership transfer information if needed
-   * @returns {Promise<void>}
-   * @throws {DeleteDryRunError} if some permissions must be transferred
-   * @public
-   */
-  async deleteDryRun(userId, transfer) {
-    try {
-      const deleteData = (transfer && transfer instanceof UserDeleteTransferEntity) ? transfer.toDto() : {};
-      await this.userService.delete(userId, deleteData, true);
-    } catch (error) {
-      if (error instanceof PassboltApiFetchError && error.data.code === 400 && error.data.body.errors) {
-        /*
-         * recast generic 400 error into a delete dry run error
-         * allowing validation of the returned entities and reuse down the line to transfer permissions
-         */
-        throw new DeleteDryRunError(error.message, error.data.body.errors);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Delete a user and transfer ownership if needed
-   *
-   * @param {string} userId The user id
-   * @param {UserDeleteTransferEntity} [transfer] optional ownership transfer information if needed
-   * @returns {Promise<void>}
-   * @public
-   */
-  async delete(userId, transfer) {
-    try {
-      const deleteData = (transfer && transfer instanceof UserDeleteTransferEntity) ? transfer.toDto() : {};
-      await this.userService.delete(userId, deleteData);
-    } catch (error) {
-      if (error instanceof PassboltApiFetchError && error.data.code === 400 && error.data.body.errors) {
-        /*
-         * recast generic 400 error into a delete dry run error
-         * allowing validation of the returned entities and reuse down the line to transfer permissions
-         */
-        throw new DeleteDryRunError(error.message, error.data.body.errors);
-      }
-      throw error;
-    }
-
-    // Update local storage
-    await UserLocalStorage.delete(userId);
-  }
-
   /**
    * Request help when a user lost its credentials.
    * @param {AbstractAccountEntity} account The account the credentials have been lost for.

package/src/all/background_page/pagemod/appPagemod.js

@@ -39,7 +39,6 @@ import {LocaleEvents} from "../event/localeEvents";
 import {MobileEvents} from "../event/mobileEvents";
 import {PownedPasswordEvents} from '../event/pownedPasswordEvents';
 import {MfaEvents} from "../event/mfaEvents";
-import {ClipboardEvents} from "../event/clipboardEvents";
 import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
 import {RememberMeEvents} from "../event/rememberMeEvents";
 import CheckAuthStatusService from "../service/auth/checkAuthStatusService";
@@ -87,7 +86,6 @@ class App extends Pagemod {
       MobileEvents,
       PownedPasswordEvents,
       MfaEvents,
-      ClipboardEvents,
       RememberMeEvents,
       PermissionEvents,
       AccountEvents

package/src/all/background_page/pagemod/appPagemod.test.js

@@ -38,7 +38,6 @@ import {ThemeEvents} from "../event/themeEvents";
 import {MobileEvents} from "../event/mobileEvents";
 import {PownedPasswordEvents} from '../event/pownedPasswordEvents';
 import {MfaEvents} from "../event/mfaEvents";
-import {ClipboardEvents} from "../event/clipboardEvents";
 import {v4 as uuid} from "uuid";
 import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
 import {enableFetchMocks} from "jest-fetch-mock";
@@ -75,13 +74,12 @@ jest.spyOn(LocaleEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(MobileEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(PownedPasswordEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(MfaEvents, "listen").mockImplementation(jest.fn());
-jest.spyOn(ClipboardEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(RememberMeEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(PermissionEvents, "listen").mockImplementation(jest.fn());
 jest.spyOn(AccountEvents, "listen").mockImplementation(jest.fn());
 
 describe("App", () => {
-  beforeEach(async() => {
+  beforeEach(() => {
     jest.resetModules();
     jest.clearAllMocks();
     enableFetchMocks();
@@ -89,7 +87,7 @@ describe("App", () => {
 
   describe("App::attachEvents", () => {
     it("Should attach events", async() => {
-      expect.assertions(34);
+      expect.assertions(33);
       // data mocked
       const port = {
         _port: {
@@ -137,7 +135,6 @@ describe("App", () => {
       expect(MobileEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
       expect(PownedPasswordEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
       expect(MfaEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
-      expect(ClipboardEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
       expect(RememberMeEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
       expect(PermissionEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
       expect(AccountEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
@@ -168,7 +165,6 @@ describe("App", () => {
         MobileEvents,
         PownedPasswordEvents,
         MfaEvents,
-        ClipboardEvents,
         RememberMeEvents,
         PermissionEvents,
         AccountEvents

package/src/all/background_page/service/alarm/globalAlarmService.js

@@ -13,6 +13,7 @@
  */
 
 import StartLoopAuthSessionCheckService from "../auth/startLoopAuthSessionCheckService";
+import CopyToClipboardService from "../clipboard/copyToClipboardService";
 import KeepSessionAliveService from "../session_storage/keepSessionAliveService";
 import PassphraseStorageService from "../session_storage/passphraseStorageService";
 
@@ -20,6 +21,7 @@ const topLevelAlarmMapping = {
   [StartLoopAuthSessionCheckService.ALARM_NAME]: StartLoopAuthSessionCheckService.handleAuthStatusCheckAlarm,
   [PassphraseStorageService.ALARM_NAME]: PassphraseStorageService.handleFlushEvent,
   [KeepSessionAliveService.ALARM_NAME]: KeepSessionAliveService.handleKeepSessionAlive,
+  [CopyToClipboardService.ALARM_NAME]: CopyToClipboardService.handleClipboardTemporaryContentFlushEvent,
 };
 
 /**

package/src/all/background_page/service/api/actionLog/{actionLogService.js → actionLogApiService.js}

@@ -11,6 +11,7 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  */
 import AbstractActionLogEntity from "../../../model/entity/actionLog/abstractActionLogEntity";
+import {assertUuid, assertNonEmptyString, assertNumber} from "../../../utils/assertions";
 import AbstractService from "../abstract/abstractService";
 
 const RESOURCE_SERVICE_RESOURCE_NAME = 'actionlog';
@@ -76,7 +77,9 @@ class ActionLogService extends AbstractService {
    */
   async findAllFor(foreignModel, foreignId, page, limit) {
     this.assertValidForeignModel(foreignModel);
-    this.assertValidId(foreignId);
+    assertNumber(page);
+    assertNumber(limit);
+    assertUuid(foreignId);
     if (!page || typeof page !== 'number') {
       throw new TypeError(`ActionLog page should be a valid integer.`);
     }
@@ -102,9 +105,7 @@ class ActionLogService extends AbstractService {
    * @public
    */
   assertValidForeignModel(foreignModel) {
-    if (!foreignModel || typeof foreignModel !== 'string') {
-      throw new TypeError(`ActionLog foreign model should be a valid string.`);
-    }
+    assertNonEmptyString(foreignModel, 'ActionLog foreign model should be a valid string.');
     if (!AbstractActionLogEntity.ALLOWED_FOREIGN_MODELS.includes(foreignModel)) {
       throw new TypeError(`ActionLog foreign model ${foreignModel} in not in the list of supported models.`);
     }

package/src/all/background_page/service/api/actionLog/actionLogApiService.test.js

@@ -0,0 +1,55 @@
+/**
+ * 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 {v4 as uuidv4} from "uuid";
+import {mockApiResponse} from '../../../../../../test/mocks/mockApiResponse';
+import ActionLogApiService from "./actionLogApiService";
+import AccountEntity from "../../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../../model/entity/account/accountEntity.test.data";
+import BuildApiClientOptionsService from "../../account/buildApiClientOptionsService";
+import {defaultActionLogsCollection} from "../../../model/entity/actionLog/actionLogsCollection.test.data";
+
+describe("ActionLogService", () => {
+  let apiClientOptions, account;
+  beforeEach(async() => {
+    enableFetchMocks();
+    fetch.resetMocks();
+    account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = BuildApiClientOptionsService.buildFromAccount(account);
+  });
+
+  describe('::findAllFor', () => {
+    it("Retrieves all action logs for a foreign model", async() => {
+      expect.assertions(2);
+
+      const apiResponse = [defaultActionLogsCollection];
+      fetch.doMockOnceIf(/actionlog\/resource/, () => mockApiResponse(apiResponse));
+
+      const service = new ActionLogApiService(apiClientOptions, account);
+      const result = await service.findAllFor("Resource", uuidv4(), 1, 5);
+
+      expect(result).toBeInstanceOf(Array);
+      expect(result).toHaveLength(apiResponse.length);
+    });
+
+    it("throws API error if the API encountered an issue", async() => {
+      expect.assertions(1);
+
+      const service = new ActionLogApiService(apiClientOptions, account);
+
+      await expect(() => service.findAllFor("Resource", uuidv4())).rejects.toThrow(TypeError);
+    });
+  });
+});