passbolt-browser-extension 3.0.6 → 4.6.2

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

@@ -1,161 +1,128 @@
 /**
  * Passbolt ~ Open source password manager for teams
- * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * Copyright (c) 2022 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)
+ * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         2.0.0
  */
-const {SiteSettings} = require("../model/siteSettings");
-const {SetupController} = require("../controller/setup/setupController");
-const Worker = require('../model/worker');
-
-const listen = function (worker) {
-  /**
-   * The setup controller.
-   * @type {SetupController}
-   * @private
-   */
-  const setupController = new SetupController(worker, worker.tab.url);
 
+import GetKeyInfoController from "../controller/crypto/getKeyInfoController";
+import VerifyImportedKeyPassphraseController from "../controller/setup/verifyImportedKeyPassphraseController";
+import SignInSetupController from "../controller/setup/signInSetupController";
+import SetSetupAccountRecoveryUserSettingController from "../controller/setup/setSetupAccountRecoveryUserSettingController";
+import ImportSetupPrivateKeyController from "../controller/setup/importSetupPrivateKeyController";
+import StartSetupController from "../controller/setup/startSetupController";
+import DownloadRecoveryKitController from "../controller/setup/downloadRecoverKitController";
+import CompleteSetupController from "../controller/setup/completeSetupController";
+import ValidatePrivateGpgKeySetupController from "../controller/crypto/validatePrivateGpgKeySetupController";
+import SetSetupLocaleController from "../controller/setup/setSetupLocaleController";
+import GetOrganizationSettingsController from "../controller/organizationSettings/getOrganizationSettingsController";
+import GenerateSetupKeyPairController from "../controller/setup/generateSetupKeyPairController";
+import GetAndInitSetupLocaleController from "../controller/setup/getAndInitSetupLocaleController";
+import IsExtensionFirstInstallController from "../controller/extension/isExtensionFirstInstallController";
+import SetSetupSecurityTokenController from "../controller/setup/setSetupSecurityTokenController";
+import GetAccountRecoveryOrganizationPolicyController from "../controller/setup/getAccountRecoveryOrganizationPolicyController";
+import GetUserPassphrasePoliciesController from "../controller/setup/getUserPassphrasePoliciesController";
+
+const listen = function(worker, apiClientOptions, account) {
   /*
-   * Initialize the recovery process.
+   * The setup runtime memory.
    *
-   * @listens passbolt.setup.site-settings
-   * @param requestId {uuid} The request identifier
+   * Used to store information collected during the user setup journey that shouldn't be stored on the react side of
+   * the application because of their confidentiality or for logic reason. By instance the account recovery organization
+   * policy, collected during a setup start, and used later during the process to encrypt the private escrow of the user.
    */
-  worker.port.on('passbolt.setup.site-settings', async function (requestId) {
-    try {
-      const siteSettings = new SiteSettings(setupController.setupEntity.domain);
-      const siteSettingsDto = await siteSettings.get();
-      worker.port.emit(requestId, 'SUCCESS', siteSettingsDto);
-    } catch(error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  const runtimeMemory = {};
+
+  worker.port.on('passbolt.setup.is-first-install', async requestId => {
+    const controller = new IsExtensionFirstInstallController(worker, requestId);
+    await controller._exec();
   });
 
-  /*
-   * Retrieve the setup info
-   *
-   * @listens passbolt.setup.info
-   * @param requestId {uuid} The request identifier
-   */
-  worker.port.on('passbolt.setup.info', async function (requestId) {
-    try {
-      const setupEntity = await setupController.retrieveSetupInfo();
-      worker.port.emit(requestId, 'SUCCESS', setupEntity);
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-      // In case of unexpected error at this step, let the API treat the case.
-      Worker.get('SetupBootstrap', worker.tab.id).port.emit('passbolt.setup-bootstrap.remove-iframe');
-    }
+  worker.port.on('passbolt.organization-settings.get', async requestId => {
+    const controller = new GetOrganizationSettingsController(worker, requestId, apiClientOptions);
+    await controller._exec();
   });
 
-  /*
-   * Generate the user secret key.
-   *
-   * @listens passbolt.setup.generate-key
-   * @param requestId {uuid} The request identifier
-   * @param passphrase {string} The passphrase used to generate the key
-   */
-  worker.port.on('passbolt.setup.generate-key', async function (requestId, passphrase) {
-    try {
-      await setupController.generateKey(passphrase);
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.setup.start', async requestId => {
+    const controller = new StartSetupController(worker, requestId, apiClientOptions, account, runtimeMemory);
+    await controller._exec();
   });
 
-  /*
-   * Download the recovery kit.
-   *
-   * @listens passbolt.setup.download-recovery-kit
-   * @param requestId {uuid} The request identifier
-   */
-  worker.port.on('passbolt.setup.download-recovery-kit', async function (requestId) {
-    try {
-      await setupController.downloadRecoveryKit();
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.setup.get-and-init-locale', async requestId => {
+    const controller = new GetAndInitSetupLocaleController(worker, requestId, apiClientOptions, account);
+    await controller._exec();
   });
 
-  /*
-   * Import secret key.
-   *
-   * @listens passbolt.setup.import-key
-   * @param requestId {uuid} The request identifier
-   * @param armoredKey {string} The armored key to import
-   */
-  worker.port.on('passbolt.setup.import-key', async function (requestId, armoredKey) {
-    try {
-      await setupController.importKey(armoredKey);
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.setup.update-locale', async(requestId, localeDto) => {
+    const controller = new SetSetupLocaleController(worker, requestId, apiClientOptions, account);
+    await controller._exec(localeDto);
   });
 
-  /*
-   * Verify secret key passphrase
-   *
-   * @listens passbolt.setup.verify-passphrase
-   * @param requestId {uuid} The request identifier
-   * @param passphrase {string} The passphrase used to verify the secret key
-   * @param rememberUntilLogout {boolean} The passphrase should be remembered until the user is logged out
-   */
-  worker.port.on('passbolt.setup.verify-passphrase', async function (requestId, passphrase, rememberUntilLogout) {
-    try {
-      await setupController.verifyPassphrase(passphrase, rememberUntilLogout);
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.setup.generate-key', async(requestId, generateGpgKeyDto) => {
+    const controller = new GenerateSetupKeyPairController(worker, requestId, apiClientOptions, account, runtimeMemory);
+    await controller._exec(generateGpgKeyDto);
   });
 
-  /*
-   * Set the user security token
-   *
-   * @listens passbolt.setup.set-security-token
-   * @param requestId {uuid} The request identifier
-   * @param securityTokenDto {object} The security token dto. ie: {color: hex-string, text-color: hex-string, code: string}
-   */
-  worker.port.on('passbolt.setup.set-security-token', async function (requestId, securityTokenDto) {
-    try {
-      setupController.setSecurityToken(securityTokenDto);
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.setup.download-recovery-kit', async requestId => {
+    const controller = new DownloadRecoveryKitController(worker, requestId, account);
+    await controller._exec();
   });
 
-  /*
-   * Complete the setup
-   *
-   * @listens passbolt.setup.complete
-   * @param requestId {uuid} The request identifier
-   */
-  worker.port.on('passbolt.setup.complete', async function (requestId) {
-    try {
-      await setupController.complete();
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.setup.get-account-recovery-organization-policy', async requestId => {
+    const controller = new GetAccountRecoveryOrganizationPolicyController(worker, requestId, runtimeMemory);
+    await controller._exec();
+  });
+
+  worker.port.on('passbolt.setup.set-account-recovery-user-setting', async(requestId, status) => {
+    const controller = new SetSetupAccountRecoveryUserSettingController(worker, requestId, account, runtimeMemory);
+    await controller._exec(status);
+  });
+
+  worker.port.on('passbolt.setup.import-key', async(requestId, armoredKey) => {
+    const controller = new ImportSetupPrivateKeyController(worker, requestId, account);
+    await controller._exec(armoredKey);
+  });
+
+  worker.port.on('passbolt.setup.verify-passphrase', async(requestId, passphrase) => {
+    const controller = new VerifyImportedKeyPassphraseController(worker, requestId, account, runtimeMemory);
+    await controller._exec(passphrase);
+  });
+
+  worker.port.on('passbolt.setup.set-security-token', async(requestId, securityTokenDto) => {
+    const controller = new SetSetupSecurityTokenController(worker, requestId, account);
+    await controller._exec(securityTokenDto);
+  });
+
+  worker.port.on('passbolt.setup.complete', async requestId => {
+    const controller = new CompleteSetupController(worker, requestId, apiClientOptions, account, runtimeMemory);
+    await controller._exec();
+  });
+
+  worker.port.on('passbolt.keyring.get-key-info', async(requestId, armoredKey) => {
+    const controller = new GetKeyInfoController(worker, requestId);
+    await controller._exec(armoredKey);
+  });
+
+  worker.port.on('passbolt.setup.sign-in', async(requestId, rememberMe) => {
+    const controller = new SignInSetupController(worker, requestId, apiClientOptions, account, runtimeMemory);
+    await controller._exec(rememberMe);
+  });
+
+  worker.port.on('passbolt.setup.validate-private-key', async(requestId, key) => {
+    const controller = new ValidatePrivateGpgKeySetupController(worker, requestId);
+    await controller._exec(key);
+  });
+
+  worker.port.on('passbolt.setup.get-user-passphrase-policies', async requestId => {
+    const controller = new GetUserPassphrasePoliciesController(worker, requestId, runtimeMemory);
+    await controller._exec();
   });
 };
-exports.listen = listen;
+export const SetupEvents = {listen};

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

@@ -6,51 +6,31 @@
  * @copyright (c) 2017 Passbolt SARL
  * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
  */
-const Worker = require('../model/worker');
-const {User} = require('../model/user');
-const {Share} = require('../model/share');
-const {ResourceModel} = require('../model/resource/resourceModel');
-const {FolderModel} = require('../model/folder/folderModel');
-
-const {FoldersCollection} = require('../model/entity/folder/foldersCollection');
-const {PermissionChangesCollection} = require('../model/entity/permission/change/permissionChangesCollection');
-
-const {ShareResourcesController} = require('../controller/share/shareResourcesController');
-const {ShareFoldersController} = require('../controller/share/shareFoldersController');
-
-const listen = function (worker) {
-  /*
-   * Search aros based on keywords.
-   * @listens passbolt.share.search-aros
-   * @param keywords {string} The keywords to search
-   */
-  worker.port.on('passbolt.share.search-aros', async function (requestId, keywords, resourcesForLegacyApi) {
-    let aros;
-    try {
-      aros = await Share.searchAros(keywords);
-    } catch (error) {
-      if (resourcesForLegacyApi.resourcesIds && resourcesForLegacyApi.resourcesIds.length === 1) {
-        // This code ensure the compatibility with passbolt < v2.4.0.
-        aros = await Share.searchResourceAros(resourcesForLegacyApi.resourcesIds[0], keywords);
-      } else {
-        worker.port.emit(requestId, 'ERROR', error);
-      }
-    }
-    worker.port.emit(requestId, 'SUCCESS', aros);
-  });
+import ResourceModel from "../model/resource/resourceModel";
+import FolderModel from "../model/folder/folderModel";
+import ShareResourcesController from "../controller/share/shareResourcesController";
+import ShareFoldersController from "../controller/share/shareFoldersController";
+import FoldersCollection from "../model/entity/folder/foldersCollection";
+import PermissionChangesCollection from "../model/entity/permission/change/permissionChangesCollection";
 
+/**
+ * Listens the share events
+ * @param {Worker} worker
+ * @param {ApiClientOptions} apiClientOptions the api client options
+ * @param {AccountEntity} account the user account
+ */
+const listen = function(worker, apiClientOptions, account) {
   /*
    * Retrieve the resources to share.
    * @listens passbolt.share.get-resources
    * @param {array} resourcesIds The ids of the resources to retrieve.
    */
-  worker.port.on('passbolt.share.get-resources', async function (requestId, resourcesIds) {
+  worker.port.on('passbolt.share.get-resources', async(requestId, resourcesIds) => {
     try {
-      let apiClientOptions = await User.getInstance().getApiClientOptions();
-      let resourceModel = new ResourceModel(apiClientOptions);
+      const resourceModel = new ResourceModel(apiClientOptions, account);
       const resourcesCollection = await resourceModel.findAllForShare(resourcesIds);
       worker.port.emit(requestId, 'SUCCESS', resourcesCollection);
-    } catch(error) {
+    } catch (error) {
       console.error(error);
       worker.port.emit(requestId, 'ERROR', error);
     }
@@ -61,10 +41,9 @@ const listen = function (worker) {
    * @listens passbolt.share.get-folders
    * @param {array} foldersIds The ids of the folders to retrieve.
    */
-  worker.port.on('passbolt.share.get-folders', async function (requestId, foldersIds) {
+  worker.port.on('passbolt.share.get-folders', async(requestId, foldersIds) => {
     try {
-      let apiClientOptions = await User.getInstance().getApiClientOptions();
-      let folderModel = new FolderModel(apiClientOptions);
+      const folderModel = new FolderModel(apiClientOptions);
       const foldersCollection = await folderModel.findAllForShare(foldersIds);
       worker.port.emit(requestId, 'SUCCESS', foldersCollection);
     } catch (error) {
@@ -78,10 +57,9 @@ const listen = function (worker) {
    * @listens passbolt.share.submit
    * @param requestId {uuid} The request identifier
    */
-  worker.port.on('passbolt.share.resources.save', async function (requestId, resources, changes) {
+  worker.port.on('passbolt.share.resources.save', async(requestId, resources, changes) => {
     try {
-      const apiClientOptions = await User.getInstance().getApiClientOptions();
-      const shareResourcesController = new ShareResourcesController(worker, requestId, apiClientOptions);
+      const shareResourcesController = new ShareResourcesController(worker, requestId, apiClientOptions, account);
       await shareResourcesController.main(resources, changes);
       worker.port.emit(requestId, 'SUCCESS');
     } catch (error) {
@@ -95,12 +73,11 @@ const listen = function (worker) {
    * @listens passbolt.share.folders.save
    * @param requestId {uuid} The request identifier
    */
-  worker.port.on('passbolt.share.folders.save', async function (requestId, foldersDto, changesDto) {
+  worker.port.on('passbolt.share.folders.save', async(requestId, foldersDto, changesDto) => {
     try {
       const folders = new FoldersCollection(foldersDto);
       const permissionChanges = new PermissionChangesCollection(changesDto);
-      const apiClientOptions = await User.getInstance().getApiClientOptions();
-      const shareFoldersController = new ShareFoldersController(worker, requestId, apiClientOptions);
+      const shareFoldersController = new ShareFoldersController(worker, requestId, apiClientOptions, account);
       await shareFoldersController.main(folders, permissionChanges);
       worker.port.emit(requestId, 'SUCCESS');
     } catch (error) {
@@ -109,4 +86,4 @@ const listen = function (worker) {
     }
   });
 };
-exports.listen = listen;
+export const ShareEvents = {listen};

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

@@ -0,0 +1,57 @@
+/**
+ * Subscription events
+ *
+ * Used to handle the events related to the current subscription
+ *
+ * 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)
+ */
+import SubscriptionController from "../controller/subscription/subscriptionController";
+
+/**
+ * Listens the subscription events
+ * @param {Worker} worker
+ * @param {ApiClientOptions} apiClientOptions the api client options
+ */
+const listen = function(worker, apiClientOptions) {
+  /*
+   * Find the subscription
+   *
+   * @listens passbolt.subscription.get
+   * @param requestId {uuid} The request identifier
+   */
+  worker.port.on('passbolt.subscription.get', async requestId => {
+    const subscriptionController = new SubscriptionController(worker, apiClientOptions);
+    try {
+      const subscriptionEntity = await subscriptionController.getSubscription();
+      worker.port.emit(requestId, 'SUCCESS', subscriptionEntity);
+    } catch (error) {
+      worker.port.emit(requestId, 'ERROR', error);
+    }
+  });
+
+  /*
+   * Update the subscription key
+   *
+   * @listens passbolt.subscription.get
+   * @param requestId {uuid} The request identifier
+   */
+  worker.port.on('passbolt.subscription.update', async(requestId, subscriptionKeyDto) => {
+    const subscriptionController = new SubscriptionController(worker, apiClientOptions);
+    try {
+      const subscriptionEntity = await subscriptionController.updateSubscription(subscriptionKeyDto);
+      worker.port.emit(requestId, 'SUCCESS', subscriptionEntity);
+    } catch (error) {
+      worker.port.emit(requestId, 'ERROR', error);
+    }
+  });
+};
+export const SubscriptionEvents = {listen};

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

@@ -4,42 +4,26 @@
  * @copyright (c) 2019 Passbolt SA
  * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
  */
-const browser = require("webextension-polyfill/dist/browser-polyfill");
+import i18n from "../sdk/i18n";
+import BrowserTabService from "../service/ui/browserTab.service";
 
-const listen = function (worker) {
+const listen = function(worker) {
   /*
    * Get the current tab url.
    *
    * @listens passbolt.active-tab.get-url
    */
-  worker.port.on('passbolt.active-tab.get-url', async function (requestId) {
-    const tabs = await browser.tabs.query({ active: true, currentWindow: true });
-    // There's a possiblity when `tabs` will be undefined.
-    // By instance separate `facebook.com` login window serves its usecase (login by facebook/google)
-    if (!tabs || !tabs[0]) {
-      worker.port.emit(requestId, 'ERROR', new Error('Unable to retrieve the active tab info.'));
+  worker.port.on('passbolt.active-tab.get-url', async(requestId, tabId) => {
+    const tab = tabId ? await BrowserTabService.getById(tabId) : await BrowserTabService.getCurrent();
+    /*
+     * There's a possiblity when `tab` will be empty.
+     * By instance separate `facebook.com` login window serves its usecase (login by facebook/google)
+     */
+    if (!tab) {
+      worker.port.emit(requestId, 'ERROR', new Error(i18n.t('Unable to retrieve the active tab info.')));
       return;
     }
-    worker.port.emit(requestId, 'SUCCESS', tabs[0].url);
+    worker.port.emit(requestId, 'SUCCESS', tab.url);
   });
-
-  /*
-   * Get the current tab info.
-   *
-   * @listens passbolt.active-tab.get-info
-   */
-  worker.port.on('passbolt.active-tab.get-info', async function (requestId) {
-    const tabs = await browser.tabs.query({ active: true, currentWindow: true });
-    if (!tabs || !tabs[0]) {
-      worker.port.emit(requestId, 'ERROR', new Error('Unable to retrieve the active tab info.'));
-      return;
-    }
-    const info = {
-      title: tabs[0].title,
-      url: tabs[0].url
-    }
-    worker.port.emit(requestId, 'SUCCESS', info);
-  });
-
 };
-exports.listen = listen;
+export const TabEvents = {listen};

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

@@ -10,22 +10,22 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {User} = require('../model/user');
-const {TagModel} = require('../model/tag/tagModel');
-const {TagEntity} = require('../model/entity/tag/tagEntity');
-const {TagsCollection} = require('../model/entity/tag/tagsCollection');
+import TagModel from "../model/tag/tagModel";
+import TagController from "../controller/tag/tagController";
+import TagEntity from "../model/entity/tag/tagEntity";
+import TagsCollection from "../model/entity/tag/tagsCollection";
 
-const listen = function (worker) {
+
+const listen = function(worker, apiClientOptions, account) {
   /*
    * Find all the tags
    *
    * @listens passbolt.tags.find-all
    * @param requestId {uuid} The request identifier
    */
-  worker.port.on('passbolt.tags.find-all', async function (requestId) {
+  worker.port.on('passbolt.tags.find-all', async requestId => {
     try {
-      const apiOption = await User.getInstance().getApiClientOptions();
-      const tagModel = new TagModel(apiOption);
+      const tagModel = new TagModel(apiClientOptions, account);
       const tagsCollection = await tagModel.findAll();
       worker.port.emit(requestId, 'SUCCESS', tagsCollection);
     } catch (error) {
@@ -41,10 +41,9 @@ const listen = function (worker) {
    * @param resourceId {uuid} The resource identifier
    * @param tagsDto {Object} tags dto
    */
-  worker.port.on('passbolt.tags.update-resource-tags', async function (requestId, resourceId, tagsDto) {
+  worker.port.on('passbolt.tags.update-resource-tags', async(requestId, resourceId, tagsDto) => {
     try {
-      const apiOption = await User.getInstance().getApiClientOptions();
-      const tagModel = new TagModel(apiOption);
+      const tagModel = new TagModel(apiClientOptions, account);
       const tagsCollection = new TagsCollection(tagsDto);
       const tags = await tagModel.updateResourceTags(resourceId, tagsCollection);
       worker.port.emit(requestId, 'SUCCESS', tags);
@@ -53,6 +52,23 @@ const listen = function (worker) {
     }
   });
 
+  /*
+   * Add resources tag
+   *
+   * @listens passbolt.tags.add-resource-tags
+   * @param requestId {uuid} The request identifier
+   * @param {object} resourcesTagDto {resources: array of uuids, tag: {object}} the tag to add for the resources
+   */
+  worker.port.on('passbolt.tags.add-resources-tag', async(requestId, resourcesTagDto) => {
+    try {
+      const tagController = new TagController(worker, apiClientOptions, account);
+      await tagController.addTagResources(resourcesTagDto.resources, resourcesTagDto.tag);
+      worker.port.emit(requestId, 'SUCCESS');
+    } catch (error) {
+      worker.port.emit(requestId, 'ERROR', error);
+    }
+  });
+
   /*
    * Update a tag
    *
@@ -60,10 +76,9 @@ const listen = function (worker) {
    * @param requestId {uuid} The request identifier
    * @param tagDto {object} The tag object
    */
-  worker.port.on('passbolt.tags.update', async function (requestId, tagDto) {
+  worker.port.on('passbolt.tags.update', async(requestId, tagDto) => {
     try {
-      const apiOption = await User.getInstance().getApiClientOptions();
-      const tagModel = new TagModel(apiOption);
+      const tagModel = new TagModel(apiClientOptions, account);
       const tagEntity = new TagEntity(tagDto);
       const updatedTag = await tagModel.update(tagEntity);
       worker.port.emit(requestId, 'SUCCESS', updatedTag);
@@ -79,10 +94,9 @@ const listen = function (worker) {
    * @param requestId {uuid} The request identifier
    * @param tagId {uuid} The tag identifier
    */
-  worker.port.on('passbolt.tags.delete', async function (requestId, tagId) {
+  worker.port.on('passbolt.tags.delete', async(requestId, tagId) => {
     try {
-      const apiOption = await User.getInstance().getApiClientOptions();
-      const tagModel = new TagModel(apiOption);
+      const tagModel = new TagModel(apiClientOptions, account);
       await tagModel.delete(tagId);
       worker.port.emit(requestId, 'SUCCESS');
     } catch (error) {
@@ -90,4 +104,4 @@ const listen = function (worker) {
     }
   });
 };
-exports.listen = listen;
+export const TagEvents = {listen};

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

@@ -10,21 +10,24 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {User} = require('../model/user');
-const {ThemeModel} = require("../model/theme/themeModel");
-const {ChangeThemeEntity} = require("../model/entity/theme/change/ChangeThemeEntity");
+import ThemeModel from "../model/theme/themeModel";
+import ChangeThemeEntity from "../model/entity/theme/change/ChangeThemeEntity";
 
-const listen = async function (worker) {
+/**
+ * Listens the theme events
+ * @param {Worker} worker
+ * @param {ApiClientOptions} apiClientOptions the api client options
+ */
+const listen = function(worker, apiClientOptions) {
   /*
    * Find all themes
    *
    * @listens passbolt.themes.find-all
    * @param requestId {uuid} The request identifier
    */
-  worker.port.on('passbolt.themes.find-all', async function (requestId) {
+  worker.port.on('passbolt.themes.find-all', async requestId => {
     try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const themeModel = new ThemeModel(clientOptions);
+      const themeModel = new ThemeModel(apiClientOptions);
       const themes = await themeModel.findAll();
       worker.port.emit(requestId, 'SUCCESS', themes);
     } catch (error) {
@@ -39,11 +42,10 @@ const listen = async function (worker) {
    * @listens passbolt.themes.change
    * @param requestId {uuid} The request identifier
    */
-  worker.port.on('passbolt.themes.change', async function (requestId, name) {
+  worker.port.on('passbolt.themes.change', async(requestId, name) => {
     try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const themeModel = new ThemeModel(clientOptions);
-      const changeThemeEntity = new ChangeThemeEntity({name});
+      const themeModel = new ThemeModel(apiClientOptions);
+      const changeThemeEntity = new ChangeThemeEntity({name: name});
       await themeModel.change(changeThemeEntity);
       worker.port.emit(requestId, 'SUCCESS');
     } catch (error) {
@@ -51,6 +53,6 @@ const listen = async function (worker) {
       worker.port.emit(requestId, 'ERROR', error);
     }
   });
-}
+};
 
-exports.listen = listen;
+export const ThemeEvents = {listen};