passbolt-browser-extension 5.13.0 → 5.14.2

package/src/all/background_page/controller/siteSettings/getOrFindSiteSettingsController.test.js

@@ -0,0 +1,150 @@
+/**
+ * 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         6.0.0
+ */
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
+import { defaultApiClientOptions } from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
+import { defaultProSiteSettings } from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity.test.data";
+import SiteSettingsLocalStorage from "../../service/local_storage/siteSettingsLocalStorage";
+import SiteSettingsRuntimeCache from "../../service/siteSettings/siteSettingsRuntimeCache";
+import GetOrFindSiteSettingsController from "./getOrFindSiteSettingsController";
+import OnlineSessionEntity from "passbolt-styleguide/src/shared/models/entity/session/onlineSessionEntity";
+import CheckAuthStatusService from "../../service/auth/checkAuthStatusService";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  SiteSettingsRuntimeCache.flushAll();
+  SiteSettingsLocalStorage._runtimeCachedData = {};
+});
+
+describe("GetOrFindSiteSettingsController", () => {
+  let account, apiClientOptions, worker;
+
+  beforeEach(() => {
+    account = new AccountEntity(defaultAccountDto());
+    apiClientOptions = defaultApiClientOptions();
+    worker = { port: { emit: jest.fn() } };
+  });
+
+  describe("::exec (default refreshCache=true)", () => {
+    it("fetches from the API and persists when authenticated", async () => {
+      expect.assertions(3);
+      const dto = defaultProSiteSettings();
+      const controller = new GetOrFindSiteSettingsController(worker, "req-1", apiClientOptions, account);
+      jest
+        .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
+        .mockResolvedValue(new OnlineSessionEntity({ is_authenticated: true, is_mfa_authenticated: true }));
+      jest
+        .spyOn(
+          controller.getOrFindSiteSettingsService.findAndUpdateSiteSettingsLocalStorageService.findSiteSettingsService,
+          "findSiteSettings",
+        )
+        .mockResolvedValue(new SiteSettingsEntity(dto));
+      const ls =
+        controller.getOrFindSiteSettingsService.findAndUpdateSiteSettingsLocalStorageService.siteSettingsLocalStorage;
+      await ls.flush();
+
+      const result = await controller.exec();
+
+      expect(result.toDto()).toEqual(dto);
+      expect(SiteSettingsRuntimeCache.get()).toEqual(dto);
+      expect(await ls.get()).toEqual(dto);
+    });
+
+    it("does not persist when not authenticated", async () => {
+      expect.assertions(3);
+      const dto = defaultProSiteSettings();
+      const controller = new GetOrFindSiteSettingsController(worker, "req-1", apiClientOptions, account);
+      jest
+        .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
+        .mockResolvedValue(new OnlineSessionEntity({ is_authenticated: false, is_mfa_authenticated: true }));
+      jest
+        .spyOn(
+          controller.getOrFindSiteSettingsService.findAndUpdateSiteSettingsLocalStorageService.findSiteSettingsService,
+          "findSiteSettings",
+        )
+        .mockResolvedValue(new SiteSettingsEntity(dto));
+      const ls =
+        controller.getOrFindSiteSettingsService.findAndUpdateSiteSettingsLocalStorageService.siteSettingsLocalStorage;
+      await ls.flush();
+
+      const result = await controller.exec();
+
+      expect(result.toDto()).toEqual(dto);
+      expect(SiteSettingsRuntimeCache.get()).toEqual(dto);
+      expect(await ls.get()).toBeUndefined();
+    });
+  });
+
+  describe("::exec (refreshCache=false)", () => {
+    it("returns from the in-memory cache without an API call when populated", async () => {
+      expect.assertions(2);
+      const dto = defaultProSiteSettings();
+      const controller = new GetOrFindSiteSettingsController(worker, "req-1", apiClientOptions, account);
+      SiteSettingsRuntimeCache.set(new SiteSettingsEntity(dto));
+      const apiSpy = jest.spyOn(
+        controller.getOrFindSiteSettingsService.findAndUpdateSiteSettingsLocalStorageService.findSiteSettingsService,
+        "findSiteSettings",
+      );
+
+      const result = await controller.exec(false);
+
+      expect(apiSpy).not.toHaveBeenCalled();
+      expect(result.toDto()).toEqual(dto);
+    });
+
+    it("returns from local storage when authenticated, without an API call", async () => {
+      expect.assertions(2);
+      const dto = defaultProSiteSettings();
+      const controller = new GetOrFindSiteSettingsController(worker, "req-1", apiClientOptions, account);
+      jest
+        .spyOn(CheckAuthStatusService.prototype, "checkAuthStatus")
+        .mockResolvedValue(new OnlineSessionEntity({ is_authenticated: true, is_mfa_authenticated: true }));
+      await controller.getOrFindSiteSettingsService.siteSettingsLocalStorage.set(new SiteSettingsEntity(dto));
+      const apiSpy = jest.spyOn(
+        controller.getOrFindSiteSettingsService.findAndUpdateSiteSettingsLocalStorageService.findSiteSettingsService,
+        "findSiteSettings",
+      );
+
+      const result = await controller.exec(false);
+
+      expect(result.toDto()).toEqual(dto);
+      expect(apiSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("::_exec", () => {
+    it("forwards refreshCache from the port handler through to the service", async () => {
+      expect.assertions(1);
+      const dto = defaultProSiteSettings();
+      const controller = new GetOrFindSiteSettingsController(worker, "req-1", apiClientOptions, account);
+      SiteSettingsRuntimeCache.set(new SiteSettingsEntity(dto));
+      const execSpy = jest.spyOn(controller, "exec");
+
+      await controller._exec(false);
+
+      expect(execSpy).toHaveBeenCalledWith(false);
+    });
+
+    it("emits ERROR when the service throws", async () => {
+      expect.assertions(1);
+      const controller = new GetOrFindSiteSettingsController(worker, "req-1", apiClientOptions, account);
+      jest.spyOn(controller.getOrFindSiteSettingsService, "getOrFind").mockRejectedValue(new Error("boom"));
+
+      await controller._exec();
+
+      expect(worker.port.emit).toHaveBeenCalledWith("req-1", "ERROR", expect.any(Error));
+    });
+  });
+});

package/src/all/background_page/controller/{group/getOrFindGroupsUsersController.js → user/getOrFindAllUsersController.js}

@@ -11,15 +11,13 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         5.13.0
  */
-import GetOrFindGroupsUsersService from "../../service/group/getOrFindGroupsUsersService";
-import { assertUuid } from "../../utils/assertions";
+import GetOrFindUsersService from "../../service/user/getOrFindUsersService";
 
 /**
- * Controller for the `passbolt.groups_users.get-by-group-id` event. Returns the members of the group
- * matching the given id, served from the local storage cache when available and otherwise fetched
- * from the API.
+ * Controller for the `passbolt.users.get-all` event. Returns all the users, served from the local
+ * storage cache when available and otherwise fetched from the API.
  */
-class GetOrFindGroupsUsersController {
+class GetOrFindAllUsersController {
   /**
    * Constructor.
    * @param {Worker} worker The associated worker.
@@ -30,17 +28,16 @@ class GetOrFindGroupsUsersController {
   constructor(worker, requestId, apiClientOptions, account) {
     this.worker = worker;
     this.requestId = requestId;
-    this.getOrFindGroupsUsersService = new GetOrFindGroupsUsersService(account, apiClientOptions);
+    this.getOrFindUsersService = new GetOrFindUsersService(account, apiClientOptions);
   }
 
   /**
    * Controller executor.
-   * @param {string} groupId The id of the group whose members are requested.
    * @returns {Promise<void>}
    */
-  async _exec(groupId) {
+  async _exec() {
     try {
-      const result = await this.exec(groupId);
+      const result = await this.exec();
       this.worker.port.emit(this.requestId, "SUCCESS", result);
     } catch (error) {
       console.error(error);
@@ -49,14 +46,12 @@ class GetOrFindGroupsUsersController {
   }
 
   /**
-   * Find all the members of the group matching the given id.
-   * @param {string} groupId The id of the group whose members are requested.
-   * @returns {Promise<GroupsUsersCollection>}
+   * Get or find all the users.
+   * @returns {Promise<UsersCollection>}
    */
-  async exec(groupId) {
-    assertUuid(groupId);
-    return this.getOrFindGroupsUsersService.getOrFindByGroupId(groupId);
+  async exec() {
+    return this.getOrFindUsersService.getOrFindAll();
   }
 }
 
-export default GetOrFindGroupsUsersController;
+export default GetOrFindAllUsersController;

package/src/all/background_page/controller/user/getOrFindAllUsersController.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.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 GetOrFindAllUsersController from "./getOrFindAllUsersController";
+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("GetOrFindAllUsersController", () => {
+  describe("::exec", () => {
+    it("Should retrieve all the users.", async () => {
+      expect.assertions(3);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const usersCollection = new UsersCollection(defaultUsersDtos());
+      const controller = new GetOrFindAllUsersController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.getOrFindUsersService, "getOrFindAll").mockImplementation(() => usersCollection);
+
+      const result = await controller.exec();
+
+      expect(result).toBeInstanceOf(UsersCollection);
+      expect(result).toStrictEqual(usersCollection);
+      expect(controller.getOrFindUsersService.getOrFindAll).toHaveBeenCalled();
+    });
+
+    it("Should let error been thrown from the service if any.", async () => {
+      expect.assertions(1);
+
+      const account = new AccountEntity(defaultAccountDto());
+      const controller = new GetOrFindAllUsersController(null, null, defaultApiClientOptions(), account);
+      jest.spyOn(controller.getOrFindUsersService, "getOrFindAll").mockImplementation(() => {
+        throw new Error("Something went wrong!");
+      });
+
+      await expect(() => controller.exec()).rejects.toThrow();
+    });
+  });
+});

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

@@ -12,7 +12,7 @@
  * @since         4.1.0
  */
 
-import UserModel from "../../model/user/userModel";
+import GetOrFindMeService from "../../service/user/getOrFindMeService";
 
 class GetOrFindLoggedInUserController {
   /**
@@ -26,7 +26,7 @@ class GetOrFindLoggedInUserController {
     this.worker = worker;
     this.requestId = requestId;
     this.account = account;
-    this.userModel = new UserModel(apiClientOptions, account);
+    this.getOrFindMeService = new GetOrFindMeService(account, apiClientOptions);
   }
 
   /**
@@ -49,7 +49,7 @@ class GetOrFindLoggedInUserController {
    * @return {Promise<UserEntity>}
    */
   async exec(refreshCache = false) {
-    return this.userModel.getOrFindMe(refreshCache);
+    return this.getOrFindMeService.getOrFindMe(refreshCache);
   }
 }
 

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

@@ -20,7 +20,7 @@ import GetOrFindLoggedInUserController from "./getOrFindLoggedInUserController";
 import AccountEntity from "../../model/entity/account/accountEntity";
 import { defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
 import UserEntity from "../../model/entity/user/userEntity";
-import UserMeSessionStorageService from "../../service/sessionStorage/userMeSessionStorageService";
+import UserMeLocalStorage from "../../service/local_storage/userMeLocalStorage";
 
 beforeEach(() => {
   enableFetchMocks();
@@ -32,61 +32,65 @@ describe("GetOrFindLoggedInUserController", () => {
     it("Should find the information and set the cache if cache is empty.", async () => {
       expect.assertions(5);
       const account = new AccountEntity(defaultAccountDto());
-
+      const storage = new UserMeLocalStorage(account);
       const mockApiResult = defaultUserDto();
       fetch.doMock(() => mockApiResponse(mockApiResult));
 
-      expect(await UserMeSessionStorageService.get(account)).toBeNull();
+      expect(await storage.getData()).toBeUndefined();
 
       const controller = new GetOrFindLoggedInUserController(null, null, defaultApiClientOptions(), account);
       const userMe = await controller.exec();
 
       expect(userMe).toBeInstanceOf(UserEntity);
-      const cachedUsedMe = await UserMeSessionStorageService.get(account);
+      const cachedUsedMe = await storage.getData();
       expect(cachedUsedMe).not.toBeNull();
       expect(cachedUsedMe.id).toEqual(mockApiResult.id);
       expect(fetch).toHaveBeenCalled();
+
+      await storage.flush();
     });
 
     it("Should return cached data if any.", async () => {
       expect.assertions(3);
       const account = new AccountEntity(defaultAccountDto());
-
+      const storage = new UserMeLocalStorage(account);
       // Populate the cache
-      await UserMeSessionStorageService.set(account, new UserEntity(defaultUserDto()));
-      expect(await UserMeSessionStorageService.get(account)).not.toBeNull();
+      await storage.setData(new UserEntity(defaultUserDto()));
+      expect(await storage.getData()).not.toBeNull();
 
       const controller = new GetOrFindLoggedInUserController(null, null, defaultApiClientOptions(), account);
       const userMe = await controller.exec();
 
       expect(userMe).toBeInstanceOf(UserEntity);
       expect(fetch).not.toHaveBeenCalled();
+
+      await storage.flush();
     });
 
     it("Should refresh the cache if enforced.", async () => {
       expect.assertions(7);
       const account = new AccountEntity(defaultAccountDto());
-
+      const storage = new UserMeLocalStorage(account);
       // Populate the cache
-      await UserMeSessionStorageService.set(account, new UserEntity(defaultUserDto()));
-      expect(await UserMeSessionStorageService.get(account)).not.toBeNull();
-      // Spy on the cache set function
-      jest.spyOn(UserMeSessionStorageService, "set");
+      await storage.setData(new UserEntity(defaultUserDto()));
+      expect(await storage.getData()).not.toBeNull();
       // Mock the API response
       const mockApiResult = defaultUserDto();
       fetch.doMock(() => mockApiResponse(mockApiResult));
 
-      expect(await UserMeSessionStorageService.get(account)).not.toBeNull();
+      expect(await storage.getData()).not.toBeNull();
 
       const controller = new GetOrFindLoggedInUserController(null, null, defaultApiClientOptions(), account);
+      // Spy on the cache set function
+      jest.spyOn(controller.getOrFindMeService.userMeLocalStorageService, "setData");
       const userMe = await controller.exec(true);
 
       expect(userMe).toBeInstanceOf(UserEntity);
-      const cachedUsedMe = await UserMeSessionStorageService.get(account);
+      const cachedUsedMe = await storage.getData();
       expect(cachedUsedMe).not.toBeNull();
       expect(cachedUsedMe.id).toEqual(mockApiResult.id);
       expect(fetch).toHaveBeenCalled();
-      expect(UserMeSessionStorageService.set).toHaveBeenCalled();
+      expect(controller.getOrFindMeService.userMeLocalStorageService.setData).toHaveBeenCalled();
     });
   });
 });

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

@@ -19,8 +19,9 @@ import UpdateUserLocalStorageController from "./updateUserLocalStorageController
 import RoleEntity from "passbolt-styleguide/src/shared/models/entity/role/roleEntity";
 import AccountEntity from "../../model/entity/account/accountEntity";
 import { adminAccountDto, defaultAccountDto } from "../../model/entity/account/accountEntity.test.data";
-import { defaultCeOrganizationSettings } from "../../model/entity/organizationSettings/organizationSettingsEntity.test.data";
-import OrganizationSettingsService from "../../service/api/organizationSettings/organizationSettingsService";
+import { defaultCeSiteSettings } from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity.test.data";
+import GetOrFindSiteSettingsService from "../../service/siteSettings/getOrFindSiteSettingsService";
+import SiteSettingsEntity from "passbolt-styleguide/src/shared/models/entity/siteSettings/siteSettingsEntity";
 
 beforeEach(() => {
   enableFetchMocks();
@@ -28,9 +29,11 @@ beforeEach(() => {
 
 describe("UpdateUserLocalStorageController", () => {
   beforeEach(() => {
-    const siteSettingsDto = defaultCeOrganizationSettings();
+    const siteSettingsDto = defaultCeSiteSettings();
 
-    jest.spyOn(OrganizationSettingsService.prototype, "find").mockImplementation(() => siteSettingsDto);
+    jest
+      .spyOn(GetOrFindSiteSettingsService.prototype, "getOrFind")
+      .mockImplementation(() => new SiteSettingsEntity(siteSettingsDto));
   });
   describe("UpdateUserLocalStorageController::exec", () => {
     it("Should update the user local storage for a user having a role user.", async () => {
@@ -39,7 +42,7 @@ describe("UpdateUserLocalStorageController", () => {
       fetch.doMockOnceIf(new RegExp(`/users.json`), async (req) => {
         const url = new URL(req.url);
         expect(url.search).toStrictEqual(
-          "?api-version=v2&contain%5Bprofile%5D=1&contain%5Bgpgkey%5D=0&contain%5Bgroups_users%5D=0&contain%5Bpending_account_recovery_request%5D=1&contain%5Baccount_recovery_user_setting%5D=1&contain%5BLastLoggedIn%5D=1",
+          "?api-version=v2&contain%5Bprofile%5D=1&contain%5Bgpgkey%5D=0&contain%5Bgroups_users%5D=0&contain%5Bpending_account_recovery_request%5D=1&contain%5Baccount_recovery_user_setting%5D=1",
         );
         return mockApiResponse([]);
       });

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

@@ -17,7 +17,7 @@ import RecoverAccountController from "../controller/accountRecovery/recoverAccou
 import VerifyAccountPassphraseController from "../controller/account/verifyAccountPassphraseController";
 import AbortAndInitiateNewAccountRecoveryController from "../controller/accountRecovery/abortAndInitiateNewAccountRecoveryController";
 import SetSetupLocaleController from "../controller/setup/setSetupLocaleController";
-import GetOrganizationSettingsController from "../controller/organizationSettings/getOrganizationSettingsController";
+import GetOrFindSiteSettingsController from "../controller/siteSettings/getOrFindSiteSettingsController";
 import GetAndInitializeAccountLocaleController from "../controller/account/getAndInitializeAccountLocaleController";
 import GetExtensionVersionController from "../controller/extension/getExtensionVersionController";
 import GetAccountController from "../controller/account/getAccountController";
@@ -31,9 +31,9 @@ import ReloadTabController from "../controller/tab/reloadTabController";
  * @param {AccountAccountRecoveryEntity} account The account completing the account recovery
  */
 const listen = function (worker, apiClientOptions, account) {
-  worker.port.on("passbolt.organization-settings.get", async (requestId) => {
-    const controller = new GetOrganizationSettingsController(worker, requestId, apiClientOptions);
-    await controller._exec();
+  worker.port.on("passbolt.site-settings.get-or-find", async (requestId, refreshCache = true) => {
+    const controller = new GetOrFindSiteSettingsController(worker, requestId, apiClientOptions, account);
+    await controller._exec(refreshCache);
   });
 
   worker.port.on("passbolt.locale.get", async (requestId) => {

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

@@ -137,7 +137,12 @@ const listen = function (worker, apiClientOptions, account) {
 
   worker.port.on("passbolt.account-recovery.generate-organization-key", async (requestId, generateGpgKeyDto) => {
     const apiClientOptions = await User.getInstance().getApiClientOptions();
-    const controller = new AccountRecoveryGenerateOrganizationKeyController(worker, requestId, apiClientOptions);
+    const controller = new AccountRecoveryGenerateOrganizationKeyController(
+      worker,
+      requestId,
+      apiClientOptions,
+      account,
+    );
     await controller._exec(generateGpgKeyDto);
   });
 
@@ -320,7 +325,7 @@ const listen = function (worker, apiClientOptions, account) {
    * @param requestId {uuid} The request identifier
    */
   worker.port.on("passbolt.desktop.export-account", async (requestId) => {
-    const account = await GetLegacyAccountService.get();
+    const account = GetLegacyAccountService.get();
     const controller = new ExportDesktopAccountController(worker, requestId, account);
     await controller._exec();
   });

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

@@ -38,7 +38,7 @@ const listen = function (worker, apiClientOptions, account) {
    * @param requestId {uuid} The request identifier
    */
   worker.port.on("passbolt.auth.is-mfa-required", async (requestId) => {
-    const controller = new AuthIsMfaRequiredController(worker, requestId);
+    const controller = new AuthIsMfaRequiredController(worker, requestId, apiClientOptions, account);
     controller._exec();
   });
 
@@ -49,7 +49,7 @@ const listen = function (worker, apiClientOptions, account) {
    * @param requestId {uuid} The request identifier
    */
   worker.port.on("passbolt.auth.check-status", async (requestId) => {
-    const controller = new AuthCheckStatusController(worker, requestId);
+    const controller = new AuthCheckStatusController(worker, requestId, apiClientOptions, account);
     controller._exec();
   });
 

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

@@ -16,9 +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";
+import FindGroupsByIdsForShareController from "../controller/group/findGroupsByIdsForShareController";
 
 /**
  * Listens to the groups events
@@ -53,27 +52,15 @@ const listen = function (worker, apiClientOptions, account) {
   /*
    * Find groups by their ids.
    *
-   * @listens passbolt.groups.get-by-ids
+   * @listens passbolt.groups.find-by-ids-for-share
    * @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);
+  worker.port.on("passbolt.groups.find-by-ids-for-share", async (requestId, groupIds) => {
+    const controller = new FindGroupsByIdsForShareController(worker, requestId, apiClientOptions);
     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

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

@@ -28,7 +28,7 @@ const listen = function (worker, apiClientOptions, account) {
    * @returns {*{isAuthenticated,isMfaRequired}
    */
   worker.port.on("passbolt.in-form-cta.check-status", async (requestId, flushCache = false) => {
-    const authIsAuthenticatedController = new AuthCheckStatusController(worker, requestId);
+    const authIsAuthenticatedController = new AuthCheckStatusController(worker, requestId, apiClientOptions, account);
     await authIsAuthenticatedController._exec(flushCache);
   });
 

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

@@ -89,7 +89,7 @@ const listen = function (worker, apiClientOptions, account) {
    * @param requestId {uuid} The request identifier
    */
   worker.port.on("passbolt.locale.get", async (requestId) => {
-    const getLocaleController = new GetLocaleController(worker, apiClientOptions);
+    const getLocaleController = new GetLocaleController(worker, apiClientOptions, account);
 
     try {
       const localeEntity = await getLocaleController.getLocale();

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

@@ -19,8 +19,9 @@ import LocaleEntity from "../model/entity/locale/localeEntity";
  * Listens to the locale events
  * @param {Worker} worker
  * @param {ApiClientOptions} apiClientOptions the api client options
+ * @param {AccountEntity} [account] the user account
  */
-const listen = function (worker, apiClientOptions) {
+const listen = function (worker, apiClientOptions, account) {
   /*
    * Get locale language
    *
@@ -28,7 +29,7 @@ const listen = function (worker, apiClientOptions) {
    * @param requestId {uuid} The request identifier
    */
   worker.port.on("passbolt.locale.get", async (requestId) => {
-    const getLocaleController = new GetLocaleController(worker, apiClientOptions);
+    const getLocaleController = new GetLocaleController(worker, apiClientOptions, account);
 
     try {
       const localeEntity = await getLocaleController.getLocale();
@@ -46,7 +47,7 @@ const listen = function (worker, apiClientOptions) {
    * @param requestId {uuid} The request identifier
    */
   worker.port.on("passbolt.locale.update-user-locale", async (requestId, localeDto) => {
-    const localeModel = new LocaleModel(apiClientOptions);
+    const localeModel = new LocaleModel(apiClientOptions, account);
     try {
       const localeToUpdateEntity = new LocaleEntity(localeDto);
       await localeModel.updateUserLocale(localeToUpdateEntity);

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

@@ -13,6 +13,7 @@
  */
 
 import FindAcoPermissionsForDisplayController from "../controller/permission/FindAcoPermissionsForDisplayController";
+import FindPermissionsByIdsForShareController from "../controller/permission/findPermissionsByIdsForShareController";
 
 /**
  * Listens the permission events
@@ -32,6 +33,18 @@ const listen = function (worker, apiClientOptions, account) {
     const controller = new FindAcoPermissionsForDisplayController(worker, requestId, apiClientOptions, account);
     await controller._exec(acoId, acoType);
   });
+
+  /*
+   * Find the permissions of the given resources, tailored for the share process.
+   *
+   * @listens passbolt.permissions.find-by-ids-for-share
+   * @param requestId {uuid} The request identifier
+   * @param resourcesIds {Array<uuid>} The ids of the resources to retrieve
+   */
+  worker.port.on("passbolt.permissions.find-by-ids-for-share", async (requestId, resourcesIds) => {
+    const controller = new FindPermissionsByIdsForShareController(worker, requestId, apiClientOptions, account);
+    await controller._exec(resourcesIds);
+  });
 };
 
 export const PermissionEvents = { listen };

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

@@ -23,7 +23,7 @@ import ValidatePrivateGpgKeyRecoverController from "../controller/crypto/validat
 import AbortAndRequestHelp from "../controller/recover/abortAndRequestHelpController";
 import SignInSetupController from "../controller/setup/signInSetupController";
 import SetSetupLocaleController from "../controller/setup/setSetupLocaleController";
-import GetOrganizationSettingsController from "../controller/organizationSettings/getOrganizationSettingsController";
+import GetOrFindSiteSettingsController from "../controller/siteSettings/getOrFindSiteSettingsController";
 import GetAndInitializeAccountLocaleController from "../controller/account/getAndInitializeAccountLocaleController";
 import IsExtensionFirstInstallController from "../controller/extension/isExtensionFirstInstallController";
 import IsLostPassphraseCaseController from "../controller/accountRecovery/isLostPassphraseCaseController";
@@ -48,9 +48,9 @@ const listen = (worker, apiClientOptions, account) => {
     await controller._exec();
   });
 
-  worker.port.on("passbolt.organization-settings.get", async (requestId) => {
-    const controller = new GetOrganizationSettingsController(worker, requestId, apiClientOptions);
-    await controller._exec();
+  worker.port.on("passbolt.site-settings.get-or-find", async (requestId, refreshCache = true) => {
+    const controller = new GetOrFindSiteSettingsController(worker, requestId, apiClientOptions, account);
+    await controller._exec(refreshCache);
   });
 
   worker.port.on("passbolt.recover.start", async (requestId) => {