passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/model/role/roleModel.js

@@ -11,9 +11,9 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         v3.0.0
  */
-const {RolesCollection} = require('../entity/role/rolesCollection');
-const {RolesLocalStorage} = require('../../service/local_storage/rolesLocalStorage');
-const {RoleService} = require('../../service/api/role/roleService');
+import RolesLocalStorage from "../../service/local_storage/rolesLocalStorage";
+import RoleService from "../../service/api/role/roleService";
+import RolesCollection from "passbolt-styleguide/src/shared/models/entity/role/rolesCollection";
 
 class RoleModel {
   /**
@@ -31,7 +31,7 @@ class RoleModel {
    *
    * @return {RolesCollection}
    */
-  async updateLocalStorage () {
+  async updateLocalStorage() {
     const rolesDtos = await this.roleService.findAll();
     const rolesCollection = new RolesCollection(rolesDtos);
     await RolesLocalStorage.set(rolesCollection);
@@ -50,7 +50,7 @@ class RoleModel {
       return new RolesCollection(rolesDto);
     }
     return this.updateLocalStorage();
-  };
+  }
 }
 
-exports.RoleModel = RoleModel;
+export default RoleModel;

package/src/all/background_page/model/setup/setupModel.js

@@ -10,10 +10,12 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {UserEntity} = require("../entity/user/userEntity");
-const {SetupEntity} = require("../entity/setup/setupEntity");
-const {SetupService} = require("../../service/api/setup/setupService");
-const {UserService} = require("../../service/api/user/userService");
+import AccountRecoveryOrganizationPolicyEntity from "../entity/accountRecovery/accountRecoveryOrganizationPolicyEntity";
+import UserService from "../../service/api/user/userService";
+import SetupService from "../../service/api/setup/setupService";
+import UserEntity from "../entity/user/userEntity";
+import Validator from "validator";
+import UserPassphrasePoliciesEntity from "passbolt-styleguide/src/shared/models/entity/userPassphrasePolicies/userPassphrasePoliciesEntity";
 
 class SetupModel {
   /**
@@ -28,76 +30,127 @@ class SetupModel {
   }
 
   /**
-   * Find setup info. Retrieve the user profile and server public key and return a setup entity
-   * @param {string} userId The user id
-   * @param {string} token The setup token
-   * populated with these information.
-   * @returns {Promise<UserEntity>}
+   * Start recover.
+   * The API will return the necessary data to complete the journey:
+   * - user and its meta data
+   * - account recovery organization policy
+   *
+   * @param {string} userId The user id to start the setup for.
+   * @param {string} authenticationTokenToken The authentication token.
+   * @return {Promise<{user: UserEntity, accountRecoveryOrganizationPolicy: AccountRecoveryOrganizationPolicyEntity, userPassphrasePolicies: UserPassphrasePoliciesEntity}>}
    * @throws {Error} if options are invalid or API error
    */
-  async findSetupInfo(userId, token) {
-    let userDto = null;
+  async startSetup(userId, authenticationTokenToken) {
+    let user, accountRecoveryOrganizationPolicy, userDto, accountRecoveryOrganizationPolicyDto, userPassphrasePoliciesDto, userPassphrasePolicies;
+
+    if (!Validator.isUUID(userId)) {
+      throw new TypeError("userId should be a valid uuid.");
+    }
+    if (!Validator.isUUID(authenticationTokenToken)) {
+      throw new TypeError("authenticationTokenToken should be a valid uuid.");
+    }
+
     try {
-      const {user} = await this.setupService.findSetupInfo(userId, token);
-      userDto = user;
+      const result = await this.setupService.findSetupInfo(userId, authenticationTokenToken);
+      userDto = result?.user;
+      accountRecoveryOrganizationPolicyDto = result?.account_recovery_organization_policy;
+      userPassphrasePoliciesDto = result?.user_passphrase_policy;
     } catch (error) {
       // If the entry point doesn't exist or return a 500, the API version is <v3.
       const code = error.data && error.data.code;
       if (code === 404 || code === 500) {
-        userDto = await this.setupService.findLegacySetupInfo(userId, token);
+        userDto = await this.setupService.findLegacySetupInfo(userId, authenticationTokenToken);
       } else {
-        throw error
+        throw error;
       }
     }
-    return new UserEntity(userDto);
+
+    if (userDto) {
+      user = new UserEntity(userDto);
+    }
+    if (accountRecoveryOrganizationPolicyDto) {
+      accountRecoveryOrganizationPolicy = new AccountRecoveryOrganizationPolicyEntity(accountRecoveryOrganizationPolicyDto);
+    }
+    if (userPassphrasePoliciesDto) {
+      userPassphrasePolicies = new UserPassphrasePoliciesEntity(userPassphrasePoliciesDto);
+    }
+
+    return {user, accountRecoveryOrganizationPolicy, userPassphrasePolicies};
   }
 
   /**
-   * Find setup info. Retrieve the user profile and server public key and return a setup entity
-   * @param {string} userId The user id
-   * @param {string} token The setup token
-   * populated with these information.
-   * @returns {Promise<UserEntity>}
-   * @throws {Error} if options are invalid or API error
+   * Start recover.src/all/background_page/model/entity/accountRecovery/accountRecoveryRequestEntity.js
+   * The API will return the necessary data to complete the journey:
+   * - user and its meta data
+   * - account recovery organization policy
+   *
+   * @param {string} userId The user id to start the recover for.
+   * @param {string} authenticationTokenToken The authentication token.
+   * @return {Promise<{user: UserEntity, userPassphrasePolicies: UserPassphrasePoliciesEntity}>}
    */
-  async findRecoverInfo(userId, token) {
-    let userDto = null;
+  async startRecover(userId, authenticationTokenToken) {
+    let user, userDto, userPassphrasePoliciesDto, userPassphrasePolicies;
+
+    if (!Validator.isUUID(userId)) {
+      throw new TypeError("userId should be a valid uuid.");
+    }
+    if (!Validator.isUUID(authenticationTokenToken)) {
+      throw new TypeError("authenticationTokenToken should be a valid uuid.");
+    }
+
     try {
-      const {user} = await this.setupService.findRecoverInfo(userId, token);
-      userDto = user;
+      const result = await this.setupService.findRecoverInfo(userId, authenticationTokenToken);
+      userDto = result?.user;
+      userPassphrasePoliciesDto = result?.user_passphrase_policy;
     } catch (error) {
       // If the entry point doesn't exist or return a 500, the API version is <v3.
-      const code = error.data && error.data.code
+      const code = error.data && error.data.code;
       if (code === 404 || code === 500) {
-        userDto = await this.setupService.findLegacyRecoverInfo(userId, token);
+        userDto = await this.setupService.findLegacyRecoverInfo(userId, authenticationTokenToken);
       } else {
-        throw error
+        throw error;
       }
     }
-    return new UserEntity(userDto);
+    if (userDto) {
+      user = new UserEntity(userDto);
+    }
+    if (userPassphrasePoliciesDto) {
+      userPassphrasePolicies = new UserPassphrasePoliciesEntity(userPassphrasePoliciesDto);
+    }
+
+    return {user, userPassphrasePolicies};
   }
 
   /**
    * Complete the setup.
-   * @param {SetupEntity} setupEntity The setup entity
+   * @param {AccountSetupEntity} account The account being set up.
    * @returns {Promise<void>}
    * @throws {Error} if options are invalid or API error
    */
-  async complete(setupEntity) {
-    const completeDto = setupEntity.toCompleteDto();
-    await this.setupService.complete(setupEntity.userId, completeDto);
+  async completeSetup(account) {
+    const completeDto = account.toCompleteSetupDto();
+    await this.setupService.complete(account.userId, completeDto);
   }
 
   /**
-   * Complete the recovery
-   * @param {SetupEntity} setupEntity The setup entity
+   * Complete the recover.
+   * @param {AccountRecoverEntity|AccountAccountRecoveryEntity} account The account being recovered.
+   * @returns {Promise<void>}
+   */
+  async completeRecover(account) {
+    const recoverCompleteDto = account.toCompleteRecoverDto();
+    await this.setupService.completeRecover(account.userId, recoverCompleteDto);
+  }
+
+  /**
+   * Abort recover request.
+   * @param {AccountRecoverEntity|AccountAccountRecoveryEntity} account The account to abort the recover request for.
    * @returns {Promise<void>}
-   * @throws {Error} if options are invalid or API error
    */
-  async completeRecovery(setupEntity) {
-    const completeDto = setupEntity.toCompleteDto();
-    await this.setupService.completeRecovery(setupEntity.userId, completeDto);
+  async abortRecover(account) {
+    const abortRecoverDto = account.toAbortRecoverDto();
+    await this.setupService.abort(account.userId, abortRecoverDto);
   }
 }
 
-exports.SetupModel = SetupModel;
+export default SetupModel;

package/src/all/background_page/model/share/shareModel.js

@@ -0,0 +1,165 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SARL (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 SARL (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.6.0
+ */
+import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
+import Keyring from "../keyring";
+import EncryptMessageService from "../../service/crypto/encryptMessageService";
+import DecryptMessageService from "../../service/crypto/decryptMessageService";
+import ShareService from "../../service/api/share/shareService";
+
+class ShareModel {
+  /**
+   * Constructor
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    this.shareService = new ShareService(apiClientOptions);
+  }
+
+  /**
+   * Bulk share multiple resources.
+   * @param {array} resources The resources to share
+   * @param {array} changes The permissions changes to apply
+   * @param {openpgp.PrivateKey} privateKey The decrypted private key to use to decrypt the message.
+   * @param {function} progressCallback Notify the user with this callback
+   */
+  async bulkShareResources(resources, changes, privateKey, progressCallback) {
+    const resourcesChanges = this.bulkShareAggregateChanges(resources, changes);
+    const resourcesNewUsers = await this.bulkShareSimulate(resources, resourcesChanges, progressCallback);
+    const resourcesSecrets = await this.bulkShareEncrypt(resources, resourcesNewUsers, privateKey, progressCallback);
+    for (const resourceId in resourcesChanges) {
+      if (Object.prototype.hasOwnProperty.call(resourcesChanges, resourceId)) {
+        const resource = resources.find(resource => resource.id === resourceId);
+        const permissions = resourcesChanges[resourceId];
+        const secrets = resourcesSecrets[resourceId] || [];
+        progressCallback(`Sharing password ${resource.name}`);
+        await this.shareService.shareResource(resourceId, {permissions: permissions, secrets: secrets});
+      }
+    }
+  }
+
+  /**
+   * Bulk share multiple folders.
+   * @param {FoldersCollection} foldersCollection
+   * @param {PermissionChangesCollection} changesCollection
+   * @param {function} progressCallback Notify the user with this callback
+   */
+  async bulkShareFolders(foldersCollection, changesCollection, progressCallback) {
+    for (const folderEntity of foldersCollection) {
+      const permissions = changesCollection.filterByAcoForeignKey(folderEntity.id);
+      if (permissions && permissions.length) {
+        await progressCallback(`Updating folder ${folderEntity.name} permissions`);
+        await this.shareService.shareFolder(folderEntity.id, {permissions: permissions.toDto()});
+      }
+    }
+  }
+
+  /**
+   * Aggregate the changes by Acos.
+   * @param {array} acos The resources to share
+   * @param {array} changes The changes to apply
+   * @return {object}
+   */
+  bulkShareAggregateChanges(acos, changes) {
+    if (!acos || !Array.isArray(acos) || !acos.length) {
+      throw new TypeError('bulkShareAggregateChanges expect an array of ACOs');
+    }
+    if (!changes || !Array.isArray(changes) || !changes.length) {
+      throw new TypeError('bulkShareAggregateChanges expect an array of changes');
+    }
+
+    const acosChanges = {};
+    acos.forEach(aco => {
+      const acoChanges = changes.filter(change => change.aco_foreign_key === aco.id);
+      if (acoChanges.length) {
+        acosChanges[aco.id] = acoChanges;
+      }
+    });
+
+    return acosChanges;
+  }
+
+  /**
+   * Simulate the changes to apply to the resources
+   * @param {array} resources
+   * @param {object} resourcesChanges The changes aggregated by resource
+   * @param {function} progressCallback Notify the user with this callback
+   * @returns {object}
+   */
+  async bulkShareSimulate(resources, resourcesChanges, progressCallback) {
+    const usersToEncryptFor = {};
+
+    for (const resourceId in resourcesChanges) {
+      const resource = resources.find(resource => resource.id === resourceId);
+      progressCallback(`Validating share operation for ${resource.name}`);
+      const simulateResult = await this.shareService.simulateShareResource(resourceId, resourcesChanges[resourceId]);
+      const simulateAddedUsers = simulateResult.changes.added;
+      if (simulateAddedUsers.length) {
+        usersToEncryptFor[resourceId] = simulateAddedUsers.reduce((carry, user) => [...carry, user.User.id], []);
+      }
+    }
+
+    return usersToEncryptFor;
+  }
+
+  /**
+   * Encrypt the resources secrets for all the new users
+   * @param {array} resources The resources to share
+   * @param {object} resourcesNewUsers The list of new users to share the resources aggregated by resource
+   * @param {openpgp.PrivateKey} privateKey The decrypted private key to use to decrypt the message.
+   * @param {function} progressCallback Notify the user with this callback
+   * @returns {object} A list of secrets as expected by the passbolt API
+   * [
+   *  {
+   *    resource_id: UUID,
+   *    user_id: UUID,
+   *    data: string
+   *  }
+   * ]
+   */
+  async bulkShareEncrypt(resources, resourcesNewUsers, privateKey, progressCallback) {
+    const keyring = new Keyring();
+    const secrets = {};
+
+    for (const resourceId in resourcesNewUsers) {
+      const resource = resources.find(resource => resource.id === resourceId);
+      const originalMessage = await OpenpgpAssertion.readMessageOrFail(resource.secrets[0].data);
+      const users = resourcesNewUsers[resourceId];
+      progressCallback(`Encrypting for ${resource.name}`);
+      if (users && users.length) {
+        const message = await DecryptMessageService.decrypt(originalMessage, privateKey);
+        const encryptAllData = users.reduce((carry, userId) => [...carry, {userId: userId, message: message}], []);
+
+        const result = [];
+        for (const i in encryptAllData) {
+          const data = encryptAllData[i];
+          const userPublicArmoredKey = keyring.findPublic(data.userId).armoredKey;
+          const userPublicKey = await OpenpgpAssertion.readKeyOrFail(userPublicArmoredKey);
+          const messageEncrypted = await EncryptMessageService.encrypt(data.message, userPublicKey, [privateKey]);
+          result.push({
+            resource_id: resourceId,
+            user_id: data.userId,
+            data: messageEncrypted
+          });
+        }
+
+        secrets[resourceId] = result;
+      }
+    }
+
+    return secrets;
+  }
+}
+
+export default ShareModel;

package/src/all/background_page/model/sso/ssoDryRunModel.js

@@ -0,0 +1,53 @@
+/**
+ * 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.9.0
+ */
+import SsoDryRunService from "../../service/api/sso/ssoDryRunService";
+import {assertUuid} from "../../utils/assertions";
+import SsoLoginUrlEntity from "../entity/sso/ssoLoginUrlEntity";
+
+/**
+ * Model related to the SSO dry run
+ */
+class SsoDryRunModel {
+  /**
+   * Constructor
+   *
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    this.ssoDryRunService = new SsoDryRunService(apiClientOptions);
+  }
+
+  /**
+   * Get the URL to process a dry-run.
+   * @param {string} providerId the provider identifier
+   * @param {uuid} ssoSettingsId the sso draft settings id
+   * @returns {Promise<URL>}
+   */
+  async getUrl(providerId, ssoSettingsId) {
+    assertUuid(ssoSettingsId, "The SSO settings id should be a valid uuid.");
+
+    if (typeof(providerId) !== "string") {
+      throw new Error("The provider identifier should be a valid string");
+    }
+
+    const dryRunDto = {
+      sso_settings_id: ssoSettingsId
+    };
+    const dryRunUrl = await this.ssoDryRunService.getUrl(providerId, dryRunDto);
+    return new SsoLoginUrlEntity(dryRunUrl, providerId);
+  }
+}
+
+export default SsoDryRunModel;

package/src/all/background_page/model/sso/ssoKitServerPartModel.js

@@ -0,0 +1,71 @@
+/**
+ * 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.9.0
+ */
+import SsoKitServerPartService from "../../service/api/sso/ssoKitServerPartService";
+import {assertUuid} from "../../utils/assertions";
+import SsoKitServerPartEntity from "../entity/sso/ssoKitServerPartEntity";
+
+/**
+ * Model related to the SSO kit server part data
+ */
+class SsoKitServerPartModel {
+  /**
+   * Constructor
+   *
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    this.ssoKitServerPartService = new SsoKitServerPartService(apiClientOptions);
+  }
+
+  /**
+   * Find the server part SSO kit given an SSO kit id, user id and an authorisation token using Passbolt API
+   *
+   * @param {string} ssoKitId a code given by the third party auth
+   * @param {string} userId a code given by the third party auth
+   * @param {string} ssoToken a code given by the third party auth
+   * @return {Promise<SsoKitServerPartEntity>}
+   */
+  async getSsoKit(ssoKitId, userId, ssoToken) {
+    assertUuid(ssoKitId, "The SSO kit id should be a valid uuid.");
+    assertUuid(userId, "The user id should be a valid uuid.");
+    assertUuid(ssoToken, "The SSO token should be a valid uuid.");
+
+    const ssoUserServerDataDto = await this.ssoKitServerPartService.getSsoKit(ssoKitId, userId, ssoToken);
+    return new SsoKitServerPartEntity(ssoUserServerDataDto);
+  }
+
+  /**
+   * Saves the generated server part SSO kit.
+   * @param {SsoKitServerPartEntity} ssoKitServerPartEntity the server part SSO kit
+   * @returns {Promise<SsoKitServerPartEntity>}
+   */
+  async setupSsoKit(ssoKitServerPartEntity) {
+    const ssoKit = await this.ssoKitServerPartService.setupSsoKit(ssoKitServerPartEntity);
+    return new SsoKitServerPartEntity(ssoKit);
+  }
+
+  /**
+   * Delete an SSO kit matching the given id.
+   * @param {uuid} ssoKitId
+   * @returns {Promise<void>}
+   */
+  async deleteSsoKit(ssoKitId) {
+    assertUuid(ssoKitId, "The SSO kit id should be a valid uuid.");
+
+    await this.ssoKitServerPartService.deleteSsoKit(ssoKitId);
+  }
+}
+
+export default SsoKitServerPartModel;

package/src/all/background_page/model/sso/ssoLoginModel.js

@@ -0,0 +1,46 @@
+/**
+ * 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.9.0
+ */
+import {assertUuid} from "../../utils/assertions";
+import SsoLoginUrlEntity from "../entity/sso/ssoLoginUrlEntity";
+import SsoLoginService from "../../service/api/sso/ssoLoginService";
+
+/**
+ * Model related to the SSO Azure Login URL
+ */
+class SsoLoginModel {
+  /**
+   * Constructor
+   *
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    this.ssoLoginService = new SsoLoginService(apiClientOptions);
+  }
+
+  /**
+   * Get the Azure login URL given a user id
+   * @param {string} providerId the provider identifier
+   * @param {uuid} userid
+   * @return {Promise<URL>}
+   */
+  async getLoginUrl(providerId, userId) {
+    assertUuid(userId, "The user id should be a valid uuid.");
+
+    const redirectUrlDto = await this.ssoLoginService.getLoginUrl(providerId, {user_id: userId});
+    return new SsoLoginUrlEntity(redirectUrlDto, providerId);
+  }
+}
+
+export default SsoLoginModel;

package/src/all/background_page/model/sso/ssoSettingsModel.js

@@ -0,0 +1,88 @@
+/**
+ * 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.9.0
+ */
+import SsoSettingsService from "../../service/api/sso/ssoSettingsService";
+import SsoSettingsEntity from "passbolt-styleguide/src/shared/models/entity/ssoSettings/SsoSettingsEntity";
+/**
+ * Model related to the SSO Settings
+ */
+class SsoSettingsModel {
+  /**
+   * Constructor
+   *
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    this.ssoSettingsService = new SsoSettingsService(apiClientOptions);
+  }
+
+  /**
+   * Save the given settings entity as a draft onto the API.
+   * @param {SsoSettingsEntity} ssoSettingsEntity the entity to save
+   * @returns {Promise<SsoSettingsEntity>} the saved entity
+   */
+  async saveDraft(ssoSettingsEntity) {
+    const savedDraft = await this.ssoSettingsService.saveDraft(ssoSettingsEntity.toDto(SsoSettingsEntity.DEFAULT_CONTAIN));
+    return new SsoSettingsEntity(savedDraft);
+  }
+
+  /**
+   * Return the sso settings for a given id using Passbolt API.
+   *
+   * @param {string} ssoSettingsId uuid
+   * @returns {Promise<SsoSettingsEntity>}
+   */
+  async getById(ssoSettingsId) {
+    const ssoSettingsDto = await this.ssoSettingsService.get(ssoSettingsId);
+    return new SsoSettingsEntity(ssoSettingsDto);
+  }
+
+  /**
+   * Find the current active SSO settings using Passbolt API
+   * @param {object} contains
+   * @returns {Promise<SsoSettingsEntity>}
+   */
+  async getCurrent(contains) {
+    const ssoSettingsDto = await this.ssoSettingsService.getCurrent(contains);
+    return new SsoSettingsEntity(ssoSettingsDto);
+  }
+
+  /**
+   * Activates an SSO settings matching a given id using Passbolt API
+   *
+   * @param {uuid} ssoSettingsId
+   * @param {uuid} ssoToken
+   * @returns {Promise<SsoSettingsEntity>}
+   */
+  async activate(ssoSettingsId, ssoToken) {
+    const activationDto = {
+      token: ssoToken,
+      status: "active"
+    };
+    const savedDraft = await this.ssoSettingsService.activateSettings(ssoSettingsId, activationDto);
+    return new SsoSettingsEntity(savedDraft);
+  }
+
+  /**
+   * Deletes an SSO settings matching a given id using Passbolt API
+   *
+   * @param {uuid} ssoSettingsId
+   * @returns {Promise<void>}
+   */
+  async delete(ssoSettingsId) {
+    await this.ssoSettingsService.delete(ssoSettingsId);
+  }
+}
+
+export default SsoSettingsModel;