passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/model/folder/folderModel.js

@@ -10,17 +10,17 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {splitBySize} = require("../../utils/array/splitBySize");
-const {FolderEntity} = require('../entity/folder/folderEntity');
-const {FoldersCollection} = require("../entity/folder/foldersCollection");
-const {FolderLocalStorage} = require('../../service/local_storage/folderLocalStorage');
-const {FolderService} = require('../../service/api/folder/folderService');
-const {MoveService} = require('../../service/api/move/moveService');
-const {ShareService} = require('../../service/api/share/shareService');
-
-const {PermissionEntity} = require('../entity/permission/permissionEntity');
-const {PermissionsCollection} = require('../entity/permission/permissionsCollection');
-const {PermissionChangesCollection} = require("../entity/permission/change/permissionChangesCollection");
+import FolderLocalStorage from "../../service/local_storage/folderLocalStorage";
+import PermissionEntity from "../entity/permission/permissionEntity";
+import PermissionsCollection from "../entity/permission/permissionsCollection";
+import FolderEntity from "../entity/folder/folderEntity";
+import FoldersCollection from "../entity/folder/foldersCollection";
+import PermissionChangesCollection from "../entity/permission/change/permissionChangesCollection";
+import MoveService from "../../service/api/move/moveService";
+import FolderService from "../../service/api/folder/folderService";
+import ShareService from "../../service/api/share/shareService";
+import splitBySize from "../../utils/array/splitBySize";
+import Validator from "validator";
 
 const BULK_OPERATION_SIZE = 5;
 
@@ -48,9 +48,11 @@ class FolderModel {
     return foldersCollection;
   }
 
-  // ============================================
-  // Local storage getters
-  // ============================================
+  /*
+   * ============================================
+   * Local storage getters
+   * ============================================
+   */
   /**
    * Return a folder for a given id from the local storage
    *
@@ -75,21 +77,21 @@ class FolderModel {
     const foldersDto = await FolderLocalStorage.get();
     if (foldersDto) {
       const inputCollection = new FoldersCollection(foldersDto);
-      inputCollection.items.forEach((folderDto) => {
+      inputCollection.items.forEach(folderDto => {
         if (folderIds.includes(folderDto.id)) {
           outputCollection.push(folderDto);
         }
       });
       if (withChildren) {
-        for (let i in folderIds) {
-          let folderId = folderIds[i];
-          let children = FoldersCollection.getAllChildren(folderId, inputCollection, outputCollection);
+        for (const i in folderIds) {
+          const folderId = folderIds[i];
+          const children = FoldersCollection.getAllChildren(folderId, inputCollection, outputCollection);
           outputCollection.merge(children);
         }
       }
     }
     return outputCollection;
-  };
+  }
 
   /**
    * Get all the children for the folder provided as input
@@ -101,17 +103,19 @@ class FolderModel {
     const foldersDto = await FolderLocalStorage.get();
     const inputCollection = new FoldersCollection(foldersDto);
     const outputCollection = new FoldersCollection([]);
-    for (let i in folderIds) {
-      let folderId = folderIds[i];
-      let children = FoldersCollection.getAllChildren(folderId, inputCollection, outputCollection);
+    for (const i in folderIds) {
+      const folderId = folderIds[i];
+      const children = FoldersCollection.getAllChildren(folderId, inputCollection, outputCollection);
       outputCollection.merge(children);
     }
     return outputCollection;
-  };
+  }
 
-  // ============================================
-  // Finders
-  // ============================================
+  /*
+   * ============================================
+   * Finders
+   * ============================================
+   */
   /**
    * Get all folders from API and map API result to folder Entity
    *
@@ -120,7 +124,7 @@ class FolderModel {
    */
   async findAll() {
     const foldersDtos = await this.folderService.findAll({permission: true});
-    return new FoldersCollection(foldersDtos);
+    return new FoldersCollection(foldersDtos, {clone: false});
   }
 
   /**
@@ -159,9 +163,11 @@ class FolderModel {
     return folderEntity.permissions;
   }
 
-  //==============================================================
-  // Permission changes
-  //==============================================================
+  /*
+   * ==============================================================
+   *  Permission changes
+   * ==============================================================
+   */
   /**
    * Calculate permission changes for a move
    * From current permissions, remove the parent folder permissions, add the destination permissions
@@ -172,10 +178,10 @@ class FolderModel {
    * @param {ResourceEntity} folderEntity
    * @param {(FolderEntity|null)} parentFolder
    * @param {(FolderEntity|null)} destFolder
-   * @returns {Promise<PermissionChangesCollection>}
+   * @returns {PermissionChangesCollection}
    */
-  async calculatePermissionsChangesForMove(folderEntity, parentFolder, destFolder) {
-    let remainingPermissions = new PermissionsCollection([], false);
+  calculatePermissionsChangesForMove(folderEntity, parentFolder, destFolder) {
+    let remainingPermissions = new PermissionsCollection([], {assertAtLeastOneOwner: false});
 
     // Remove permissions from parent if any
     if (parentFolder) {
@@ -185,7 +191,7 @@ class FolderModel {
       remainingPermissions = PermissionsCollection.diff(folderEntity.permissions, parentFolder.permissions, false);
     }
     // Add parent permissions
-    let permissionsFromParent = new PermissionsCollection([], false);
+    let permissionsFromParent = new PermissionsCollection([], {assertAtLeastOneOwner: false});
     if (destFolder) {
       if (!destFolder.permissions) {
         throw new TypeError('Resource model calculatePermissionsChangesForMove requires destination permissions to be set.');
@@ -195,10 +201,12 @@ class FolderModel {
       );
     }
 
-    let newPermissions = PermissionsCollection.sum(remainingPermissions, permissionsFromParent, false);
+    const newPermissions = PermissionsCollection.sum(remainingPermissions, permissionsFromParent, false);
     if (!destFolder) {
-      // If the move is toward the root
-      // Reuse highest permission
+      /*
+       * If the move is toward the root
+       * Reuse highest permission
+       */
       newPermissions.addOrReplace(new PermissionEntity({
         aco: PermissionEntity.ACO_FOLDER,
         aco_foreign_key: folderEntity.id,
@@ -234,9 +242,11 @@ class FolderModel {
     return changes;
   }
 
-  //==============================================================
-  // CRUD
-  //==============================================================
+  /*
+   * ==============================================================
+   *  CRUD
+   * ==============================================================
+   */
   /**
    * Create a folder using Passbolt API and add result to local storage
    *
@@ -292,8 +302,10 @@ class FolderModel {
   async share(folderEntity, changesCollection, updateStorage) {
     await this.shareService.shareFolder(folderEntity.id, {permissions: changesCollection.toDto()});
     if (typeof updateStorage === 'undefined' || updateStorage) {
-      // update storage in case the folder becomes non visible to current user
-      // TODO: optimize update only the given folder when user lost access
+      /*
+       * update storage in case the folder becomes non visible to current user
+       * TODO: optimize update only the given folder when user lost access
+       */
       await this.updateLocalStorage();
     }
     return folderEntity;
@@ -310,8 +322,10 @@ class FolderModel {
     await this.folderService.delete(folderId, cascade);
     await FolderLocalStorage.delete(folderId);
     if (cascade) {
-      // update storage and get updated sub folders list in case some are deleted
-      // TODO: optimize update only if folder contains subfolders
+      /*
+       * update storage and get updated sub folders list in case some are deleted
+       * TODO: optimize update only if folder contains subfolders
+       */
       await this.updateLocalStorage();
     }
   }
@@ -327,9 +341,9 @@ class FolderModel {
 
     // Parallelize the operations by chunk of BULK_OPERATION_SIZE operations.
     const chunks = splitBySize(collection.folders, BULK_OPERATION_SIZE);
-    for (let chunkIndex in chunks) {
+    for (const chunkIndex in chunks) {
       const chunk = chunks[chunkIndex];
-      const promises = chunk.map(async (folderEntity, mapIndex) => {
+      const promises = chunk.map(async(folderEntity, mapIndex) => {
         const collectionIndex = (chunkIndex * BULK_OPERATION_SIZE) + mapIndex;
         return this._bulkCreate_createFolder(folderEntity, collectionIndex, callbacks);
       });
@@ -361,23 +375,27 @@ class FolderModel {
     const errorCallback = callbacks.errorCallback || (() => {});
 
     try {
-      // Here we create entity just like in this.create
-      // but we don't add the folder entity in the local storage just yet,
-      // we wait until all folders are created in order to speed things up
+      /*
+       * Here we create entity just like in this.create
+       * but we don't add the folder entity in the local storage just yet,
+       * we wait until all folders are created in order to speed things up
+       */
       const folderDto = await this.folderService.create(folderEntity.toDto(), {permission: true});
       const createdFolderEntity = new FolderEntity(folderDto);
       successCallback(createdFolderEntity, collectionIndex);
       return createdFolderEntity;
-    } catch(error) {
+    } catch (error) {
       console.error(error);
       errorCallback(error, collectionIndex);
       throw error;
     }
   }
 
-  // ============================================
-  // Assertions
-  // ============================================
+  /*
+   * ============================================
+   * Assertions
+   * ============================================
+   */
   /**
    * Assert for a given folder id that the folder is in the local storage
    *
@@ -408,10 +426,10 @@ class FolderModel {
     if (!Array.isArray(folderIds)) {
       throw new TypeError(`Folders exist check expect an array of uuid.`);
     }
-    for (let i in folderIds) {
+    for (const i in folderIds) {
       await this.assertFolderExists(folderIds[i]);
     }
   }
 }
 
-exports.FolderModel = FolderModel;
+export default FolderModel;

package/src/all/background_page/model/folder/folderModel.test.js

@@ -11,39 +11,36 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         2.13.0
  */
-import Validator from "validator";
-import {FolderLocalStorage} from '../../service/local_storage/folderLocalStorage';
-import {ApiClientOptions} from "../../service/api/apiClient/apiClientOptions";
-import {FolderModel} from "./folderModel";
+import FolderLocalStorage from '../../service/local_storage/folderLocalStorage';
+import {ApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions";
+import FolderModel from "./folderModel";
 
 // Mock storage
 jest.mock('../../service/local_storage/folderLocalStorage');
 
-// Reset the modules before each test.
-beforeEach(() => {
-  window.Validator = Validator;
-  jest.resetModules();
-});
-
 describe("FolderModel",  () => {
-  // Folder 1 5f1da286-37ae-4f1c-aaf1-e0342a5d4dc1
-  // -- Folder 2 870ae6ca-538d-45ff-91ae-1466de7b27ac
-  //     -- Folder 3 130162ae-a4eb-46ac-80b2-2a187601109c
-  //     -- Folder 4 af372e21-b93b-480d-bcda-4a772ae141ba
-  //        -- Folder 5 cccb2dd3-c064-46da-ae03-9b77ac19107e
-  // Folder A 2529edc2-3c04-4d31-bc38-0a28ce4e372a
-  // -- Folder B 34719980-89d3-4791-9c5a-63ff91967fd5
-  let folder1 = "5f1da286-37ae-4f1c-aaf1-e0342a5d4dc1";
-    let folder2 = "870ae6ca-538d-45ff-91ae-1466de7b27ac";
-      let folder3 = "130162ae-a4eb-46ac-80b2-2a187601109c";
-      let folder4 = "af372e21-b93b-480d-bcda-4a772ae141ba";
-        let folder5 = "cccb2dd3-c064-46da-ae03-9b77ac19107e";
-  let folderA = "2529edc2-3c04-4d31-bc38-0a28ce4e372a";
-    let folderB = "34719980-89d3-4791-9c5a-63ff91967fd5";
+  /*
+   * Folder 1 5f1da286-37ae-4f1c-aaf1-e0342a5d4dc1
+   * -- Folder 2 870ae6ca-538d-45ff-91ae-1466de7b27ac
+   *     -- Folder 3 130162ae-a4eb-46ac-80b2-2a187601109c
+   *     -- Folder 4 af372e21-b93b-480d-bcda-4a772ae141ba
+   *        -- Folder 5 cccb2dd3-c064-46da-ae03-9b77ac19107e
+   * Folder A 2529edc2-3c04-4d31-bc38-0a28ce4e372a
+   * -- Folder B 34719980-89d3-4791-9c5a-63ff91967fd5
+   */
+  const folder1 = "5f1da286-37ae-4f1c-aaf1-e0342a5d4dc1";
+  /*
+   * const folder2 = "870ae6ca-538d-45ff-91ae-1466de7b27ac";
+   * const folder3 = "130162ae-a4eb-46ac-80b2-2a187601109c";
+   * const folder4 = "af372e21-b93b-480d-bcda-4a772ae141ba";
+   */
+  const folder5 = "cccb2dd3-c064-46da-ae03-9b77ac19107e";
+  const folderA = "2529edc2-3c04-4d31-bc38-0a28ce4e372a";
+  //const folderB = "34719980-89d3-4791-9c5a-63ff91967fd5";
 
-  it("getAllByIds works", async () => {
+  it("getAllByIds works", async() => {
     FolderLocalStorage.get.mockResolvedValue(getReturnValue());
-    const apiClientOptions = (new ApiClientOptions()).setBaseUrl('https://www.passbolt.test');
+    const apiClientOptions = new ApiClientOptions().setBaseUrl('https://www.passbolt.test');
     const folderModel = new FolderModel(apiClientOptions);
 
     // Not found
@@ -66,11 +63,10 @@ describe("FolderModel",  () => {
     result = await folderModel.getAllByIds([folder1, folder5], true);
     expect(result.length).toBe(5);
   });
-
 });
 
 function getReturnValue() {
-  return new Promise((resolve) => {
+  return new Promise(resolve => {
     resolve([
       {
         "id": "5f1da286-37ae-4f1c-aaf1-e0342a5d4dc1",
@@ -205,6 +201,6 @@ function getReturnValue() {
         },
         "folder_parent_id": "2529edc2-3c04-4d31-bc38-0a28ce4e372a"
       }
-    ])
+    ]);
   });
 }

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

@@ -4,16 +4,15 @@
  * @copyright (c) 2016-onwards Bolt Softwares pvt. ltd.
  * @licence AGPL-3.0 http://www.gnu.org/licenses/agpl-3.0.en.html
  */
-"use strict";
+import UserAlreadyLoggedInError from "../error/userAlreadyLoggedInError";
 
-var __ = require('../sdk/l10n').get;
 
 /**
  * The class that deals with secrets.
  */
-var GpgAuthHeader = function(headers, step) {
+const GpgAuthHeader = function(headers, step) {
   this.headers = {};
-  var allowedHeaders = [
+  const allowedHeaders = [
     'x-gpgauth-version',
     'x-gpgauth-authenticated',
     'x-gpgauth-progress',
@@ -23,8 +22,8 @@ var GpgAuthHeader = function(headers, step) {
     'x-gpgauth-debug',
     'x-gpgauth-error'
   ];
-  var h;
-  for (var i=0; i < allowedHeaders.length; i++) {
+  let h;
+  for (let i = 0; i < allowedHeaders.length; i++) {
     h = allowedHeaders[i];
     if (headers.has(h)) {
       this.headers[h] = headers.get(h);
@@ -42,18 +41,16 @@ var GpgAuthHeader = function(headers, step) {
  *   if the validation of the step failed
  */
 GpgAuthHeader.prototype.__validate = function(step) {
-  var error_msg;
-
   // Checks common to all stages
-  var commonChecks = this.__validateCommonAllStage();
+  const commonChecks = this.__validateCommonAllStage();
   if (commonChecks instanceof Error) {
     throw commonChecks;
   }
 
   // Check if the headers are correct
-  var result = this.__validateByStage(step);
+  const result = this.__validateByStage(step);
   if (result instanceof Error) {
-    throw new Error(result.message);
+    throw result;
   }
 
   return true;
@@ -65,18 +62,18 @@ GpgAuthHeader.prototype.__validate = function(step) {
  * @returns {*} True or Error
  * @private
  */
-GpgAuthHeader.prototype.__validateCommonAllStage = function () {
-  var error_msg;
+GpgAuthHeader.prototype.__validateCommonAllStage = function() {
+  let error_msg;
 
   // Check if headers are present
   if (typeof this.headers === 'undefined') {
-    return new Error(__('No GPGAuth headers set.'))
+    return new Error('No GPGAuth headers set.');
   }
 
   // Check if version is supported
   if (typeof this.headers['x-gpgauth-version'] !== 'string' ||
     this.headers['x-gpgauth-version'] !== '1.3.0') {
-    return new Error(__('That version of GPGAuth is not supported. (' + this.headers['x-gpgauth-version'] + ')'));
+    return new Error(`That version of GPGAuth is not supported. (${this.headers['x-gpgauth-version']})`);
   }
 
   // Check if there is GPGAuth error flagged by the server
@@ -98,79 +95,79 @@ GpgAuthHeader.prototype.__validateCommonAllStage = function () {
  * @param stage {string} The stage name to validate
  * @returns {*} True or Error
  */
-GpgAuthHeader.prototype.__validateByStage = function (stage) {
+GpgAuthHeader.prototype.__validateByStage = function(stage) {
   // Stage specific checks
   switch (stage) {
     case 'logout' :
       if (typeof this.headers['x-gpgauth-authenticated'] !== 'string' ||
         this.headers['x-gpgauth-authenticated'] != 'false') {
-        return new Error(__('x-gpgauth-authenticated should be set to false during the logout stage'));
+        return new Error('x-gpgauth-authenticated should be set to false during the logout stage');
       }
       break;
     case 'verify' :
     case 'stage0' :
       if (typeof this.headers['x-gpgauth-authenticated'] !== 'string' ||
         this.headers['x-gpgauth-authenticated'] != 'false') {
-        return new Error(__('x-gpgauth-authenticated should be set to false during the verify stage'));
+        return new Error('x-gpgauth-authenticated should be set to false during the verify stage');
       }
       if (typeof this.headers['x-gpgauth-progress'] !== 'string' ||
         this.headers['x-gpgauth-progress'] != 'stage0') {
-        return new Error(__('x-gpgauth-progress should be set to stage0 during the verify stage'));
+        return new Error('x-gpgauth-progress should be set to stage0 during the verify stage');
       }
       if (typeof this.headers['x-gpgauth-user-auth-token'] !== 'undefined') {
-        return new Error(__('x-gpgauth-user-auth-token should not be set during the verify stage' + typeof this.headers['x-gpgauth-user-auth-token']));
+        return new Error(`x-gpgauth-user-auth-token should not be set during the verify stage${typeof this.headers['x-gpgauth-user-auth-token']}`);
       }
       if (typeof this.headers['x-gpgauth-verify-response'] !== 'string') {
-        return new Error(__('x-gpgauth-verify-response should be set during the verify stage'));
+        return new Error('x-gpgauth-verify-response should be set during the verify stage');
       }
       if (typeof this.headers['x-gpgauth-refer'] !== 'undefined') {
-        return new Error(__('x-gpgauth-refer should not be set during verify stage'));
+        return new Error('x-gpgauth-refer should not be set during verify stage');
       }
       break;
 
     case 'stage1' :
       if (typeof this.headers['x-gpgauth-authenticated'] !== 'string' ||
         this.headers['x-gpgauth-authenticated'] != 'false') {
-        return new Error(__('x-gpgauth-authenticated should be set to false during stage1'));
+        return new UserAlreadyLoggedInError('x-gpgauth-authenticated should be set to false during stage1');
       }
       if (typeof this.headers['x-gpgauth-progress'] !== 'string' ||
         this.headers['x-gpgauth-progress'] != 'stage1') {
-        return new Error(__('x-gpgauth-progress should be set to stage1'));
+        return new Error('x-gpgauth-progress should be set to stage1');
       }
       if (typeof this.headers['x-gpgauth-user-auth-token'] === 'undefined') {
-        return new Error(__('x-gpgauth-user-auth-token should be set during stage1'));
+        return new Error('x-gpgauth-user-auth-token should be set during stage1');
       }
       if (typeof this.headers['x-gpgauth-verify-response'] !== 'undefined') {
-        return new Error(__('x-gpgauth-verify-response should not be set during stage1'));
+        return new Error('x-gpgauth-verify-response should not be set during stage1');
       }
       if (typeof this.headers['x-gpgauth-refer'] !== 'undefined') {
-        return new Error(__('x-gpgauth-refer should not be set during stage1'));
+        return new Error('x-gpgauth-refer should not be set during stage1');
       }
       return true;
 
     case 'complete':
       if (typeof this.headers['x-gpgauth-authenticated'] !== 'string' ||
         this.headers['x-gpgauth-authenticated'] != 'true') {
-        return new Error(__('x-gpgauth-authenticated should be set to true when GPGAuth is complete'));
+        return new Error('x-gpgauth-authenticated should be set to true when GPGAuth is complete');
       }
       if (typeof this.headers['x-gpgauth-progress'] !== 'string' ||
         this.headers['x-gpgauth-progress'] != 'complete') {
-        return new Error(__('x-gpgauth-progress should be set to complete during final stage'));
+        return new Error('x-gpgauth-progress should be set to complete during final stage');
       }
       if (typeof this.headers['x-gpgauth-user-auth-token'] !== 'undefined') {
-        return new Error(__('x-gpgauth-user-auth-token should not be set during final stage'));
+        return new Error('x-gpgauth-user-auth-token should not be set during final stage');
       }
       if (typeof this.headers['x-gpgauth-verify-response'] !== 'undefined') {
-        return new Error(__('x-gpgauth-verify-response should not be set during final stage'));
+        return new Error('x-gpgauth-verify-response should not be set during final stage');
       }
       if (typeof this.headers['x-gpgauth-refer'] !== 'string') {
-        return new Error(__('x-gpgauth-refer should be set during final stage'));
+        return new Error('x-gpgauth-refer should be set during final stage');
       }
       return true;
 
     default:
-      return new Error(__('Unknown GPGAuth stage'));
+      return new Error('Unknown GPGAuth stage');
   }
 };
 
-exports.GpgAuthHeader = GpgAuthHeader;
+export default GpgAuthHeader;

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

@@ -11,8 +11,8 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         2.0.0
  */
-const __ = require('../sdk/l10n').get;
-const Uuid = require('../utils/uuid');
+import {Uuid} from "../utils/uuid";
+import Validator from "validator";
 
 class GpgAuthToken {
   /**
@@ -22,7 +22,7 @@ class GpgAuthToken {
    * @param {string} [token] optional The gpg authentication token
    * @throw {Error} if the token is not valid
    */
-  constructor (token) {
+  constructor(token) {
     if (typeof token === 'undefined') {
       this.token = 'gpgauthv1.3.0|36|';
       this.token += Uuid.get();
@@ -44,30 +44,31 @@ class GpgAuthToken {
    * @param {string} value The value of the field to validate
    * @return {*} True or Error
    */
-  validate (field, value) {
+  validate(field, value) {
+    let sections = [];
     switch (field) {
       case 'token' :
         if (typeof value === 'undefined' || value === '') {
-          return new Error(__('The user authentication token cannot be empty'));
+          return new Error('The user authentication token cannot be empty');
         }
-        const sections = value.split('|');
+        sections = value.split('|');
         if (sections.length !== 4) {
-          return new Error(__('The user authentication token is not in the right format'));
+          return new Error('The user authentication token is not in the right format');
         }
         if (sections[0] !== sections[3] && sections[0] !== 'gpgauthv1.3.0') {
-          return new Error(__('Passbolt does not support this GPGAuth version'));
+          return new Error('Passbolt does not support this GPGAuth version');
         }
         if (sections[1] !== '36') {
-          return new Error(__('Passbolt does not support GPGAuth token nonce longer than 36 characters: ' + sections[2]));
+          return new Error(`Passbolt does not support GPGAuth token nonce longer than 36 characters: ${sections[2]}`);
         }
         if (!Validator.isUUID(sections[2])) {
-          return new Error(__('Passbolt does not support GPGAuth token nonce that are not UUIDs'));
+          return new Error('Passbolt does not support GPGAuth token nonce that are not UUIDs');
         }
         return true;
       default :
-        return new Error(__('No validation defined for field: ' + field));
+        return new Error(`No validation defined for field: ${field}`);
     }
   }
 }
 
-exports.GpgAuthToken = GpgAuthToken;
+export default GpgAuthToken;