passbolt-styleguide 3.5.2 → 3.6.0-alpha2

package/src/react-extension/contexts/AdminAccountRecoveryContext.test.js

@@ -0,0 +1,229 @@
+/**
+ * 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.6.0
+ */
+
+import {defaultProps} from "./AdminAccountRecoveryContext.test.data";
+import {AdminAccountRecoveryContextProvider} from "./AdminAccountRecoveryContext";
+
+describe("AdminAccountRecoveryContext", () => {
+  let adminAccountRecoveryContext; // The adminAccountRecoveryContext to text
+  const props = defaultProps(); // The props to pass
+
+
+  beforeEach(() => {
+    adminAccountRecoveryContext = new AdminAccountRecoveryContextProvider(props);
+    const setStateMock = state => adminAccountRecoveryContext.state = Object.assign(adminAccountRecoveryContext.state, state);
+    jest.spyOn(adminAccountRecoveryContext, "setState").mockImplementation(setStateMock);
+  });
+
+  describe("AdminAccountRecoveryContext::findAccountRecoveryPolicy", () => {
+    it("should get the current account recovery organization policy and store it in its state", async() => {
+      const currentPolicy = {policy: "disabled"};
+
+      // Mock the background page get organization policy request.
+      props.context.port.request = jest.fn(() => currentPolicy);
+
+      expect.assertions(2);
+      await adminAccountRecoveryContext.findAccountRecoveryPolicy();
+      expect(adminAccountRecoveryContext.props.context.port.request).toHaveBeenCalledWith("passbolt.account-recovery.get-organization-policy");
+      expect(adminAccountRecoveryContext.state.currentPolicy).toBe(currentPolicy);
+    });
+  });
+
+  describe("AdminAccountRecoveryContext::changePolicy", () => {
+    it("should store the policy change", async() => {
+      const currentPolicy = {policy: "disabled"};
+      const newPolicy = "mandatory";
+
+      // Mock the background page get organization policy request.
+      props.context.port.request = jest.fn(() => currentPolicy);
+
+      expect.assertions(1);
+      await adminAccountRecoveryContext.findAccountRecoveryPolicy();
+      await adminAccountRecoveryContext.changePolicy(newPolicy);
+      expect(adminAccountRecoveryContext.state.policyChanges.policy).toEqual(newPolicy);
+    });
+
+    it("should not impact the stored policy changes if applying the same policy", async() => {
+      const currentPolicy = {policy: "mandatory"};
+      const newPolicy = "mandatory";
+
+      // Mock the background page get organization policy request.
+      props.context.port.request = jest.fn(() => currentPolicy);
+
+      expect.assertions(1);
+      await adminAccountRecoveryContext.findAccountRecoveryPolicy();
+      await adminAccountRecoveryContext.changePolicy(newPolicy);
+      expect(adminAccountRecoveryContext.state.policyChanges.policy).toBeUndefined();
+    });
+
+    it("should reset the public key policy change if AD wants to disable the policy", async() => {
+      const currentPolicy = {policy: "disabled"};
+      const newPolicy = "disabled";
+      const newPublicKey = "new public key";
+
+      // Mock the background page get organization policy request.
+      props.context.port.request = jest.fn(() => currentPolicy);
+
+      expect.assertions(3);
+      await adminAccountRecoveryContext.findAccountRecoveryPolicy();
+      await adminAccountRecoveryContext.changePublicKey(newPublicKey);
+      expect(adminAccountRecoveryContext.state.policyChanges.publicKey).toEqual(newPublicKey);
+      await adminAccountRecoveryContext.changePolicy(newPolicy);
+      expect(adminAccountRecoveryContext.state.policyChanges.policy).toBeUndefined();
+      expect(adminAccountRecoveryContext.state.policyChanges.publicKey).toBeUndefined();
+    });
+  });
+
+  describe("AdminAccountRecoveryContext::changePublicKey", () => {
+    it("should store the public key change", async() => {
+      const newPublicKey = "new public key";
+
+      expect.assertions(1);
+      await adminAccountRecoveryContext.findAccountRecoveryPolicy();
+      await adminAccountRecoveryContext.changePublicKey(newPublicKey);
+      expect(adminAccountRecoveryContext.state.policyChanges.publicKey).toEqual(newPublicKey);
+    });
+
+    it("should remember the policy change", async() => {
+      const newPolicy = "new policy";
+      const newPublicKey = "new public key";
+
+      expect.assertions(2);
+      await adminAccountRecoveryContext.changePolicy(newPolicy);
+      await adminAccountRecoveryContext.changePublicKey(newPublicKey);
+      expect(adminAccountRecoveryContext.state.policyChanges.publicKey).toEqual(newPublicKey);
+      expect(adminAccountRecoveryContext.state.policyChanges.policy).toEqual(newPolicy);
+    });
+  });
+
+  describe("AdminAccountRecoveryContext::hasPolicyChanges", () => {
+    it("it should return false if no policy changes", async() => {
+      expect.assertions(1);
+      expect(adminAccountRecoveryContext.hasPolicyChanges()).toBeFalsy();
+    });
+
+    it("it should return true if a new policy is set", async() => {
+      const currentPolicy = {policy: "disabled"};
+      const newPolicy = "mandatory";
+
+      // Mock the background page get organization policy request.
+      props.context.port.request = jest.fn(() => currentPolicy);
+
+      expect.assertions(1);
+      await adminAccountRecoveryContext.findAccountRecoveryPolicy();
+      await adminAccountRecoveryContext.changePolicy(newPolicy);
+      expect(adminAccountRecoveryContext.hasPolicyChanges()).toBeTruthy();
+    });
+
+    it("it should return true if a new public key is set", async() => {
+      const newPublicKey = "new public key";
+
+      expect.assertions(1);
+      await adminAccountRecoveryContext.findAccountRecoveryPolicy();
+      await adminAccountRecoveryContext.changePublicKey(newPublicKey);
+      expect(adminAccountRecoveryContext.hasPolicyChanges()).toBeTruthy();
+    });
+  });
+
+  describe("AdminAccountRecoveryContext::getKeyInfo", () => {
+    it("it should return the key info", async() => {
+      const armoredKey = "armored-key";
+      const mockKeyInfo = {
+        armored_key: "armored-key",
+        key_id: "key-id",
+      };
+
+      // Mock the background page get key info.
+      props.context.port.request = jest.fn(() => mockKeyInfo);
+
+      expect.assertions(2);
+      const keyInfo = await adminAccountRecoveryContext.getKeyInfo(armoredKey);
+      expect(adminAccountRecoveryContext.props.context.port.request).toHaveBeenCalledWith("passbolt.keyring.get-key-info", armoredKey);
+      expect(keyInfo).toBe(mockKeyInfo);
+    });
+  });
+
+  describe("AdminAccountRecoveryContext::resetChanges", () => {
+    it("it should reset the policy changes", async() => {
+      const newPolicy = "new policy";
+      const newPublicKey = "new public key";
+      await adminAccountRecoveryContext.changePolicy(newPolicy);
+      await adminAccountRecoveryContext.changePublicKey(newPublicKey);
+
+      expect.assertions(2);
+      await adminAccountRecoveryContext.resetChanges();
+      expect(adminAccountRecoveryContext.state.policyChanges.publicKey).toBeUndefined();
+      expect(adminAccountRecoveryContext.state.policyChanges.policy).toBeUndefined();
+    });
+  });
+
+  describe("AdminAccountRecoveryContext::downloadPrivateKey", () => {
+    it("it should initiate the download of the organization private key", async() => {
+      const newPrivateKey = "new private key";
+
+      // Mock the background page download private key request.
+      props.context.port.request = jest.fn();
+
+      expect.assertions(1);
+      await adminAccountRecoveryContext.downloadPrivateKey(newPrivateKey);
+      expect(adminAccountRecoveryContext.props.context.port.request).toHaveBeenCalledWith("passbolt.account-recovery.download-organization-generated-key", newPrivateKey);
+    });
+  });
+
+  describe("AdminAccountRecoveryContext::save", () => {
+    it("it should save the policy changes", async() => {
+      const newPolicy = "new policy";
+      const newPublicKey = "new public key";
+      const expectedSaveDto = {
+        "account_recovery_organization_public_key": {
+          "armored_key": "new public key",
+        },
+        "policy": "new policy",
+      };
+
+      // Mock the background page save request.
+      props.context.port.request = jest.fn();
+
+      expect.assertions(1);
+      await adminAccountRecoveryContext.changePolicy(newPolicy);
+      await adminAccountRecoveryContext.changePublicKey(newPublicKey);
+      await adminAccountRecoveryContext.save();
+      expect(adminAccountRecoveryContext.props.context.port.request).toHaveBeenCalledWith("passbolt.account-recovery.save-organization-policy", expectedSaveDto, undefined);
+    });
+
+    it("it should save the policy changes with a provided current private key", async() => {
+      const newPolicy = "new policy";
+      const newPublicKey = "new public key";
+      const currentPrivateKey = {
+        armored_key: "current-private-key",
+        passhrase: "current-private-key-passphrase"
+      };
+      const expectedSaveDto = {
+        "account_recovery_organization_public_key": {
+          "armored_key": "new public key",
+        },
+        "policy": "new policy",
+      };
+
+      // Mock the background page save request.
+      props.context.port.request = jest.fn();
+
+      expect.assertions(1);
+      await adminAccountRecoveryContext.changePolicy(newPolicy);
+      await adminAccountRecoveryContext.changePublicKey(newPublicKey);
+      await adminAccountRecoveryContext.save(currentPrivateKey);
+      expect(adminAccountRecoveryContext.props.context.port.request).toHaveBeenCalledWith("passbolt.account-recovery.save-organization-policy", expectedSaveDto, currentPrivateKey);
+    });
+  });
+});

package/src/react-extension/contexts/AdministrationWorkspaceContext.js

@@ -16,6 +16,8 @@ import {withAppContext} from "./AppContext";
 import {withRouter} from "react-router-dom";
 import {withLoading} from "./LoadingContext";
 import {ApiClient} from "../../shared/lib/apiClient/apiClient";
+import DisplayAdministrationWorkspaceActions
+  from "../components/Administration/DisplayAdministrationWorkspaceActions/DisplayAdministrationWorkspaceActions";
 
 /**
  * Context related to resources ( filter, current selections, etc.)
@@ -34,6 +36,9 @@ export const AdministrationWorkspaceContext = React.createContext({
     editSubscriptionKey: false, // Must edit subscription key
     refreshSubscriptionKey: false // Must refresh the subscription key
   },
+  administrationWorkspaceAction: DisplayAdministrationWorkspaceActions, // Class of the component to display the actions of the users
+  setDisplayAdministrationWorkspaceAction: () => {}, // Whenever the component to display workspace action is requested
+  resetDisplayAdministrationWorkspaceAction: () => {}, // Whenever the reset of the display workspace action is requested
   onGetMfaRequested: () => {}, // Whenever the user access to the Mfa page
   onSaveMfaRequested: () => {}, // Whenever the user wants save Mfa settings
   onGetUsersDirectoryRequested: () => {}, // Whenever the user access to the users directory page
@@ -89,6 +94,9 @@ class AdministrationWorkspaceContextProvider extends React.Component {
         editSubscriptionKey: false, // Must edit subscription key
         refreshSubscriptionKey: false // Must refresh the susbcription key
       },
+      administrationWorkspaceAction: DisplayAdministrationWorkspaceActions, // Class of the component to display the actions of the users
+      setDisplayAdministrationWorkspaceAction: this.setDisplayAdministrationWorkspaceAction.bind(this), // Whenever the component to display workspace action is requested
+      resetDisplayAdministrationWorkspaceAction: this.resetDisplayAdministrationWorkspaceAction.bind(this), // Whenever the reset of the display workspace action is requested
       onGetMfaRequested: this.onGetMfaRequested.bind(this), // Whenever the user access to the Mfa page
       onSaveMfaRequested: this.onSaveMfaRequested.bind(this), // Whenever the user wants save the Mfa page
       onGetUsersDirectoryRequested: this.onGetUsersDirectoryRequested.bind(this), // Whenever the user access to the users directory page
@@ -219,6 +227,7 @@ class AdministrationWorkspaceContextProvider extends React.Component {
     const isEmailNotificationLocation = this.props.location.pathname.includes('email-notification');
     const isSubscriptionLocation = this.props.location.pathname.includes('subscription');
     const isInternationalizationLocation = this.props.location.pathname.includes('internationalization');
+    const isAccountRecoveryLocation = this.props.location.pathname.includes('account-recovery');
     const can = {
       save: false,
       test: false,
@@ -243,10 +252,27 @@ class AdministrationWorkspaceContextProvider extends React.Component {
       selectedAdministration =  AdministrationWorkspaceMenuTypes.SUBSCRIPTION;
     } else if (isInternationalizationLocation) {
       selectedAdministration =  AdministrationWorkspaceMenuTypes.INTERNATIONALIZATION;
+    } else if (isAccountRecoveryLocation) {
+      selectedAdministration =  AdministrationWorkspaceMenuTypes.ACCOUNT_RECOVERY;
     }
     await this.setState({selectedAdministration, can, must});
   }
 
+  /**
+   * Set the display of the administration workspace action
+   * @param administrationWorkspaceAction
+   */
+  setDisplayAdministrationWorkspaceAction(administrationWorkspaceAction) {
+    this.setState({administrationWorkspaceAction});
+  }
+
+  /**
+   * Reset the display of the administration workspace action
+   */
+  resetDisplayAdministrationWorkspaceAction() {
+    this.setState({administrationWorkspaceAction: DisplayAdministrationWorkspaceActions});
+  }
+
   /**
    * Whenever the mfa is requested.
    * @return {Promise<object>}
@@ -431,4 +457,5 @@ export const AdministrationWorkspaceMenuTypes = {
   EMAIL_NOTIFICATION: 'EMAIL-NOTIFICATION', // Email notification administration menu selected
   SUBSCRIPTION: 'SUBSCRIPTION', // Subscription administration menu selected
   INTERNATIONALIZATION: 'INTERNATIONALIZATION', // Email notification administration menu selected
+  ACCOUNT_RECOVERY: 'ACCOUNT-RECOVERY', // Email notification administration menu selected
 };

package/src/react-extension/contexts/ApiAccountRecoveryContext.js

@@ -0,0 +1,148 @@
+/**
+ * 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.6.0
+ */
+
+import React from "react";
+import PropTypes from "prop-types";
+import {withAppContext} from "./AppContext";
+import {ApiClient} from "../../shared/lib/apiClient/apiClient";
+import PassboltApiFetchError from "../../shared/lib/Error/PassboltApiFetchError";
+
+/**
+ * The ApiAccountRecovery context.
+ * @type {React.Context<object>}
+ */
+export const ApiAccountRecoveryContext = React.createContext({
+  userId: null, // The account recovery user id
+  authenticationToken: null, // The account recovery authentication token
+  state: null, // The current account recovery workflow state
+  onInitializeAccountRecoveryRequested: () => {
+  } // Whenever the initialization of the account recovery is requested.
+});
+
+/**
+ * The related context provider
+ */
+class ApiAccountRecoveryContextProvider extends React.Component {
+  /**
+   * Default constructor
+   * @param props The component props
+   */
+  constructor(props) {
+    super(props);
+    this.state = Object.assign(this.defaultState, props.value);
+  }
+
+  /**
+   * Returns the default component state
+   */
+  get defaultState() {
+    return {
+      userId: null, // The account recovery user id
+      authenticationToken: null, // The account recovery authentication token
+      state: ApiAccountRecoveryContextState.INITIAL_STATE, // The current account recovery workflow state
+      onInitializeAccountRecoveryRequested: this.onInitializeAccountRecoveryRequested.bind(this) // Whenever the initialization of the account recovery is requested.
+    };
+  }
+
+  /**
+   * Initialize the account recovery
+   * @return {Promise<void>}
+   */
+  async onInitializeAccountRecoveryRequested() {
+    // @todo account-recovery userId and authentication token are always null here. TO continue.
+    if (!this.state.userId || !this.state.authenticationToken) {
+      return this.setState({state: ApiAccountRecoveryContextState.ERROR_STATE});
+    }
+
+    try {
+      await this.verifyCanContinueAccountRecovery();
+      this.setState({state: ApiAccountRecoveryContextState.RESTART_FROM_SCRATCH});
+    } catch (error) {
+      await this.handleVerifyCanContinueAccountRecoveryError(error);
+    }
+  }
+
+  /**
+   * Verify the user can continue its account recovery.
+   * @returns {Promise<void>}
+   */
+  async verifyCanContinueAccountRecovery() {
+    const apiClientOptions = this.props.context.getApiClientOptions();
+    apiClientOptions.setResourceName("account-recovery");
+    const apiClient = new ApiClient(apiClientOptions);
+    await apiClient.get(`continue/${this.state.userId}/${this.state.authenticationToken}`);
+  }
+
+  /**
+   * Handle error on the can continue account recovery verification.
+   * @return {Promise<void>}
+   */
+  async handleVerifyCanContinueAccountRecoveryError(error) {
+    if (error instanceof PassboltApiFetchError) {
+      const isTokenExpired = Boolean(error?.data?.body?.token?.expired);
+      if (isTokenExpired) {
+        await this.setState({state: ApiAccountRecoveryContextState.TOKEN_EXPIRED_STATE});
+        return;
+      }
+    }
+    await this.setState({state: ApiAccountRecoveryContextState.ERROR_STATE, error: error});
+  }
+
+  /**
+   * Render the component
+   * @returns {JSX}
+   */
+  render() {
+    return (
+      <ApiAccountRecoveryContext.Provider value={this.state}>
+        {this.props.children}
+      </ApiAccountRecoveryContext.Provider>
+    );
+  }
+}
+
+ApiAccountRecoveryContextProvider.propTypes = {
+  context: PropTypes.any, // The application context
+  value: PropTypes.any, // The initial value of the context
+  children: PropTypes.any // The children components
+};
+export default withAppContext(ApiAccountRecoveryContextProvider);
+
+/**
+ * API Account Recovery Context Consumer HOC
+ * @param WrappedComponent
+ */
+export function withApiAccountRecoveryContext(WrappedComponent) {
+  return class withApiRecoverContext extends React.Component {
+    render() {
+      return (
+        <ApiAccountRecoveryContext.Consumer>
+          {
+            context => <WrappedComponent apiAccountRecoveryContext={context} {...this.props} />
+          }
+        </ApiAccountRecoveryContext.Consumer>
+      );
+    }
+  };
+}
+
+/**
+ * The account recovery types of state
+ */
+export const ApiAccountRecoveryContextState = {
+  INITIAL_STATE: 'Initial state',
+  RESTART_FROM_SCRATCH: 'Restart from scratch state',
+  TOKEN_EXPIRED_STATE: 'Token expired state',
+  ERROR_STATE: 'Error state',
+};

package/src/react-extension/contexts/ApiRecoverContext.js

@@ -17,7 +17,6 @@ import {withAppContext} from "./AppContext";
 import {ApiClient} from "../../shared/lib/apiClient/apiClient";
 import {BROWSER_NAMES, detectBrowserName} from "../../shared/lib/Browser/detectBrowserName";
 import PassboltApiFetchError from "../../shared/lib/Error/PassboltApiFetchError";
-import getPropValue from "../lib/Object/getPropValue";
 
 /**
  * The Api recover context.
@@ -69,27 +68,28 @@ class ApiRecoverContextProvider extends React.Component {
       return this.setState({state: ApiRecoverContextState.DOWNLOAD_SUPPORTED_BROWSER_STATE});
     }
 
-    await this.verifyRecoverInfo()
-      .then(this.handleRecoverVerifySuccess.bind(this))
-      .catch(this.handleRecoverVerifyError.bind(this));
+    await this.startRecover()
+      .then(this.handleStartRecoverSuccess.bind(this))
+      .catch(this.handleStartRecoverError.bind(this));
   }
 
   /**
-   * When the recover info are valid.
+   * When the recover started with success.
    * @return {void}
    */
-  handleRecoverVerifySuccess() {
+  handleStartRecoverSuccess() {
     this.setState({state: ApiRecoverContextState.INSTALL_EXTENSION_STATE});
   }
 
   /**
-   * When the recover info didn't validate
+   * When the recover didn't start with success.
    * @return {void}
    */
-  handleRecoverVerifyError(error) {
+  handleStartRecoverError(error) {
     if (error instanceof PassboltApiFetchError) {
-      const isTokenExpired = getPropValue(error, "data.body.token.expired");
-      if (isTokenExpired) {
+      const isTokenExpired = Boolean(error.data.body?.token?.expired);
+      const isTokenConsumed = Boolean(error.data.body?.token?.isActive);
+      if (isTokenExpired || isTokenConsumed) {
         return this.setState({state: ApiRecoverContextState.TOKEN_EXPIRED_STATE});
       }
     }
@@ -107,15 +107,14 @@ class ApiRecoverContextProvider extends React.Component {
   }
 
   /**
-   * Verify the recover information.
-   * @returns {Promise<object>}
+   * Start the recover.
+   * @returns {Promise<void>}
    */
-  async verifyRecoverInfo() {
+  async startRecover() {
     const apiClientOptions = this.props.context.getApiClientOptions();
     apiClientOptions.setResourceName("setup");
     const apiClient = new ApiClient(apiClientOptions);
-    const {body} = await apiClient.get(`recover/${this.state.userId}/${this.state.token}`);
-    return body;
+    await apiClient.get(`recover/${this.state.userId}/${this.state.token}`);
   }
 
   /**

package/src/react-extension/contexts/ApiSetupContext.js

@@ -69,24 +69,24 @@ class ApiSetupContextProvider extends React.Component {
       return this.setState({state: ApiSetupContextState.DOWNLOAD_SUPPORTED_BROWSER_STATE});
     }
 
-    await this.verifySetupInfo()
-      .then(this.handleSetupVerifySuccess.bind(this))
-      .catch(this.handleSetupVerifyError.bind(this));
+    await this.startSetup()
+      .then(this.handleStartSetupSuccess.bind(this))
+      .catch(this.handleStartSetupError.bind(this));
   }
 
   /**
-   * When the setup info are valid.
+   * When the setup start succeed.
    * @return {void}
    */
-  handleSetupVerifySuccess() {
+  handleStartSetupSuccess() {
     this.setState({state: ApiSetupContextState.INSTALL_EXTENSION_STATE});
   }
 
   /**
-   * When the setup info didn't validate
+   * When the setup start failed.
    * @return {void}
    */
-  handleSetupVerifyError(error) {
+  handleStartSetupError(error) {
     if (error instanceof PassboltApiFetchError) {
       const isTokenExpired = getPropValue(error, "data.body.token.expired");
       if (isTokenExpired) {
@@ -110,7 +110,7 @@ class ApiSetupContextProvider extends React.Component {
    * Verify the setup information.
    * @returns {Promise<object>}
    */
-  async verifySetupInfo() {
+  async startSetup() {
     const apiClientOptions = this.props.context.getApiClientOptions();
     apiClientOptions.setResourceName("setup");
     const apiClient = new ApiClient(apiClientOptions);