passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/model/log.js

@@ -7,21 +7,16 @@
  * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
  */
 
-var Config = require('./config');
-var logSettings = Config.read('log');
+import {Config} from "./config";
+
+const logSettings = Config.read('log');
 
 // Logs type.
-var ERROR = 'error';
-exports.ERROR = ERROR;
-var WARNING = 'warning';
-exports.WARNING = WARNING;
-var INFO = 'info';
-exports.INFO = INFO;
-var DEBUG = 'debug';
-exports.DEBUG = DEBUG;
+const ERROR = 'error';
+const WARNING = 'warning';
 
 // Logs level mapping.
-var logLevelMapping = {
+const logLevelMapping = {
   error: 1,
   warning: 2,
   info: 3,
@@ -29,28 +24,19 @@ var logLevelMapping = {
 };
 
 // The stored logs.
-var _logs = [];
-exports._logs = _logs;
+let _logs = [];
 
 /**
  * The Logger constructor.
  * @constructor
  */
-var Log = function () {};
-
-/**
- * Get all the logs.
- * @returns {*}
- */
-Log.readAll = function () {
-  return _logs;
-};
+const Log = function() {};
 
 /**
  * Write a log.
  * @param log {object} The log to write.
  */
-Log.write = function (log) {
+Log.write = function(log) {
   // If no logging is required, or the log level is lower than the log level message, leave.
   if (logSettings.level == 0 || logSettings.level < logLevelMapping[log.level]) {
     return;
@@ -58,7 +44,7 @@ Log.write = function (log) {
 
   // add a timestamp
   function formatTime(i) {
-    return (i < 10) ? "0" + i : i;
+    return (i < 10) ? `0${i}` : i;
   }
 
   if (!log.date) {
@@ -68,14 +54,14 @@ Log.write = function (log) {
   const m = formatTime(log.date.getMinutes());
   const s = formatTime(log.date.getSeconds());
   const ms = formatTime(log.date.getMilliseconds());
-  log.created =  h + ':' + m + ':' + s + ':' + ms;
+  log.created =  `${h}:${m}:${s}:${ms}`;
 
   // Register the log.
   _logs.push(log);
 
   // The log could also be displayed on the console.
   if (logSettings.console) {
-    var consoleLog = log.created + ' [' + log.level + '] ' + log.message;
+    const consoleLog = `${log.created} [${log.level}] ${log.message}`;
     if (log.level === ERROR) {
       console.error(consoleLog);
     } else if (log.level === WARNING) {
@@ -89,15 +75,8 @@ Log.write = function (log) {
 /**
  * Flush a log.
  */
-Log.flush = function () {
-  _logs = [];
-};
-
-/**
- * Flush a log.
- */
-Log.init = function () {
+Log.init = function() {
   _logs = [];
 };
 
-exports.Log = Log;
+export default Log;

package/src/all/background_page/model/mobileTransfer/mobileTransferModel.js

@@ -0,0 +1,63 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         v3.2.0
+ */
+import MobileTransferService from "../../service/api/mobileTransferService/mobileTransferService";
+import TransferEntity from "../../model/entity/transfer/transferEntity";
+
+class MobileTransferModel {
+  /**
+   * Constructor
+   *
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    this.mobileTransferService = new MobileTransferService(apiClientOptions);
+  }
+
+  /**
+   * Get transfer info using Passbolt API
+   *
+   * @params {string} transferId uuid
+   * @throws {Error} if API call fails, service unreachable, etc.
+   * @return {TransferEntity}
+   */
+  async get(transferId) {
+    const transferDto = await this.mobileTransferService.get(transferId);
+    return new TransferEntity(transferDto);
+  }
+
+  /**
+   * Create a transfer using Passbolt API
+   *
+   * @param {TransferEntity} transferEntity
+   * @returns {Promise<TransferEntity>}
+   */
+  async create(transferEntity) {
+    const transferDto = await this.mobileTransferService.create(transferEntity.toDto());
+    return new TransferEntity(transferDto);
+  }
+
+  /**
+   * Update a transfer using Passbolt API
+   *
+   * @param {TransferEntity} transferEntity
+   * @returns {Promise<TransferEntity>}
+   */
+  async update(transferEntity) {
+    const transferDto = await this.mobileTransferService.update(transferEntity.id, transferEntity.toDto());
+    return new TransferEntity(transferDto);
+  }
+}
+
+export default MobileTransferModel;

package/src/all/background_page/model/multiFactorAuthentication/multiFactorAuthenticationModel.js

@@ -10,9 +10,14 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {UserEntity} = require("../entity/user/userEntity");
-const {UserLocalStorage} = require("../../service/local_storage/userLocalStorage");
-const {MultiFactorAuthenticationService} = require("../../service/api/multiFactorAuthentication/multiFactorAuthenticationService");
+import UserLocalStorage from "../../service/local_storage/userLocalStorage";
+import MultiFactorAuthenticationService from "../../service/api/multiFactorAuthentication/multiFactorAuthenticationService";
+import UserEntity from "../entity/user/userEntity";
+import MultiFactorAuthenticationPolicyService from '../../service/api/multiFactorAuthentication/multiFactorAuthenticationPolicyService';
+import MfaPolicyEntity from '../entity/mfa/mfaPolicyEntity';
+import MfaCombinedEnabledProvidersEntity from '../entity/mfa/mfaCombinedEnabledProvidersEntity';
+import MfaVerifyProviderEntity from "../entity/mfa/mfaVerifyProviderEntity";
+import MfaTotpSetupInfoEntity from "../entity/mfa/mfaTotpSetupInfoEntity";
 
 class MultiFactorAuthenticationModel {
   /**
@@ -23,6 +28,7 @@ class MultiFactorAuthenticationModel {
    */
   constructor(apiClientOptions) {
     this.multiFactorAuthenticationService = new MultiFactorAuthenticationService(apiClientOptions);
+    this.multiFactorAuthenticationPolicyService = new MultiFactorAuthenticationPolicyService(apiClientOptions);
   }
 
   /**
@@ -41,6 +47,80 @@ class MultiFactorAuthenticationModel {
       await UserLocalStorage.updateUser(userEntity);
     }
   }
+
+  /**
+   * Return the current MFA policy defined by the organization
+   *
+   * @returns {Promise<MfaPolicyEntity>}
+   * @public
+   */
+  async getPolicy() {
+    const policy = await this.multiFactorAuthenticationPolicyService.find();
+    return new MfaPolicyEntity(policy);
+  }
+
+  /**
+   * Return the otp setup info
+   * @returns {Promise<string>}
+   * @public
+   */
+  async getMfaToTpSetupInfo() {
+    const dto = await this.multiFactorAuthenticationService.getMfaToTpSetupInfo();
+    const QRCode = new MfaTotpSetupInfoEntity(dto).toDto();
+    return QRCode.otpProvisioningUri;
+  }
+
+  /**
+   * Return the mfa settings for an organization and user
+   *
+   * @returns {Promise<MfaCombinedEnabledProvidersEntity>}
+   * @public
+   */
+  async getMfaSettings() {
+    const setting = await this.multiFactorAuthenticationService.getSettings();
+    return new MfaCombinedEnabledProvidersEntity(setting);
+  }
+
+  /**
+   * Setup the topt provider
+   * @param   {MfaSetupTotpEntity} totpEntity
+   * @returns {Promise<void>}
+   * @public
+   */
+  async setupTotp(totpEntity) {
+    await this.multiFactorAuthenticationService.setupTotp(totpEntity.toDto());
+  }
+
+  /**
+   * Setup the yubikey provider
+   * @param   {MfaSetupYubikeyEntity} totpEntity
+   * @returns {Promise<void>}
+   * @public
+   */
+  async setupYubikey(totpEntity) {
+    await this.multiFactorAuthenticationService.setupYubikey(totpEntity.toDto());
+  }
+
+  /**
+   * Verify the provider setup
+   * @param   {MfaProviderEntity} providerEntity
+   * @returns {Promise<void>}
+   * @public
+   */
+  async verifyProvider(providerEntity) {
+    const result =  await this.multiFactorAuthenticationService.verifyProvider(providerEntity.provider);
+    return new MfaVerifyProviderEntity(result);
+  }
+
+  /**
+   * Remove the provider from configuration
+   * @param   {MfaProviderEntity} providerEntity
+   * @returns {Promise<void>}
+   * @public
+   */
+  async removeProvider(providerEntity) {
+    await this.multiFactorAuthenticationService.removeProvider(providerEntity.provider);
+  }
 }
 
-exports.MultiFactorAuthenticationModel = MultiFactorAuthenticationModel;
+export default MultiFactorAuthenticationModel;

package/src/all/background_page/model/multiFactorAuthentication/multiFactorAuthenticationModel.test.js

@@ -0,0 +1,84 @@
+/**
+ * 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         4.4.0
+ */
+
+import {enableFetchMocks} from "jest-fetch-mock";
+import {mockApiResponse} from "../../../../../test/mocks/mockApiResponse";
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import MultiFactorAuthenticationModel from "./multiFactorAuthenticationModel";
+import {defaultSetupTotpData} from "../entity/mfa/mfaSetupTotpEntity.test.data";
+import {defaultVerifyProviderData} from "../entity/mfa/mfaVerifyProviderEntity.test.data";
+import MfaVerifyProviderEntity from "../entity/mfa/mfaVerifyProviderEntity";
+import {defaultMfaProviderData} from "../entity/mfa/mfaProviderEntity.test.data";
+import MfaSetupTotpEntity from "../entity/mfa/mfaSetupTotpEntity";
+import MfaProviderEntity from "../entity/mfa/mfaProviderEntity";
+import {defaultTotpQrCodeData} from "../entity/mfa/mfaTotpSetupInfoEntity.test.data";
+
+beforeEach(() => {
+  enableFetchMocks();
+});
+
+
+describe("MultiFactorAuthenticationModel", () => {
+  let model;
+
+  beforeEach(() => {
+    model = new MultiFactorAuthenticationModel(defaultApiClientOptions());
+  });
+
+  it("Should able to setup totp", async() => {
+    expect.assertions(1);
+    jest.spyOn(model.multiFactorAuthenticationService, "setupTotp");
+
+    fetch.doMock(() => mockApiResponse({}));
+
+    await model.setupTotp(new MfaSetupTotpEntity(defaultSetupTotpData()));
+
+    expect(model.multiFactorAuthenticationService.setupTotp).toHaveBeenCalledWith(defaultSetupTotpData());
+  });
+
+  it("Should able to verify a MFA configuration", async() => {
+    expect.assertions(2);
+    jest.spyOn(model.multiFactorAuthenticationService, "verifyProvider");
+
+    fetch.doMock(() => mockApiResponse(defaultVerifyProviderData()));
+
+    const result = await model.verifyProvider(new defaultMfaProviderData());
+
+    expect(model.multiFactorAuthenticationService.verifyProvider).toHaveBeenCalledWith("totp");
+    expect(result).toEqual(new MfaVerifyProviderEntity(defaultVerifyProviderData()));
+  });
+
+  it("Should able to remove a MFA provider", async() => {
+    expect.assertions(1);
+    jest.spyOn(model.multiFactorAuthenticationService, "removeProvider");
+
+    fetch.doMock(() => mockApiResponse({}));
+
+    await model.removeProvider(new MfaProviderEntity(defaultMfaProviderData()));
+
+    expect(model.multiFactorAuthenticationService.removeProvider).toHaveBeenCalledWith("totp");
+  });
+
+  it("Should retrieve the QR code uri from API", async() => {
+    expect.assertions(2);
+    jest.spyOn(model.multiFactorAuthenticationService, "getMfaToTpSetupInfo");
+
+    fetch.doMock(() => mockApiResponse(defaultTotpQrCodeData()));
+
+    const result = await model.getMfaToTpSetupInfo();
+
+    expect(model.multiFactorAuthenticationService.getMfaToTpSetupInfo).toHaveBeenCalled();
+    expect(result).toEqual(defaultTotpQrCodeData().otpProvisioningUri);
+  });
+});

package/src/all/background_page/model/organizationSettings/organizationSettingsModel.js

@@ -0,0 +1,94 @@
+/**
+ * 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 OrganizationSettingsService from "../../service/api/organizationSettings/organizationSettingsService";
+import OrganizationSettingsEntity from "../entity/organizationSettings/organizationSettingsEntity";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+
+// Settings local cache.
+let _settings;
+
+/**
+ * Organization settings model.
+ */
+class OrganizationSettingsModel {
+  /**
+   * Constructor
+   *
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    this.organizationSettingsService = new OrganizationSettingsService(apiClientOptions);
+  }
+
+  /**
+   * Set the settings.
+   * @params {OrganizationSettingsEntity} settings The settings
+   */
+  static set(settings) {
+    if (!(settings instanceof OrganizationSettingsEntity)) {
+      throw new Error('The settings should be an instance of OrganizationSettingsEntity');
+    }
+    _settings = settings;
+  }
+
+  /**
+   * get the cached settings if any.
+   * @return {OrganizationSettingsEntity|null}
+   */
+  static get() {
+    return _settings || null;
+  }
+
+  /**
+   * Returns the organization settings from the local cache or requests the server.
+   * @param {boolean} refreshCache Should request the API to retrieve the organization settings and refresh the cache.
+   * Default false
+   * @returns {Promise<OrganizationSettingsEntity>}
+   */
+  async getOrFind(refreshCache = false) {
+    if (refreshCache || !_settings) {
+      _settings = await this.find();
+    }
+    return _settings;
+  }
+
+  /**
+   * Flush the settings cache
+   */
+  static flushCache() {
+    _settings = null;
+  }
+
+  /**
+   * Find the organization settings.
+   * @returns {Promise<OrganizationSettingsEntity>}
+   */
+  async find() {
+    let organizationSettingsDto;
+
+    try {
+      organizationSettingsDto = await this.organizationSettingsService.find();
+    } catch (error) {
+      // When the cloud organization is disabled or not found, the cloud API returns a 403.
+      if (error instanceof PassboltApiFetchError
+        && error?.data?.code === 403) {
+        organizationSettingsDto = OrganizationSettingsEntity.disabledOrganizationSettings;
+      }
+    }
+    return new OrganizationSettingsEntity(organizationSettingsDto);
+  }
+}
+
+export default OrganizationSettingsModel;

package/src/all/background_page/model/passwordExpiry/passwordExpiryResourceModel.js

@@ -0,0 +1,49 @@
+/**
+ * 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         4.5.0
+ */
+
+import PasswordExpiryResourceService from "../../service/api/passwordExpiry/passwordExpiryResourceService";
+import {assertType} from "../../utils/assertions";
+import PasswordExpiryResourcesCollection from "../entity/passwordExpiry/passwordExpiryResourcesCollection";
+import ResourceLocalStorage from "../../service/local_storage/resourceLocalStorage";
+
+class PasswordExpiryResourceModel {
+  /**
+   * Constructor
+   *
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    this.passwordExpiryResourceService = new PasswordExpiryResourceService(apiClientOptions);
+  }
+
+  /**
+   * Update the password expiry date of resources on the API.
+   * @param {PasswordExpiryResourcesCollection} collection the collection to update
+   * @returns {Promise<void|Error>}
+   */
+  async update(collection) {
+    assertType(collection, PasswordExpiryResourcesCollection, 'The given entity is not a PasswordExpiryResourceCollection');
+    try {
+      await this.passwordExpiryResourceService.update(collection.toDto());
+      // Insert the updated resources expiry date in the local storage
+      await ResourceLocalStorage.updateResourcesExpiryDate(collection.passwordExpiryResources);
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+}
+
+export default PasswordExpiryResourceModel;

package/src/all/background_page/model/passwordExpiry/passwordExpiryResourceModel.test.js

@@ -0,0 +1,62 @@
+/**
+ * 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         4.5.0
+ */
+
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import ResourceLocalStorage from "../../service/local_storage/resourceLocalStorage";
+import PasswordExpiryResourcesCollection from "../entity/passwordExpiry/passwordExpiryResourcesCollection";
+import {defaultPasswordExpiryCollectionDto} from "../entity/passwordExpiry/passwordExpiryResourceCollection.test.data";
+import PasswordExpiryResourceModel from "./passwordExpiryResourceModel";
+
+jest.mock("../../service/local_storage/resourceLocalStorage");
+
+describe("PasswordExpiryResourceModel", () => {
+  describe('::update', () => {
+    it("Should call for the service to update the date on the API and run callbacks during the process", async() => {
+      expect.assertions(2);
+
+      const collectionDto = defaultPasswordExpiryCollectionDto();
+      const collection = new PasswordExpiryResourcesCollection(collectionDto);
+
+      const model = new PasswordExpiryResourceModel(defaultApiClientOptions());
+      jest.spyOn(model.passwordExpiryResourceService, "update").mockImplementation(collectionDto => {
+        expect(collectionDto).toStrictEqual(collection.toDto());
+      });
+
+      //Mock the local storage call and check if the given parameters are ok
+      ResourceLocalStorage.updateResourcesExpiryDate.mockImplementation(passwordExpiryCollection => {
+        const collection = new PasswordExpiryResourcesCollection(collectionDto);
+        expect(passwordExpiryCollection).toStrictEqual(collection.passwordExpiryResources);
+      });
+
+      await model.update(collection);
+    });
+
+    it("Should throw an Error if the something goes wrong during the process", async() => {
+      expect.assertions(1);
+
+      const collectionDto = defaultPasswordExpiryCollectionDto();
+      const collection = new PasswordExpiryResourcesCollection(collectionDto);
+
+      const model = new PasswordExpiryResourceModel(defaultApiClientOptions());
+      const expectedError = new Error("Something went wrong!");
+      jest.spyOn(model.passwordExpiryResourceService, "update").mockImplementation(() => { throw expectedError; });
+
+      try {
+        await model.update(collection);
+      } catch (e) {
+        expect(e).toStrictEqual(expectedError);
+      }
+    });
+  });
+});

package/src/all/background_page/model/passwordExpiry/passwordExpirySettingsModel.js

@@ -0,0 +1,110 @@
+/**
+ * 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         4.4.0
+ */
+
+import PasswordExpirySettingsService from "../../service/api/passwordExpiry/passwordExpirySettingsService";
+import {assertType, assertUuid} from "../../utils/assertions";
+import PasswordExpirySettingsEntity from "passbolt-styleguide/src/shared/models/entity/passwordExpiry/passwordExpirySettingsEntity";
+import OrganizationSettingsModel from "../organizationSettings/organizationSettingsModel";
+import PasswordExpiryProSettingsEntity from "passbolt-styleguide/src/shared/models/entity/passwordExpiryPro/passwordExpiryProSettingsEntity";
+import PasswordExpirySettingsLocalStorage from "../../service/local_storage/passwordExpirySettingsLocalStorage";
+
+class PasswordExpirySettingsModel {
+  /**
+   * Constructor
+   *
+   * @param {AccountEntity} account the user account
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(account, apiClientOptions) {
+    this.passwordExpirySettingsLocalStorage = new PasswordExpirySettingsLocalStorage(account);
+    this.passwordExpirySettingsService = new PasswordExpirySettingsService(apiClientOptions);
+    this.organisationSettingsModel = new OrganizationSettingsModel(apiClientOptions);
+  }
+
+  /**
+   * Get the password expiry data from the local storage or find it from the API.
+   * The API can send data that is not compatible with what's expected (like CE settings when the PRO is expected)
+   * In this case, an exception is catch and we ignore the settings and build new one from scratch to avoid
+   * the styleguide to crash.
+   * @param {boolean} refreshCache
+   * @returns {Promise<PasswordExpirySettingsEntity>}
+   */
+  async getOrFindOrDefault(refreshCache = false) {
+    try {
+      if (refreshCache) {
+        await this.passwordExpirySettingsLocalStorage.flush();
+      }
+
+      let passwordExpirySettingsDto = await this.passwordExpirySettingsLocalStorage.get();
+      if (!passwordExpirySettingsDto) {
+        passwordExpirySettingsDto = await this.passwordExpirySettingsService.find();
+      }
+      const passwordExpirySettingsEntity = await this.createFromDefault(passwordExpirySettingsDto);
+      this.passwordExpirySettingsLocalStorage.set(passwordExpirySettingsEntity.toDto());
+      return passwordExpirySettingsEntity;
+    } catch (error) {
+      console.error(error);
+    }
+    const passwordExpirySettingsEntity = await this.createFromDefault();
+    this.passwordExpirySettingsLocalStorage.set(passwordExpirySettingsEntity.toDto());
+    return passwordExpirySettingsEntity;
+  }
+
+  /**
+   * Saves the password expiry settings on the API.
+   * @param {PasswordExpirySettingsEntity|PasswordExpiryProSettingsEntity} passwordExpirySettingsEntity the entity to register
+   * @returns {Promise<PasswordExpirySettingsEntity>}
+   */
+  async save(passwordExpirySettingsEntity) {
+    const organizationSettings = await this.organisationSettingsModel.getOrFind();
+    const isAdvancedSettingsEnable = organizationSettings.isPluginEnabled("passwordExpiryPolicies");
+    if (!isAdvancedSettingsEnable) {
+      assertType(passwordExpirySettingsEntity, PasswordExpirySettingsEntity, 'The given entity is not a PasswordExpirySettingsEntity');
+    } else {
+      assertType(passwordExpirySettingsEntity, PasswordExpiryProSettingsEntity, 'The given entity is not a PasswordExpiryProSettingsEntity');
+    }
+    const passwordExpirySettingsDto = await this.passwordExpirySettingsService.create(passwordExpirySettingsEntity);
+    const passwordExpirySettingsEntityUpdated = await this.createFromDefault(passwordExpirySettingsDto);
+    this.passwordExpirySettingsLocalStorage.set(passwordExpirySettingsEntityUpdated.toDto());
+    return passwordExpirySettingsEntityUpdated;
+  }
+
+  /**
+   * Delete the password expiry settings on the API given an ID.
+   * @param {string<UUID>} passwordExpirySettingsId the ID of the entity to delete
+   * @returns {Promise<void>}
+   */
+  async delete(passwordExpirySettingsId) {
+    assertUuid(passwordExpirySettingsId, "The password expiry settings id should be a valid uuid.");
+    await this.passwordExpirySettingsService.delete(passwordExpirySettingsId);
+    await this.passwordExpirySettingsLocalStorage.flush();
+  }
+
+  /**
+   * Create model based the version using entity
+   * @param {Object} passwordExpirySettingsDto the dto to map
+   * @returns {Promise<PasswordExpirySettingsEntity|PasswordExpiryProSettingsEntity>}
+   */
+  async createFromDefault(passwordExpirySettingsDto = {}) {
+    const organizationSettings = await this.organisationSettingsModel.getOrFind();
+    const isAdvancedSettingsEnabled = organizationSettings.isPluginEnabled("passwordExpiryPolicies");
+    if (!isAdvancedSettingsEnabled) {
+      return PasswordExpirySettingsEntity.createFromDefault(passwordExpirySettingsDto);
+    }
+    return PasswordExpiryProSettingsEntity.createFromDefault(passwordExpirySettingsDto);
+  }
+}
+
+export default PasswordExpirySettingsModel;