passbolt-browser-extension 5.12.1 → 5.13.0

package/src/all/background_page/controller/share/findFoldersForShareController.test.js

@@ -0,0 +1,70 @@
+/**
+ * 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.13.0
+ */
+
+import FindFoldersForShareController from "./findFoldersForShareController";
+import FindFoldersService from "../../service/folder/findFoldersService";
+import FoldersCollection from "../../model/entity/folder/foldersCollection";
+import FolderService from "../../service/api/folder/folderService";
+import { defaultFolderDto } from "passbolt-styleguide/src/shared/models/entity/folder/folderEntity.test.data";
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import { enableFetchMocks } from "jest-fetch-mock";
+import { mockApiResponse } from "../../../../../test/mocks/mockApiResponse";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  enableFetchMocks();
+});
+
+describe("FindFoldersForShareController", () => {
+  describe("FindFoldersForShareController::exec", () => {
+    it("requests the API with permission + permissions.user.profile + permissions.group contains and returns a FoldersCollection", async () => {
+      expect.assertions(6);
+
+      const folderDto1 = defaultFolderDto();
+      const folderDto2 = defaultFolderDto();
+      const serverResponseDto = [folderDto1, folderDto2];
+      const foldersIds = [folderDto1.id, folderDto2.id];
+
+      fetch.doMockOnceIf(/folders\.json/, async (request) => {
+        const url = new URL(request.url);
+        expect(url.searchParams.getAll("filter[has-id][]")).toStrictEqual(foldersIds);
+        expect(url.searchParams.get("contain[permission]")).toStrictEqual("1");
+        expect(url.searchParams.get("contain[permissions.user.profile]")).toStrictEqual("1");
+        expect(url.searchParams.get("contain[permissions.group]")).toStrictEqual("1");
+        return await mockApiResponse(serverResponseDto);
+      });
+
+      const controller = new FindFoldersForShareController(null, null, defaultApiClientOptions());
+      const result = await controller.exec(foldersIds);
+
+      expect(result).toBeInstanceOf(FoldersCollection);
+      expect(result).toStrictEqual(new FoldersCollection(serverResponseDto));
+    });
+
+    it("rejects with a TypeError when foldersIds is not an array of UUIDs", async () => {
+      expect.assertions(1);
+      const controller = new FindFoldersForShareController(null, null, defaultApiClientOptions());
+      await expect(controller.exec(["not-a-uuid"])).rejects.toThrow(TypeError);
+    });
+  });
+
+  describe("FindFoldersForShareController::constructor", () => {
+    it("instantiates a FindFoldersService backed by a FolderService", () => {
+      expect.assertions(2);
+      const controller = new FindFoldersForShareController(null, null, defaultApiClientOptions());
+      expect(controller.findFoldersService).toBeInstanceOf(FindFoldersService);
+      expect(controller.findFoldersService.folderService).toBeInstanceOf(FolderService);
+    });
+  });
+});

package/src/all/background_page/controller/share/searchUsersAndGroupsController.js

@@ -12,12 +12,12 @@
  * @since         4.9.0
  */
 
-import ShareModel from "../../model/share/shareModel";
+import SearchUsersAndGroupsService from "../../service/share/searchUsersAndGroupsService";
 import { assertString } from "../../utils/assertions";
 
 class SearchUsersAndGroupsController {
   /**
-   * DeleteLocalSsoKitController constructor
+   * SearchUsersAndGroupsController constructor
    * @param {Worker} worker
    * @param {string} requestId uuid
    * @param {ApiClientOptions} apiClientOptions
@@ -25,7 +25,7 @@ class SearchUsersAndGroupsController {
   constructor(worker, requestId, apiClientOptions) {
     this.worker = worker;
     this.requestId = requestId;
-    this.shareModel = new ShareModel(apiClientOptions);
+    this.searchUsersAndGroupsService = new SearchUsersAndGroupsService(apiClientOptions);
   }
 
   /**
@@ -51,7 +51,7 @@ class SearchUsersAndGroupsController {
    */
   async exec(keyword) {
     assertString(keyword, "keyword is not a valid string");
-    return await this.shareModel.search(keyword);
+    return await this.searchUsersAndGroupsService.search(keyword);
   }
 }
 

package/src/all/background_page/controller/share/searchUsersAndGroupsController.test.js

@@ -19,49 +19,34 @@ import {
   defaultGroupSearchResultDto,
 } from "../../model/entity/userAndGroupSearchResultEntity/userAndGroupSearchResultEntity.test.data";
 import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
-import { enableFetchMocks } from "jest-fetch-mock";
-import { mockApiResponse } from "../../../../../test/mocks/mockApiResponse";
-
-jest.mock("../../service/progress/progressService");
-jest.mock("../../service/passphrase/getPassphraseService");
 
 beforeEach(() => {
   jest.clearAllMocks();
-  enableFetchMocks();
 });
 
 describe("SearchUsersAndGroupsController", () => {
   describe("SearchUsersAndGroupsController::exec", () => {
-    it("Request the API the right way and returns the a collection", async () => {
-      expect.assertions(5);
+    it("should delegate to SearchUsersAndGroupsService and return the result", async () => {
+      expect.assertions(3);
 
       const serverResponseDto = [defaultUserSearchResultDto(), defaultGroupSearchResultDto()];
-
+      const expectedResult = new UserAndGroupSearchResultsCollection(serverResponseDto);
       const searchedKeyword = "test";
 
-      fetch.doMockOnceIf(/share\/search-aros\.json/, async (request) => {
-        const url = new URL(request.url);
-        expect(url.searchParams.get("filter[search]")).toStrictEqual(searchedKeyword);
-        expect(url.searchParams.get("contain[profile]")).toStrictEqual("1");
-        expect(url.searchParams.get("contain[user_count]")).toStrictEqual("1");
-        return await mockApiResponse(serverResponseDto);
-      });
+      const controller = new SearchUsersAndGroupsController(null, null, defaultApiClientOptions());
+      jest.spyOn(controller.searchUsersAndGroupsService, "search").mockResolvedValue(expectedResult);
 
-      const apiClientOptions = defaultApiClientOptions();
-      const controller = new SearchUsersAndGroupsController(null, null, apiClientOptions);
       const result = await controller.exec(searchedKeyword);
 
-      const expectedResult = new UserAndGroupSearchResultsCollection(serverResponseDto);
-
-      expect(result).toBeInstanceOf(UserAndGroupSearchResultsCollection);
+      expect(controller.searchUsersAndGroupsService.search).toHaveBeenCalledTimes(1);
+      expect(controller.searchUsersAndGroupsService.search).toHaveBeenCalledWith(searchedKeyword);
       expect(result).toStrictEqual(expectedResult);
     });
 
     it("should throw an error if the keyword is not a valid string", async () => {
       expect.assertions(1);
 
-      const apiClientOptions = defaultApiClientOptions();
-      const controller = new SearchUsersAndGroupsController(null, null, apiClientOptions);
+      const controller = new SearchUsersAndGroupsController(null, null, defaultApiClientOptions());
 
       try {
         await controller.exec(1);

package/src/all/background_page/controller/share/shareResourcesController.test.js

@@ -89,7 +89,7 @@ describe("ShareResourcesController", () => {
         .mockImplementation(() => new ResourceTypesCollection(resourceTypesCollectionDto()));
       // Mock request simulating the share.
       jest
-        .spyOn(controller.shareResourceService.shareService, "simulateShareResource")
+        .spyOn(controller.shareResourceService.shareApiService, "simulateShareResource")
         .mockImplementation(() => simulateShareSecretsChangesDto([pgpKeys.carol.userId], []));
       // Mock find all for share.
       const secretDto = plaintextSecretPasswordAndDescriptionDto();
@@ -111,7 +111,7 @@ describe("ShareResourcesController", () => {
       // Mock the share request.
       let shareRequestData;
       jest
-        .spyOn(controller.shareResourceService.shareService, "shareResource")
+        .spyOn(controller.shareResourceService.shareApiService, "shareResource")
         .mockImplementation((resourceId, data) => {
           shareRequestData = data;
           return {};

package/src/all/background_page/controller/subscription/createSubscriptionKeyController.js

@@ -0,0 +1,63 @@
+/**
+ * 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.13.0
+ */
+
+import UpdateSubscriptionEntity from "../../model/entity/subscription/update/updateSubscriptionEntity";
+import PostLogoutService from "../../service/auth/postLogoutService";
+import CreateSubscriptionKeyService from "../../service/subscription/createSubscriptionKeyService";
+
+export default class CreateSubscriptionKeyController {
+  /**
+   * @constructor
+   * @param {Worker} worker
+   * @param {string} requestId
+   * @param {ApiClientOptions} apiClientOptions
+   */
+  constructor(worker, requestId, apiClientOptions) {
+    this.worker = worker;
+    this.requestId = requestId;
+
+    this.createSubscriptionService = new CreateSubscriptionKeyService(apiClientOptions);
+  }
+
+  /**
+   * Controller executor
+   * @returns {Promise<void>}
+   */
+  async _exec() {
+    try {
+      const result = await this.exec.apply(this, arguments);
+      this.worker.port.emit(this.requestId, "SUCCESS", result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, "ERROR", error);
+    }
+  }
+
+  /**
+   * Create the subscription key (upgrade CE to PRO).
+   * @param {{ data: string }} subscriptionKeyDto The new subscription key
+   * @returns {Promise<SubscriptionEntity>} The subscription key
+   * @throws {Error} Throws an error when encountering any network error
+   * @throws {ValidationError} Throws an error if subscriptionKeyDto format is incorrect
+   * @throws {PassboltSubscriptionError} Throws `PassboltSubscriptionError` when subscription is already expired or user limit reached
+   */
+  async exec(subscriptionKeyDto) {
+    const subscriptionKeyEntity = new UpdateSubscriptionEntity(subscriptionKeyDto);
+    const subscriptionEntity = await this.createSubscriptionService.create(subscriptionKeyEntity);
+
+    await PostLogoutService.exec();
+
+    return subscriptionEntity;
+  }
+}

package/src/all/background_page/controller/subscription/createSubscriptionKeyController.test.js

@@ -0,0 +1,56 @@
+/**
+ * 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.13.0
+ */
+
+import SubscriptionEntity from "passbolt-styleguide/src/shared/models/entity/subscription/subscriptionEntity";
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import { mockSubscriptionUpdated } from "passbolt-styleguide/src/react-extension/components/Administration/DisplaySubscriptionKey/DisplaySubscriptionKey.test.data";
+
+import CreateSubscriptionKeyController from "./createSubscriptionKeyController";
+import PostLogoutService from "../../service/auth/postLogoutService";
+
+describe("CreateSubscriptionKeyController", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("::exec", () => {
+    it("should create the subscription key and log the user out", async () => {
+      expect.assertions(3);
+
+      const controller = new CreateSubscriptionKeyController(null, null, defaultApiClientOptions());
+      jest
+        .spyOn(controller.createSubscriptionService, "create")
+        .mockResolvedValue(new SubscriptionEntity(mockSubscriptionUpdated));
+      jest.spyOn(PostLogoutService, "exec").mockImplementation(async () => {});
+
+      const result = await controller.exec({ data: mockSubscriptionUpdated.data });
+
+      expect(result).toEqual(new SubscriptionEntity(mockSubscriptionUpdated));
+      expect(controller.createSubscriptionService.create).toHaveBeenCalledTimes(1);
+      expect(PostLogoutService.exec).toHaveBeenCalledTimes(1);
+    });
+
+    it("should not catch errors", async () => {
+      expect.assertions(2);
+
+      const expectedError = new Error("Something went wrong!");
+      const controller = new CreateSubscriptionKeyController(null, null, defaultApiClientOptions());
+      jest.spyOn(controller.createSubscriptionService, "create").mockRejectedValue(expectedError);
+      jest.spyOn(PostLogoutService, "exec").mockImplementation(async () => {});
+
+      await expect(controller.exec({ data: mockSubscriptionUpdated.data })).rejects.toStrictEqual(expectedError);
+      expect(PostLogoutService.exec).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/all/background_page/controller/subscription/deleteSubscriptionKeyController.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.13.0
+ */
+
+import PostLogoutService from "../../service/auth/postLogoutService";
+import DeleteSubscriptionKeyService from "../../service/subscription/deleteSubscriptionKeyService";
+
+export default class DeleteSubscriptionKeyController {
+  /**
+   * @constructor
+   * @param {Worker} worker
+   * @param {string} requestId
+   * @param {ApiClientOptions} apiClientOptions
+   */
+  constructor(worker, requestId, apiClientOptions) {
+    this.worker = worker;
+    this.requestId = requestId;
+
+    this.deleteSubscriptionService = new DeleteSubscriptionKeyService(apiClientOptions);
+  }
+
+  /**
+   * Controller executor
+   * @returns Promise<void>
+   */
+  async _exec() {
+    try {
+      const result = await this.exec.apply(this, arguments);
+      this.worker.port.emit(this.requestId, "SUCCESS", result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, "ERROR", error);
+    }
+  }
+
+  /**
+   * Delete the subscription key (downgrade PRO to CE).
+   * @returns {Promise<void>}
+   * @throws {Error} Throws an error when encountering any network or server error
+   */
+  async exec() {
+    await this.deleteSubscriptionService.delete();
+    await PostLogoutService.exec();
+  }
+}

package/src/all/background_page/controller/subscription/deleteSubscriptionKeyController.test.js

@@ -0,0 +1,50 @@
+/**
+ * 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.13.0
+ */
+
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+
+import DeleteSubscriptionKeyController from "./deleteSubscriptionKeyController";
+import PostLogoutService from "../../service/auth/postLogoutService";
+
+describe("DeleteSubscriptionKeyController", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("::exec", () => {
+    it("should delete the subscription key and log the user out", async () => {
+      expect.assertions(3);
+
+      const controller = new DeleteSubscriptionKeyController(null, null, defaultApiClientOptions());
+      jest.spyOn(controller.deleteSubscriptionService, "delete").mockResolvedValue(undefined);
+      jest.spyOn(PostLogoutService, "exec").mockImplementation(async () => {});
+
+      await expect(controller.exec()).resolves.toBeUndefined();
+      expect(controller.deleteSubscriptionService.delete).toHaveBeenCalledTimes(1);
+      expect(PostLogoutService.exec).toHaveBeenCalledTimes(1);
+    });
+
+    it("should not catch errors", async () => {
+      expect.assertions(2);
+
+      const expectedError = new Error("Something went wrong!");
+      const controller = new DeleteSubscriptionKeyController(null, null, defaultApiClientOptions());
+      jest.spyOn(controller.deleteSubscriptionService, "delete").mockRejectedValue(expectedError);
+      jest.spyOn(PostLogoutService, "exec").mockImplementation(async () => {});
+
+      await expect(controller.exec()).rejects.toStrictEqual(expectedError);
+      expect(PostLogoutService.exec).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -31,7 +31,7 @@ import MetadataKeysCollection from "passbolt-styleguide/src/shared/models/entity
 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";
+import UsersCollection from "passbolt-styleguide/src/shared/models/entity/user/usersCollection";
 
 beforeEach(() => {
   enableFetchMocks();

package/src/all/background_page/controller/user/getOrFindUsersController.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.13.0
+ */
+import GetOrFindUsersService from "../../service/user/getOrFindUsersService";
+import { assertArrayUUID } from "../../utils/assertions";
+
+/**
+ * Controller for the `passbolt.users.get-by-ids` event. Returns the users matching the given ids,
+ * served from the local storage cache when available and otherwise fetched from the API.
+ */
+class GetOrFindUsersController {
+  /**
+   * Constructor.
+   * @param {Worker} worker The associated worker.
+   * @param {string} requestId The associated request id.
+   * @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.getOrFindUsersService = new GetOrFindUsersService(account, apiClientOptions);
+  }
+
+  /**
+   * Controller executor.
+   * @param {Array<string>} userIds The ids of the users to retrieve.
+   * @returns {Promise<void>}
+   */
+  async _exec(userIds) {
+    try {
+      const result = await this.exec(userIds);
+      this.worker.port.emit(this.requestId, "SUCCESS", result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, "ERROR", error);
+    }
+  }
+
+  /**
+   * Find all the users matching the given ids.
+   * @param {Array<string>} userIds The ids of the users to retrieve.
+   * @returns {Promise<UsersCollection>}
+   */
+  async exec(userIds) {
+    assertArrayUUID(userIds);
+    return this.getOrFindUsersService.getOrFindByIds(userIds);
+  }
+}
+
+export default GetOrFindUsersController;

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

@@ -0,0 +1,69 @@
+/**
+ * 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.13.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 GetOrFindUsersController from "./getOrFindUsersController";
+import UsersCollection from "passbolt-styleguide/src/shared/models/entity/user/usersCollection";
+import { defaultUsersDtos } from "passbolt-styleguide/src/shared/models/entity/user/usersCollection.test.data";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("GetOrFindUsersController", () => {
+  describe("::exec", () => {
+    it("Should retrieve the users matching the given ids.", async () => {
+      expect.assertions(3);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const usersDto = defaultUsersDtos();
+      const usersCollection = new UsersCollection(usersDto);
+      const requestedIds = [usersDto[1].id, usersDto[3].id];
+      const controller = new GetOrFindUsersController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.getOrFindUsersService, "getOrFindByIds").mockImplementation(() => usersCollection);
+
+      const result = await controller.exec(requestedIds);
+
+      expect(result).toBeInstanceOf(UsersCollection);
+      expect(result).toStrictEqual(usersCollection);
+      expect(controller.getOrFindUsersService.getOrFindByIds).toHaveBeenCalledWith(requestedIds);
+    });
+
+    it("Should let error been thrown from the service if any.", async () => {
+      expect.assertions(1);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const controller = new GetOrFindUsersController(null, null, defaultApiClientOptions(), account);
+      const requestedIds = [defaultUsersDtos()[0].id];
+      jest.spyOn(controller.getOrFindUsersService, "getOrFindByIds").mockImplementation(() => {
+        throw new Error("Something went wrong!");
+      });
+
+      await expect(() => controller.exec(requestedIds)).rejects.toThrow();
+    });
+
+    it("Should assert its parameter.", async () => {
+      expect.assertions(1);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const controller = new GetOrFindUsersController(null, null, defaultApiClientOptions(), account);
+
+      await expect(() => controller.exec(["not-a-uuid"])).rejects.toThrow(
+        "The given parameter is not a valid array of uuid",
+      );
+    });
+  });
+});

package/src/all/background_page/error/deleteDryRunError.js

@@ -11,7 +11,7 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         3.0.0
  */
-import GroupsCollection from "../model/entity/group/groupsCollection";
+import GroupsCollection from "passbolt-styleguide/src/shared/models/entity/group/groupsCollection";
 import ResourcesCollection from "../model/entity/resource/resourcesCollection";
 import FoldersCollection from "../model/entity/folder/foldersCollection";
 import "./error.js";

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

@@ -10,7 +10,7 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-import FindAllForActionLogController from "./findAllForActionLogController";
+import FindAllForActionLogController from "../controller/actionLog/findAllForActionLogController";
 
 /**
  * Listens to the action logs events

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

@@ -73,6 +73,8 @@ import FindResourceSecretRevisionsForDisplayController from "../controller/secre
 import DeleteSecretRevisionsSettingsController from "../controller/secretRevision/deleteSecretRevisionsSettingsController";
 import SaveSecretRevisionsSettingsController from "../controller/secretRevision/saveSecretRevisionsSettingsController";
 import FindExportPoliciesSettingsController from "../controller/exportPolicies/findExportPoliciesSettingsController";
+import CreateSubscriptionKeyController from "../controller/subscription/createSubscriptionKeyController";
+import DeleteSubscriptionKeyController from "../controller/subscription/deleteSubscriptionKeyController";
 import FindSubscriptionKeyController from "../controller/subscription/findSubscriptionKeyController";
 import UpdateSubscriptionKeyController from "../controller/subscription/updateSubscriptionKeyController";
 import FindTagsController from "../controller/tag/findTagsController";
@@ -771,6 +773,29 @@ const listen = function (worker, apiClientOptions, account) {
     await subscriptionController._exec(subscriptionKeyDto);
   });
 
+  /**
+   * Create the subscription key (upgrade CE to PRO).
+   *
+   * @listens passbolt.subscription.create
+   * @param requestId {uuid} The request identifier
+   * @param subscriptionKeyDto {{ data: string }} The new subscription key
+   */
+  worker.port.on("passbolt.subscription.create", async (requestId, subscriptionKeyDto) => {
+    const subscriptionController = new CreateSubscriptionKeyController(worker, requestId, apiClientOptions);
+    await subscriptionController._exec(subscriptionKeyDto);
+  });
+
+  /**
+   * Delete the subscription (downgrade PRO to CE).
+   *
+   * @listens passbolt.subscription.downgrade
+   * @param requestId {uuid} The request identifier
+   */
+  worker.port.on("passbolt.subscription.downgrade", async (requestId) => {
+    const subscriptionController = new DeleteSubscriptionKeyController(worker, requestId, apiClientOptions);
+    await subscriptionController._exec();
+  });
+
   /**
    * Find all the tags
    *

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

@@ -16,6 +16,8 @@ import GroupsUpdateController from "../controller/group/groupUpdateController";
 import GroupCreateController from "../controller/group/groupCreateController";
 import GroupDeleteTransferEntity from "../model/entity/group/transfer/groupDeleteTransferEntity";
 import FindMyGroupsController from "../controller/group/findMyGroupsController";
+import GetOrFindGroupsController from "../controller/group/getOrFindGroupsController";
+import GetOrFindGroupsUsersController from "../controller/group/getOrFindGroupsUsersController";
 import UpdateAllGroupsLocalStorageController from "../controller/group/updateAllGroupsLocalStorageController";
 
 /**
@@ -48,6 +50,30 @@ const listen = function (worker, apiClientOptions, account) {
     controller._exec();
   });
 
+  /*
+   * Find groups by their ids.
+   *
+   * @listens passbolt.groups.get-by-ids
+   * @param {uuid} requestId The request identifier
+   * @param {Array<uuid>} groupIds The ids of the groups to retrieve
+   */
+  worker.port.on("passbolt.groups.get-by-ids", async (requestId, groupIds) => {
+    const controller = new GetOrFindGroupsController(worker, requestId, apiClientOptions, account);
+    controller._exec(groupIds);
+  });
+
+  /*
+   * Find the members of a group given its id.
+   *
+   * @listens passbolt.groups_users.get-by-group-id
+   * @param {uuid} requestId The request identifier
+   * @param {uuid} groupId The id of the group whose members are requested
+   */
+  worker.port.on("passbolt.groups_users.get-by-group-id", async (requestId, groupId) => {
+    const controller = new GetOrFindGroupsUsersController(worker, requestId, apiClientOptions, account);
+    controller._exec(groupId);
+  });
+
   /*
    * ==================================================================================
    *  CRUD