passbolt-styleguide 3.8.4 → 3.9.0-alpha2

package/src/react-extension/contexts/Administration/AdministrationMfa/AdministrationMfaContext.test.js

@@ -0,0 +1,178 @@
+/**
+ * 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.8.0
+ */
+
+import {defaultProps} from "../../../../react-extension/components/Administration/DisplayMfaAdministration/DisplayMfaAdministration.test.data";
+import {AdminMfaContextProvider} from "./AdministrationMfaContext";
+import {enableFetchMocks} from 'jest-fetch-mock';
+import {mockMfaSettings, mockDuoError} from "../../../../react-extension/components/Administration/DisplayMfaAdministration/DisplayMfaAdministration.test.data";
+import {mockApiResponse} from "../../../../../test/mocks/mockApiResponse";
+import MfaModel from '../../../../shared/models/Mfa/MfaModel';
+import {mockDefaultMfaModel} from '../../../components/Administration/DisplayMfaAdministration/DisplayMfaAdministration.test.data';
+import MfaDTO from '../../../../shared/models/Mfa/MfaDTO';
+
+describe("AdminMfaContext", () => {
+  let adminMfaContext; // The adminMfaContext to test
+  const props = defaultProps(); // The props to pass
+
+  //Initialize context by default
+  const initContext = async() => {
+    fetch.doMock(() => mockApiResponse(mockMfaSettings));
+    await adminMfaContext.findMfaSettings();
+  };
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    adminMfaContext = new AdminMfaContextProvider(props);
+    const setStateMock = state => adminMfaContext.state = Object.assign(adminMfaContext.state, state);
+    jest.spyOn(adminMfaContext, "setState").mockImplementation(setStateMock);
+    enableFetchMocks();
+  });
+  describe("AdminMfaContext::findMfaSettings", () => {
+    it("should get the current settings and store it in its state", async() => {
+      // Mock the call to API
+      const mockApiSettingsFetch = fetch.doMockOnceIf(/mfa\/settings.json/, () => mockApiResponse(mockMfaSettings));
+      const expectedResult = new MfaModel(mockMfaSettings);
+      await adminMfaContext.findMfaSettings();
+
+      expect.assertions(4);
+
+      expect(mockApiSettingsFetch).toHaveBeenCalledTimes(1);
+      expect(adminMfaContext.getSettings()).toEqual(expectedResult);
+      expect(adminMfaContext.getCurrentSettings()).toEqual(expectedResult);
+      expect(adminMfaContext.isProcessing()).toBeFalsy();
+    });
+
+    it("should initialize with default value if object is empty", async() => {
+      // Mock the call to API
+      const mockApiSettingsFetch = fetch.doMockOnceIf(/mfa\/settings.json/, () => mockApiResponse({}));
+      await adminMfaContext.findMfaSettings();
+
+      expect.assertions(4);
+
+      expect(mockApiSettingsFetch).toHaveBeenCalledTimes(1);
+      expect(adminMfaContext.getSettings()).toEqual(mockDefaultMfaModel);
+      expect(adminMfaContext.getCurrentSettings()).toEqual(mockDefaultMfaModel);
+      expect(adminMfaContext.isProcessing()).toBeFalsy();
+    });
+
+    it("should set processing to true when loading settings", async() => {
+      adminMfaContext.setProcessing(false);
+      try {
+        await adminMfaContext.findMfaSettings();
+      } catch {
+        expect.assertions(1);
+        expect(adminMfaContext.isProcessing()).toBeTruthy();
+      }
+    });
+  });
+
+  describe("AdminMfaContext::hasSettingsChanges", () => {
+    beforeEach(async() => {
+      await initContext();
+    });
+    it("should return true if settings is different then current setting", () => {
+      adminMfaContext.setSettings("duoToggle", false);
+
+      expect.assertions(1);
+
+      expect(adminMfaContext.hasSettingsChanges()).toBeTruthy();
+    });
+
+    it("should return false if settings is different then current setting", () => {
+      adminMfaContext.setSettings("duoToggle", false);
+      adminMfaContext.setSettings("duoToggle", true);
+
+      expect.assertions(1);
+
+      expect(adminMfaContext.hasSettingsChanges()).toBeFalsy();
+    });
+  });
+
+  describe("AdminMfaContext::clearContext", () => {
+    beforeEach(async() => {
+      await initContext();
+    });
+    it("should clear the context and set it by default", () => {
+      adminMfaContext.setSettings("duoToggle", true);
+      adminMfaContext.setSettings("yubikeyToggle", true);
+      adminMfaContext.setSettings("toptToggle", true);
+      adminMfaContext.clearContext();
+
+      expect.assertions(5);
+
+      expect(adminMfaContext.isProcessing()).toBeTruthy();
+      expect(adminMfaContext.getCurrentSettings()).toBe(null);
+      expect(adminMfaContext.getSettings().duoToggle).toBeFalsy();
+      expect(adminMfaContext.getSettings().toptToggle).toBeFalsy();
+      expect(adminMfaContext.getSettings().yubikeyToggle).toBeFalsy();
+    });
+  });
+
+  describe("AdminMfaContext::save", () => {
+    it("should save settings and call findMfaSettings", async() => {
+      fetch.doMockOnceIf(/mfa\/settings.json/, () => mockApiResponse({}));
+      const findSettings = jest.spyOn(adminMfaContext, "findMfaSettings").mockImplementation();
+
+      await adminMfaContext.save();
+
+      expect.assertions(3);
+
+      expect(adminMfaContext.isProcessing()).toBeTruthy();
+      expect(findSettings).toHaveBeenCalled();
+      expect(JSON.parse(fetch.mock.calls[0][1].body)).toEqual(expect.objectContaining(new MfaDTO()));
+    });
+  });
+
+  describe("AdminMfaContext::setSettings", () => {
+    it("should update settings object and not the current object", async() => {
+      await initContext();
+      adminMfaContext.setSettings("duoToggle", false);
+
+      expect.assertions(2);
+
+      expect(adminMfaContext.getCurrentSettings().duoToggle).toBeTruthy();
+      expect(adminMfaContext.getSettings().duoToggle).toBeFalsy();
+    });
+  });
+
+  describe("AdminMfaContext::errors", () => {
+    it("should update error object with targeted property", async() => {
+      await initContext();
+      adminMfaContext.setError("duoSaltError", "error");
+
+      expect.assertions(1);
+
+      expect(adminMfaContext.getErrors().duoSaltError).toBe("error");
+    });
+
+    it("should init errors with default property", async() => {
+      expect.assertions(1);
+      expect(adminMfaContext.getErrors()).toEqual(adminMfaContext.initErrors());
+    });
+
+    it("should update error object with all properties ", async() => {
+      const mockError = mockDuoError();
+      adminMfaContext.setErrors(mockError);
+
+      expect.assertions(4);
+
+      expect(adminMfaContext.getErrors().duoSaltError).toEqual(mockError.duoSaltError);
+      expect(adminMfaContext.getErrors().duoIntegrationKeyError).toEqual(mockError.duoIntegrationKeyError);
+      expect(adminMfaContext.getErrors().duoHostnameError).toEqual(mockError.duoHostnameError);
+      expect(adminMfaContext.getErrors().duoSecretKeyError).toEqual(mockError.duoSecretKeyError);
+    });
+  });
+});
+
+

package/src/react-extension/contexts/Administration/AdministrationSelfRegistration/AdministrationSelfRegistrationContext.js

@@ -0,0 +1,453 @@
+/**
+ * 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.8.3
+ */
+
+import React from "react";
+import PropTypes from "prop-types";
+import {withAppContext} from "../../AppContext";
+import SelfRegistrationService from "../../../../shared/services/api/selfRegistration/selfRegistrationService";
+import SelfRegistrationDomainsViewModel from "../../../../shared/models/selfRegistration/SelfRegistrationDomainsViewModel";
+import MapObject from "../../../lib/Map/MapObject";
+import SelfRegistrationDto from "../../../../shared/models/selfRegistration/SelfRegistrationDto";
+import SelfRegistrationFormService from "../../../../shared/services/forms/selfRegistration/SelfRegistrationFormService";
+import ConfirmSaveSelfRegistrationSettings from "../../../components/Administration/DisplaySelfRegistrationAdministration/ConfirmSaveSelfRegistrationSettings/ConfirmSaveSelfRegistrationSettings";
+import NotifyError from "../../../components/Common/Error/NotifyError/NotifyError";
+import {withActionFeedback} from "../../ActionFeedbackContext";
+import {withDialog} from "../../DialogContext";
+import {withTranslation} from "react-i18next";
+import ConfirmDeletionSelfRegistrationSettings from "../../../components/Administration/DisplaySelfRegistrationAdministration/ConfirmDeletionSelfRegistrationSettings/ConfirmDeletionSelfRegistrationSettings";
+
+/**
+ * The Administration Self registration Context
+ * @type {React.Context<Object>}
+ */
+export const AdminSelfRegistrationContext = React.createContext({
+  getCurrentSettings: () => {}, // Returns settings saved
+  getAllowedDomains: () => {}, // Returns allowed domains for UI changes
+  setAllowedDomains: () => {}, // Returns allowed domains for UI changes
+  hasSettingsChanges: () => {}, // Check if the policy has changes
+  setDomains: () => {}, // change domains
+  findSettings: () => {}, // Find the current self registraiton settings and store it in the state
+  setProcessing: () => {}, //Update processing object
+  isProcessing: () => {}, // returns true if a process is running and the UI must be disabled
+  clearContext: () => {}, // put the data to its default state value
+  isSubmitted: () => {}, // returns the value submitted
+  setSubmitted: () => {}, // Set the submitted variable
+  setErrors: () => {}, // Set errors to object object
+  getErrors: () => {}, // Return current errors
+  setError: () => {}, // Init errors object message
+  save: () => {}, // Save settings,
+  delete: () => {}, // Delete settings,
+  shouldFocus: () => {}, // Return the focus object,
+  setFocus: () => {}, // Set the focus object,
+  isSaved: () => {}, // return saved value
+  setSaved: () => {}, // init saved value
+  validateForm: () => {} // Validate the form
+});
+
+/**
+ * The Administration self registration context provider
+ */
+export class AdminSelfRegistrationContextProvider extends React.Component {
+  /**
+   * Default constructor
+   * @param props The component props
+   */
+  constructor(props) {
+    super(props);
+    this.state = this.defaultState;
+    const apiClientOptions = props.context.getApiClientOptions();
+    this.selfRegistrationService = new SelfRegistrationService(
+      apiClientOptions
+    );
+    this.selfRegistrationFormService = new SelfRegistrationFormService(
+      this.props.t
+    );
+  }
+
+  /**
+   * Returns the default component state
+   */
+  get defaultState() {
+    return {
+      errors: new Map(), // The error map object
+      submitted: false, // The informations about the form state
+      currentSettings: null, // The current settings
+      focus: false, // return request to focus to input
+      saved: false, // return request to inform about a saved
+      domains: new SelfRegistrationDomainsViewModel(), // Change done to the allowed domains object
+      processing: true, // Context is processing data
+      getCurrentSettings: this.getCurrentSettings.bind(this), // Returns settings saved
+      getAllowedDomains: this.getAllowedDomains.bind(this), // Returns allowed domains for UI changes
+      setAllowedDomains: this.setAllowedDomains.bind(this), // Returns allowed domains for UI changes
+      setDomains: this.setDomains.bind(this), // change domains
+      findSettings: this.findSettings.bind(this), // Find the current self registraiton settings and store it in the state
+      hasSettingsChanges: this.hasSettingsChanges.bind(this), // Check if setting has changes
+      isProcessing: this.isProcessing.bind(this), // returns true if a process is running and the UI must be disabled
+      setProcessing: this.setProcessing.bind(this),
+      clearContext: this.clearContext.bind(this), // put the data to its default state value
+      isSubmitted: this.isSubmitted.bind(this), // returns the value submitted
+      setSubmitted: this.setSubmitted.bind(this), // Set the submitted variable
+      getErrors: this.getErrors.bind(this), // Return current errors
+      setError: this.setError.bind(this), // Set an error to object object
+      setErrors: this.setErrors.bind(this), // Set errors to object object
+      save: this.save.bind(this), // Save the policy changes
+      shouldFocus: this.shouldFocus.bind(this), // Return the focus object,
+      setFocus: this.setFocus.bind(this), // Set the focus object
+      isSaved: this.isSaved.bind(this), // return saved value
+      setSaved: this.setSaved.bind(this), // init saved value
+      deleteSettings: this.deleteSettings.bind(this), // Delete settings,
+      validateForm: this.validateForm.bind(this), // Validate the form
+    };
+  }
+
+  /**
+   * Find the self registration settings
+   * @return {Promise<void>}
+   */
+  async findSettings(callback = () => {}) {
+    this.setProcessing(true);
+    const result = await this.selfRegistrationService.find();
+    //Init saved setting
+    this.setState({currentSettings: result});
+    const domains = new SelfRegistrationDomainsViewModel(result);
+    //Init allowed domains which will interact with UI
+    this.setDomains(domains, callback);
+    this.setProcessing(false);
+  }
+
+  /**
+   * Returns the setting actually saved inside DB
+   * @returns {object}
+   */
+  getCurrentSettings() {
+    return this.state.currentSettings;
+  }
+
+  /**
+   * Returns the allowed domains settings that have been fetch previously.
+   * @returns {object}
+   */
+  getAllowedDomains() {
+    return this.state.domains.allowedDomains;
+  }
+
+
+  /**
+   * Handle settings changes.
+   * @params {ReactEvent} The react event
+   * @returns {void}
+   */
+  setAllowedDomains(key, value, callback = () => {}) {
+    this.setState(prevState => {
+      const allowedDomains = MapObject.clone(prevState.domains.allowedDomains);
+      allowedDomains.set(key, value);
+      return {domains: {allowedDomains}};
+    }, callback);
+  }
+
+  /**
+   * Handle domains changes.
+   * @params {ReactEvent} The react event
+   * @returns {void}
+   */
+  setDomains(domains, callback = () => {}) {
+    this.setState({domains}, callback);
+  }
+
+  /**
+   * Returns true when the data is under processing
+   * @returns {boolean}
+   *
+   */
+  isProcessing() {
+    return this.state.processing;
+  }
+
+  /**
+   * Handle processing change.
+   * @params {Boolean} processing value
+   * @returns {void}
+   */
+  setProcessing(processing) {
+    this.setState({processing});
+  }
+
+  /**
+   * return true if the form has been submitted
+   * @returns {Boolean}
+   */
+  isSubmitted() {
+    return this.state.submitted;
+  }
+
+  /**
+   * change value for isSubmitted
+   * @params  {Boolean}
+   * @returns {Boolean}
+   */
+  setSubmitted(submitted) {
+    this.setState({submitted});
+    this.setFocus(submitted);
+  }
+
+  /**
+   * return the errors object
+   */
+  getErrors() {
+    return this.state.errors;
+  }
+
+  /**
+   * return the focus object
+   */
+  shouldFocus() {
+    return this.state.focus;
+  }
+
+  /**
+   * change value for isSubmitted
+   * @params  {Boolean}
+   * @returns {Boolean}
+   */
+  setFocus(focus) {
+    this.setState({focus});
+  }
+
+  /**
+   * set an error to object
+   */
+  setError(key, value) {
+    this.setState(prevState => {
+      const errors = MapObject.clone(prevState.errors);
+      errors.set(key, value);
+      return {errors};
+    });
+  }
+
+  /**
+   * set errors to object
+   */
+  setErrors(errors) {
+    this.setState({errors});
+  }
+
+  /**
+   * Check if there are changes to apply
+   * @returns {Boolean}
+   */
+  hasSettingsChanges() {
+    // we compare the domains from the server vs the UI
+    const savedDomains = this.state.currentSettings?.data?.allowed_domains || [];
+    const uiDomains = MapObject.listValues(this.state.domains.allowedDomains);
+
+    return (
+      (JSON.stringify(savedDomains) !== JSON.stringify(uiDomains))
+    );
+  }
+
+  /**
+   * Puts the state to its default in order to avoid keeping the data users didn't want to save.
+   */
+  clearContext() {
+    const {currentSettings, domains, processing} = this.defaultState;
+    this.setState({
+      currentSettings,
+      domains,
+      processing,
+    });
+  }
+
+  /**
+   * Whenever the save has been requested
+   */
+  async save() {
+    this.setSubmitted(true);
+    const isValid = await this.validateForm();
+    if (isValid) {
+      if (this.hasSettingsChanges() && this.getAllowedDomains().size === 0) {
+        this.displayConfirmDeletionDialog();
+      } else {
+        this.displayConfirmSummaryDialog();
+      }
+    }
+  }
+
+  /**
+   * validate the form
+   * @returns {void}
+   */
+  async validateForm() {
+    const errors = await this.selfRegistrationFormService.validate(this.state.getAllowedDomains());
+    this.state.setErrors(errors);
+    return errors.size === 0;
+  }
+
+  /**
+   * Handle save operation error.
+   * @param {object} error The returned error
+   */
+  async handleSubmitError(error) {
+    if (error.name !== "UserAbortsOperationError") {
+      // Unexpected error occurred.
+      console.error(error);
+      await this.handleError(error);
+    }
+  }
+
+  /**
+   * Whenever the submit request is done
+   */
+  async saveSettings() {
+    try {
+      this.setProcessing(true);
+      const newSettings = new SelfRegistrationDto(
+        this.state.domains,
+        this.state.currentSettings
+      );
+      await this.selfRegistrationService.save(newSettings);
+      await this.findSettings(() => this.setSaved(true));
+      await this.props.actionFeedbackContext.displaySuccess(
+        this.props.t(
+          "The self registration settings for the organization were updated."
+        )
+      );
+    } catch (error) {
+      this.handleSubmitError(error);
+    } finally {
+      this.setProcessing(false);
+      this.setSubmitted(false);
+    }
+  }
+
+  /**
+   * handle error to display the error dialog
+   * @param error
+   */
+  async handleError(error) {
+    this.handleCloseDialog();
+    const errorDialogProps = {
+      error: error,
+    };
+    this.props.dialogContext.open(NotifyError, errorDialogProps);
+  }
+
+  /**
+   * Handle close dialog
+   */
+  handleCloseDialog() {
+    this.props.dialogContext.close();
+  }
+
+  /**
+   * Display the confirmation summary dialog
+   * @returns {Promise<void>}
+   */
+  displayConfirmSummaryDialog() {
+    this.props.dialogContext.open(ConfirmSaveSelfRegistrationSettings, {
+      domains: this.getAllowedDomains(),
+      onSubmit: () => this.saveSettings(),
+      onClose: () => this.handleCloseDialog(),
+    });
+  }
+
+  /**
+   * Display the confirmation dialog for deletion seytings
+   * @returns {Promise<void>}
+   */
+  displayConfirmDeletionDialog() {
+    this.props.dialogContext.open(ConfirmDeletionSelfRegistrationSettings, {
+      onSubmit: () => this.deleteSettings(),
+      onClose: () => this.handleCloseDialog(),
+    });
+  }
+
+  /**
+   * Whenever the delete has been requested
+   */
+  async deleteSettings() {
+    try {
+      this.setProcessing(true);
+      await this.selfRegistrationService.delete(this.state.currentSettings.id);
+      await this.findSettings();
+      await this.props.actionFeedbackContext.displaySuccess(
+        this.props.t(
+          "The self registration settings for the organization were updated."
+        )
+      );
+    } catch (error) {
+      this.handleSubmitError(error);
+    } finally {
+      this.setProcessing(false);
+      this.setSubmitted(false);
+    }
+  }
+
+  /**
+   * return the saved state
+   */
+  isSaved() {
+    return this.state.saved;
+  }
+
+  /**
+   * Set saved state
+   * @Param {Boolean}
+   */
+  setSaved(saved) {
+    return this.setState({saved});
+  }
+
+  /**
+   * Render the component
+   * @returns {JSX}
+   */
+  render() {
+    return (
+      <AdminSelfRegistrationContext.Provider value={this.state}>
+        {this.props.children}
+      </AdminSelfRegistrationContext.Provider>
+    );
+  }
+}
+
+AdminSelfRegistrationContextProvider.propTypes = {
+  context: PropTypes.any, // The application context
+  children: PropTypes.any, // The children components
+  t: PropTypes.any, // The translate context
+  dialogContext: PropTypes.any, // The dialog context
+  actionFeedbackContext: PropTypes.object, // The action feedback context
+};
+
+export default withAppContext(withDialog(withActionFeedback(withTranslation("common")(AdminSelfRegistrationContextProvider))));
+
+/**
+ * Resource Workspace Context Consumer HOC
+ * @param WrappedComponent
+ */
+export function withAdminSelfRegistration(WrappedComponent) {
+  return class WithAdminSelfRegistration extends React.Component {
+    render() {
+      return (
+        <AdminSelfRegistrationContext.Consumer>
+          {adminSelfRegistrationContext => (
+            <WrappedComponent
+              adminSelfRegistrationContext={adminSelfRegistrationContext}
+              {...this.props}
+            />
+          )}
+        </AdminSelfRegistrationContext.Consumer>
+      );
+    }
+  };
+}