passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/controller/import/importResourcesFileController.js

@@ -10,56 +10,50 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const __ = require('../../sdk/l10n').get;
-const Worker = require('../../model/worker');
-
-const {Keyring} = require('../../model/keyring');
-const {Crypto} = require('../../model/crypto');
-const {User} = require('../../model/user');
-
-const {FileTypeError} = require("../../error/fileTypeError");
-
-const progressController = require('../progress/progressController');
-const passphraseController = require('../passphrase/passphraseController');
-const {ImportError} = require("../../error/importError");
-
-const {ResourcesImportParser} = require("../../model/import/resourcesImportParser");
-const {FolderModel} = require('../../model/folder/folderModel');
-const {ResourceTypeModel} = require("../../model/resourceType/resourceTypeModel");
-const {ResourceModel} = require('../../model/resource/resourceModel');
-const {TagModel} = require('../../model/tag/tagModel');
-
-const {ResourcesCollection} = require("../../model/entity/resource/resourcesCollection");
-const {FoldersCollection} = require("../../model/entity/folder/foldersCollection");
-const {TagsCollection} = require('../../model/entity/tag/tagsCollection');
-const {ResourceSecretsCollection} = require("../../model/entity/secret/resource/resourceSecretsCollection");
-const {ImportResourcesFileEntity} = require("../../model/entity/import/importResourcesFileEntity");
-const {SecretEntity} = require("../../model/entity/secret/secretEntity");
-
-const PROGRESS_DIALOG_TITLE = "Importing ...";
-
+import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
+import Keyring from "../../model/keyring";
+import EncryptMessageService from "../../service/crypto/encryptMessageService";
+import User from "../../model/user";
+import ResourceTypeModel from "../../model/resourceType/resourceTypeModel";
+import ResourceModel from "../../model/resource/resourceModel";
+import GetPassphraseService from "../../service/passphrase/getPassphraseService";
+import GetDecryptedUserPrivateKeyService from "../../service/account/getDecryptedUserPrivateKeyService";
+import FolderModel from "../../model/folder/folderModel";
+import TagModel from "../../model/tag/tagModel";
+import ResourcesCollection from "../../model/entity/resource/resourcesCollection";
+import ExternalFoldersCollection from "../../model/entity/folder/external/externalFoldersCollection";
+import ImportResourcesFileEntity from "../../model/entity/import/importResourcesFileEntity";
+import ResourcesImportParser from "../../model/import/resourcesImportParser";
+import i18n from "../../sdk/i18n";
+import TagsCollection from "../../model/entity/tag/tagsCollection";
+import SecretEntity from "../../model/entity/secret/secretEntity";
+import ResourceSecretsCollection from "../../model/entity/secret/resource/resourceSecretsCollection";
+import ImportError from "../../error/importError";
+import ProgressService from "../../service/progress/progressService";
+
+const INITIAL_PROGRESS_GOAL = 100;
 class ImportResourcesFileController {
   /**
    * ImportResourcesFileController constructor
    * @param {Worker} worker
-   * @param {ApiClientOptions} clientOptions
+   * @param {ApiClientOptions} apiClientOptions the api client options
+   * @param {AccountEntity} account the account associated to the worker
    */
-  constructor(worker, clientOptions) {
+  constructor(worker, apiClientOptions, account) {
     this.worker = worker;
 
     // Crypto
     this.keyring = new Keyring();
-    this.crypto = new Crypto(this.keyring);
 
     // Models
-    this.resourceTypeModel = new ResourceTypeModel(clientOptions);
-    this.resourceModel = new ResourceModel(clientOptions);
-    this.folderModel = new FolderModel(clientOptions);
-    this.tagModel = new TagModel(clientOptions);
+    this.resourceTypeModel = new ResourceTypeModel(apiClientOptions);
+    this.resourceModel = new ResourceModel(apiClientOptions, account);
+    this.folderModel = new FolderModel(apiClientOptions);
+    this.tagModel = new TagModel(apiClientOptions, account);
 
     // Progress
-    this.progressGoal = 100;
-    this.progress = 0;
+    this.progressService = new ProgressService(this.worker, i18n.t("Importing ..."));
+    this.getPassphraseService = new GetPassphraseService(account);
   }
 
   /**
@@ -72,9 +66,8 @@ class ImportResourcesFileController {
   async exec(fileType, file, options) {
     const userId = User.getInstance().get().id;
 
-    await progressController.open(this.worker, PROGRESS_DIALOG_TITLE, this.progressGoal, __('Initialize'));
-    await progressController.update(this.worker, ++this.progress);
-
+    this.progressService.start(INITIAL_PROGRESS_GOAL, i18n.t('Initialize'));
+    await this.progressService.finishStep(null, true);
     try {
       const importEntity = this.buildImportEntity(fileType, file, options);
       await this.parseFile(importEntity);
@@ -83,11 +76,11 @@ class ImportResourcesFileController {
       importEntity.mustImportFolders && await this.bulkImportFolders(importEntity);
       await this.bulkImportResources(importEntity);
       importEntity.mustTag && await this.bulkTagResources(importEntity);
-      await progressController.update(this.worker, this.progressGoal);
-      await progressController.close(this.worker);
+      await this.progressService.finishStep(null, true);
+      await this.progressService.close();
       return importEntity;
     } catch (error) {
-      await progressController.close(this.worker);
+      await this.progressService.close();
       throw error;
     }
   }
@@ -102,7 +95,7 @@ class ImportResourcesFileController {
    */
   buildImportEntity(fileType, file, options) {
     const ref = this.generateImportReference();
-    const importResourcesDto = {file_type: fileType, file, options, ref};
+    const importResourcesDto = {file_type: fileType, file: file, options: options, ref: ref};
     return new ImportResourcesFileEntity(importResourcesDto);
   }
 
@@ -128,40 +121,43 @@ class ImportResourcesFileController {
     await importParser.parseImport(importEntity, resourceTypesCollection);
 
     // Now that we know about the content of the import, update the progress bar goals.
-    this.progressGoal = 1 // Initialization
+    const progressGoal = 1 // Initialization
       + (importEntity.mustImportFolders ? importEntity.importFolders.items.length : 0) // #folders create API calls
       + importEntity.importResources.items.length * 2 // #resource to encrypt + #resource create API calls
       + (importEntity.mustTag ? importEntity.importResources.items.length : 0); // #resources tag API calls
-    await progressController.updateGoals(this.worker, this.progressGoal);
+    this.progressService.updateGoals(progressGoal);
 
     return importEntity;
   }
 
   /**
    * Get the user private key decrypted
-   * @returns {Promise<openpgp.key.Key>}
+   * @returns {Promise<openpgp.PrivateKey>}
    */
   async getPrivateKey() {
-    const passphrase = await passphraseController.get(this.worker);
-    return this.crypto.getAndDecryptPrivateKey(passphrase);
+    const passphrase = await this.getPassphraseService.getPassphrase(this.worker);
+    return GetDecryptedUserPrivateKeyService.getKey(passphrase);
   }
 
   /**
    * Encrypt the secrets.
    * @param {ImportResourcesFileEntity} importEntity The import object
    * @param {string} userId uuid
-   * @param {openpgp.key.Key} privateKey
+   * @param {openpgp.PrivateKey} privateKey
    * @returns {Promise<void>}
    */
   async encryptSecrets(importEntity, userId, privateKey) {
     let i = 0;
-    for (let importResourceEntity of importEntity.importResources) {
-      progressController.update(this.worker, this.progress++, __(`Encrypting ${++i}/${importEntity.importResources.items.length}`));
+    for (const importResourceEntity of importEntity.importResources) {
+      i++;
+      await this.progressService.finishStep(i18n.t('Encrypting {{counter}}/{{total}}', {counter: i, total: importEntity.importResources.items.length}));
       // @todo The secret DTO could be carried by the external resource entity. It can be done when we arrange the external resource entity schema validation.
       const secretDto = this.buildSecretDto(importResourceEntity);
       const serializedPlaintextDto = await this.resourceModel.serializePlaintextDto(importResourceEntity.resourceTypeId, secretDto);
-      const data = await this.crypto.encrypt(serializedPlaintextDto, userId, privateKey);
-      const secret = new SecretEntity({data});
+      const userPublicArmoredKey = this.keyring.findPublic(userId).armoredKey;
+      const userPublicKey = await OpenpgpAssertion.readKeyOrFail(userPublicArmoredKey);
+      const data = await EncryptMessageService.encrypt(serializedPlaintextDto, userPublicKey, [privateKey]);
+      const secret = new SecretEntity({data: data});
       importResourceEntity.secrets = new ResourceSecretsCollection([secret]);
     }
   }
@@ -176,10 +172,13 @@ class ImportResourcesFileController {
     if (importResourceEntity.resourceTypeId) {
       const dto = {
         password: importResourceEntity.secretClear || "",
-        description: importResourceEntity.description || ""
-      }
-      // @todo sloppy. We remove the clear description here, but it should be done at a parsing level.
+        description: importResourceEntity.description || "",
+        totp: importResourceEntity.totp || ""
+      };
+      // @todo sloppy. We remove the clear secret fields here, but it should be done at a parsing level.
+      importResourceEntity.secretClear = "";
       importResourceEntity.description = "";
+      importResourceEntity.totp = "";
       return dto;
     }
     return importResourceEntity.secretClear;
@@ -200,11 +199,11 @@ class ImportResourcesFileController {
       if (!externalFolderChunk.length) {
         break;
       }
-      const foldersCollection = new FoldersCollection(externalFolderChunk);
+      const foldersCollection = ExternalFoldersCollection.toFoldersCollection(externalFolderChunk);
       const successCallback = (folderEntity, index) => this.handleImportFolderSuccess.bind(this)(importEntity, ++importedCount, folderEntity, externalFolderChunk[index]);
       const errorCallback = (error, index) => this.handleImportFolderError.bind(this)(importEntity, ++importedCount, error, externalFolderChunk[index]);
-      await this.folderModel.bulkCreate(foldersCollection, {successCallback, errorCallback});
-    } while(++depth);
+      await this.folderModel.bulkCreate(foldersCollection, {successCallback: successCallback, errorCallback: errorCallback});
+    } while (++depth);
 
     // Set import folder reference
     const importFolderReferenceEntity = importEntity.importFolders.getByPath(importEntity.ref);
@@ -221,11 +220,11 @@ class ImportResourcesFileController {
    * @param {FolderEntity} folderEntity The created folder
    * @param {ExternalFolderEntity} externalFolderEntity The external folder entity at the source of the create
    */
-  handleImportFolderSuccess(importEntity, importedCount, folderEntity, externalFolderEntity) {
+  async handleImportFolderSuccess(importEntity, importedCount, folderEntity, externalFolderEntity) {
     externalFolderEntity.id = folderEntity.id;
     importEntity.importFolders.setFolderParentIdsByPath(externalFolderEntity.path, externalFolderEntity.id);
     importEntity.importResources.setFolderParentIdsByPath(externalFolderEntity.path, externalFolderEntity.id);
-    progressController.update(this.worker, this.progress++, __(`Importing folders ${importedCount}/${importEntity.importFolders.items.length}`));
+    await this.progressService.finishStep(i18n.t('Importing folders {{importedCount}}/{{total}}', {importedCount: importedCount, total: importEntity.importFolders.items.length}));
   }
 
   /**
@@ -235,8 +234,8 @@ class ImportResourcesFileController {
    * @param {Error} error The encountered error
    * @param {ExternalFolderEntity} externalFolderEntity The external folder entity at the source of the create
    */
-  handleImportFolderError(importEntity, importedCount, error, externalFolderEntity) {
-    progressController.update(this.worker, this.progress++, __(`Importing folders ${importedCount}/${importEntity.importFolders.items.length}`));
+  async handleImportFolderError(importEntity, importedCount, error, externalFolderEntity) {
+    await this.progressService.finishStep(i18n.t('Importing folders {{importedCount}}/{{total}}', {importedCount: importedCount, total: importEntity.importFolders.items.length}));
     importEntity.importFoldersErrors.push(new ImportError("Cannot import folder", externalFolderEntity, error));
     importEntity.importFolders.removeByPath(externalFolderEntity.path);
     importEntity.importResources.removeByPath(externalFolderEntity.path);
@@ -252,7 +251,7 @@ class ImportResourcesFileController {
     const resourcesCollection = new ResourcesCollection(importEntity.importResources.toJSON());
     const successCallback = (resourceEntity, index) => this.handleImportResourceSuccess(importEntity, ++importedCount, resourceEntity, importEntity.importResources.items[index]);
     const errorCallback = (error, index) => this.handleImportResourceError(importEntity, ++importedCount, error, importEntity.importResources.items[index]);
-    await this.resourceModel.bulkCreate(resourcesCollection, {successCallback, errorCallback});
+    await this.resourceModel.bulkCreate(resourcesCollection, {successCallback: successCallback, errorCallback: errorCallback});
   }
 
   /**
@@ -262,9 +261,9 @@ class ImportResourcesFileController {
    * @param {ResourceEntity} resourceEntity The created resource
    * @param {ExternalResourceEntity} externalResourceEntity The external resource entity at the source of the create
    */
-  handleImportResourceSuccess(importEntity, importedCount, resourceEntity, externalResourceEntity) {
+  async handleImportResourceSuccess(importEntity, importedCount, resourceEntity, externalResourceEntity) {
     externalResourceEntity.id = resourceEntity.id;
-    progressController.update(this.worker, this.progress++, __(`Importing passwords ${importedCount}/${importEntity.importResources.items.length}`));
+    await this.progressService.finishStep(i18n.t('Importing passwords {{importedCount}}/{{total}}', {importedCount: importedCount, total: importEntity.importResources.items.length}));
   }
 
   /**
@@ -274,8 +273,8 @@ class ImportResourcesFileController {
    * @param {Error} error The encountered error
    * @param {ExternalResourceEntity} externalResourceEntity The external resource entity at the source of the create
    */
-  handleImportResourceError(importEntity, importedCount, error, externalResourceEntity) {
-    progressController.update(this.worker, this.progress++, __(`Importing passwords ${importedCount}/${importEntity.importResources.items.length}`));
+  async handleImportResourceError(importEntity, importedCount, error, externalResourceEntity) {
+    await this.progressService.finishStep(i18n.t('Importing passwords {{importedCount}}/{{total}}', {importedCount: importedCount, total: importEntity.importResources.items.length}));
     importEntity.importResourcesErrors.push(new ImportError("Cannot import resource", externalResourceEntity, error));
   }
 
@@ -287,7 +286,7 @@ class ImportResourcesFileController {
   async bulkTagResources(importEntity) {
     const tagsCollection = new TagsCollection([{slug: importEntity.ref}]);
     const resourcesIds = importEntity.importResources.items.filter(importResourceEntity => importResourceEntity.id)
-      // Do not tag resource which failed.
+    // Do not tag resource which failed.
       .map(importResourceEntity => importResourceEntity.id);
 
     if (!resourcesIds.length) {
@@ -312,7 +311,7 @@ class ImportResourcesFileController {
     let taggedCount = 0;
     const successCallback = () => this.handleTagResourceSuccess(importEntity, ++taggedCount);
     const errorCallback = () => this.handleTagResourceError(importEntity, ++taggedCount);
-    const resourcesEntities = await this.tagModel.bulkTagResources(resourcesIds, tagsCollection, {successCallback, errorCallback});
+    const resourcesEntities = await this.tagModel.bulkTagResources(resourcesIds, tagsCollection, {successCallback: successCallback, errorCallback: errorCallback});
 
     // Retrieve the reference tag and update the import entity.
     if (resourcesEntities && resourcesEntities.length) {
@@ -325,8 +324,8 @@ class ImportResourcesFileController {
    * @param {ImportResourcesFileEntity} importEntity The import
    * @param {int} taggedCount The number of resource tagged (with success or no)
    */
-  handleTagResourceSuccess(importEntity, taggedCount) {
-    progressController.update(this.worker, this.progress++, __(`Tagging passwords ${taggedCount}/${importEntity.importResources.items.length}`));
+  async handleTagResourceSuccess(importEntity, taggedCount) {
+    await this.progressService.finishStep(i18n.t('Tagging passwords {{taggedCount}}/{{total}}', {taggedCount: taggedCount, total: importEntity.importResources.items.length}));
   }
 
   /**
@@ -334,9 +333,9 @@ class ImportResourcesFileController {
    * @param {ImportResourcesFileEntity} importEntity The import
    * @param {int} taggedCount The number of resource tagged (with success or no)
    */
-  handleTagResourceError(importEntity, taggedCount) {
-    progressController.update(this.worker, this.progress++, __(`Tagging passwords ${taggedCount}/${importEntity.importResources.items.length}`));
+  async handleTagResourceError(importEntity, taggedCount) {
+    await this.progressService.finishStep(i18n.t('Tagging passwords {{taggedCount}}/{{total}}', {taggedCount: taggedCount, total: importEntity.importResources.items.length}));
   }
 }
 
-exports.ImportResourcesFileController = ImportResourcesFileController;
+export default ImportResourcesFileController;

package/src/all/background_page/controller/informCallToActionController/informCallToActionController.js

@@ -0,0 +1,99 @@
+/**
+ * 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         3.3.0
+ */
+import GpgAuth from "../../model/gpgauth";
+import User from "../../model/user";
+import ResourceModel from "../../model/resource/resourceModel";
+import {QuickAccessService} from "../../service/ui/quickAccess.service";
+import WorkerService from "../../service/worker/workerService";
+
+/**
+ * Controller related to the in-form call-to-action
+ */
+class InformCallToActionController {
+  /**
+   * InformCallToActionController constructor
+   * @param {Worker} worker
+   * @param {ApiClientOptions} clientOptions
+   * @param {AccountEntity} account the user account
+   */
+  constructor(worker, clientOptions, account) {
+    this.worker = worker;
+    this.resourceModel = new ResourceModel(clientOptions, account);
+  }
+
+  /**
+   * Whenever one intends to check the status of the call-to-action (authenticated / unauthenticated mode)
+   * @param requestId
+   */
+  async checkStatus(requestId) {
+    try {
+      const auth = new GpgAuth();
+      const status = await auth.checkAuthStatus({requestApi: false});
+      this.worker.port.emit(requestId, "SUCCESS", status);
+    } catch (error) {
+      /*
+       * When we are in a logged out mode and there's some cleaning of the local storage
+       * the check status request the api. In case of unauthenticated user, it throws a 401
+       * that we catch right here
+       */
+      this.worker.port.emit(requestId, "SUCCESS", {isAuthenticated: false});
+    }
+  }
+
+  /**
+   * Whenever one intends to know the count of suggested resources
+   * @param requestId The identifier of the request
+   */
+  async countSuggestedResourcesCount(requestId) {
+    try {
+      const suggestedResourcesCount = await this.resourceModel.countSuggestedResources(this.worker.tab.url);
+      this.worker.port.emit(requestId, "SUCCESS", suggestedResourcesCount);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(requestId, 'ERROR', error);
+    }
+  }
+
+
+  /**
+   * Whenever the user executes the inform call-to-action
+   * @param requestId The identifier of the request
+   */
+  async execute(requestId) {
+    try {
+      const auth = new GpgAuth();
+      const status = await auth.checkAuthStatus({requestApi: false});
+      if (!status.isAuthenticated) {
+        const queryParameters = [
+          {name: "uiMode", value: "detached"},
+          {name: "feature", value: "login"}
+        ];
+        await QuickAccessService.openInDetachedMode(queryParameters);
+        this.worker.port.emit(requestId, "SUCCESS");
+      } else if (status.isMfaRequired) {
+        browser.tabs.create({url: User.getInstance().settings.getDomain(), active: true});
+        this.worker.port.emit(requestId, "SUCCESS");
+      } else {
+        const webIntegrationWorker = await WorkerService.get('WebIntegration', this.worker.tab.id);
+        webIntegrationWorker.port.emit('passbolt.in-form-menu.open');
+      }
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(requestId, 'ERROR', error);
+    }
+  }
+}
+
+
+export default InformCallToActionController;

package/src/all/background_page/controller/locale/getLocaleController.js

@@ -0,0 +1,58 @@
+/**
+ * Get locale controller has for aim to retrieve the locale for an application
+ * having an already configured browser extension.
+ *
+ * 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         3.2.0
+ */
+import LocaleModel from "../../model/locale/localeModel";
+import {Config} from "../../model/config";
+import LocaleEntity from "../../model/entity/locale/localeEntity";
+
+
+class GetLocaleController {
+  /**
+   * GetLocaleController constructor.
+   * @param {Worker} worker
+   * @param {ApiClientOptions} apiClientOptions The api client options.
+   */
+  constructor(worker, apiClientOptions) {
+    this.worker = worker;
+    this.localeModel = new LocaleModel(apiClientOptions);
+  }
+
+  /**
+   * Get the locale following the priority:
+   * 1. The locale of the user if set.
+   * 2. The locale of the organization if set and supported.
+   * 3. The default fallback locale.
+   * @returns {Promise<LocaleEntity>} The locale
+   */
+  async getLocale() {
+    let userLocale;
+    const userSettingsLocale = await Config.read('user.settings.locale');
+    if (userSettingsLocale) {
+      userLocale = new LocaleEntity({locale: userSettingsLocale});
+    }
+
+    const locale = userLocale
+      || await this.localeModel.getOrganizationLocale()
+      || LocaleModel.DEFAULT_LOCALE;
+
+    // @todo It is not the best place to initialize the background page i18next library.
+    this.localeModel.initializeI18next(locale);
+
+    return locale;
+  }
+}
+
+export default GetLocaleController;

package/src/all/background_page/controller/mfaPolicy/hasUserPostponedUserSettingInvitationController.js

@@ -0,0 +1,50 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * 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) 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         3.10.0
+ */
+
+import PostponeUserSettingInvitationService from '../../service/invitation/postponeUserSettingInvitationService';
+
+class HasUserPostponedUserSettingInvitationMFAPolicyController {
+  /**
+   * HasUserPostponedUserSettingInvitationMFAPolicyController constructor
+   * @param {Worker} worker
+   * @param {string} requestId uuid
+   */
+  constructor(worker, requestId) {
+    this.worker = worker;
+    this.requestId = requestId;
+  }
+
+  /**
+   * Controller executor.
+   * @returns {Promise<bool>}
+   */
+  async _exec() {
+    try {
+      const hasPostponedInvitation = await this.exec();
+      this.worker.port.emit(this.requestId, "SUCCESS", hasPostponedInvitation);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Check if the user has postponed the MFA Policy enrollment invitation.
+   */
+  exec() {
+    return PostponeUserSettingInvitationService.hasPostponedMFAPolicy();
+  }
+}
+
+export default HasUserPostponedUserSettingInvitationMFAPolicyController;

package/src/all/background_page/controller/mfaPolicy/hasUserPostponedUserSettingInvitationController.test.js

@@ -0,0 +1,32 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * 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) 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         3.10.0
+ */
+
+import PostponeUserSettingInvitationService from "../../service/invitation/postponeUserSettingInvitationService";
+import HasUserPostponedUserSettingInvitationController from "./hasUserPostponedUserSettingInvitationController";
+
+describe("hasUserPostponedUserSettingInvitationController", () => {
+  it("can get the mfa enrollment invitation status", () => {
+    expect.assertions(2);
+    const controller = new HasUserPostponedUserSettingInvitationController();
+    const defaultValue = controller.exec();
+
+    expect(defaultValue).toBe(false);
+
+    PostponeUserSettingInvitationService.postponeMFAPolicy();
+
+    const setValue = controller.exec();
+    expect(setValue).toBe(true);
+  });
+});
+

package/src/all/background_page/controller/mfaPolicy/mfaGetMfaSettingsController.js

@@ -0,0 +1,51 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * 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) 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         3.10.0
+ */
+
+import MultiFactorAuthenticationModel from '../../model/multiFactorAuthentication/multiFactorAuthenticationModel';
+
+class MfaGetMfaSettingsController {
+  /**
+   * MfaGetPolicyController constructor
+   * @param {Worker} worker
+   * @param {string} requestId uuid
+   */
+  constructor(worker, requestId, apiClientOptions) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.multiFactorAuthenticationModel = new MultiFactorAuthenticationModel(apiClientOptions);
+  }
+
+  /**
+   * Controller executor.
+   * @returns {Promise<string>}
+   */
+  async _exec() {
+    try {
+      const policy = await this.exec();
+      this.worker.port.emit(this.requestId, "SUCCESS", policy);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * retrieve the MFA Policy.
+   */
+  exec() {
+    return this.multiFactorAuthenticationModel.getMfaSettings();
+  }
+}
+
+export default MfaGetMfaSettingsController;

package/src/all/background_page/controller/mfaPolicy/mfaGetMfaSettingsController.test.data.js

@@ -0,0 +1,21 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * 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) 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         3.10.0
+ */
+
+export const mfaDto = (data = {}) => {
+  const defaultData = {
+    MfaAccountSettings: {totp: false, duo: false, yubikey: false},
+    MfaOrganizationSettings: {totp: true, duo: false, yubikey: false}
+  };
+  return Object.assign(defaultData, data);
+};