passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/model/entity/folder/external/externalFoldersCollection.js

@@ -10,31 +10,31 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {FoldersCollection} = require("../foldersCollection");
-const {ExternalFolderEntity} = require("./externalFolderEntity");
-const {EntityCollection} = require('../../abstract/entityCollection');
-const {EntitySchema} = require('../../abstract/entitySchema');
+import FoldersCollection from "../foldersCollection";
+import ExternalFolderEntity from "./externalFolderEntity";
+import EntityCollection from "passbolt-styleguide/src/shared/models/entity/abstract/entityCollection";
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+
 
 const ENTITY_NAME = 'ExternalFolders';
 
 class ExternalFoldersCollection extends EntityCollection {
   /**
-   * ExternalFoldersCollection constructor
-   *
-   * @param {array} externalFoldersCollectionDto external folders DTO
-   * @throws EntityValidationError if the dto cannot be converted into an entity
+   * @inheritDoc
    */
-  constructor(externalFoldersCollectionDto) {
+  constructor(externalFoldersCollectionDto, options = {}) {
     super(EntitySchema.validate(
       ExternalFoldersCollection.ENTITY_NAME,
       externalFoldersCollectionDto,
       ExternalFoldersCollection.getSchema()
-    ));
+    ), options);
 
-    // Note: there is no "multi-item" validation
-    // Collection validation will fail at the first item that doesn't validate
+    /*
+     * Note: there is no "multi-item" validation
+     * Collection validation will fail at the first item that doesn't validate
+     */
     this._props.forEach(externalFolderDto => {
-      this.push(new ExternalFolderEntity(externalFolderDto));
+      this.push(new ExternalFolderEntity(externalFolderDto, {clone: false}));
     });
 
     // We do not keep original props
@@ -53,9 +53,12 @@ class ExternalFoldersCollection extends EntityCollection {
       throw new TypeError(`ExternalFoldersCollection constructFromFoldersCollection parameter should be an instance of FoldersCollection.`);
     }
     const externalFoldersDto = foldersCollection.folders.map(folderEntity => {
-      const folderParentPath = foldersCollection.getFolderParentPath(folderEntity);
+      const folderParentPath = ExternalFoldersCollection.getEscapedFolderParentPath(foldersCollection, folderEntity);
       const folderParentId = folderParentPath.length ? folderEntity.folderParentId : null;
-      return Object.assign(folderEntity.toDto(), {folder_parent_id: folderParentId, folder_parent_path: folderParentPath});
+      return Object.assign(folderEntity.toDto(), {
+        name: ExternalFolderEntity.escapeName(folderEntity.name),
+        folder_parent_id: folderParentId,
+        folder_parent_path: folderParentPath});
     });
     return new ExternalFoldersCollection(externalFoldersDto);
   }
@@ -69,7 +72,40 @@ class ExternalFoldersCollection extends EntityCollection {
     return {
       "type": "array",
       "items": ExternalFolderEntity.getSchema(),
-    }
+    };
+  }
+
+  /**
+   * Get the escaped folder parent path for a given FolderEntity.
+   *
+   * @param {FoldersCollection} foldersCollection
+   * @param {FolderEntity} folderEntity
+   * @returns {string}
+   */
+  static getEscapedFolderParentPath(foldersCollection, folderEntity) {
+    return foldersCollection.getAllParents(folderEntity).items
+      .reverse()
+      .map(folderParentEntity => ExternalFolderEntity.escapeName(folderParentEntity.name))
+      .join("/");
+  }
+
+  /**
+   * Builds a folderCollection based on an array of ExternalFolderEntity.
+   * ExternalFolderEntity has name escaped while FolderEntity doesn't have.
+   * So, this method ensure that FolderEntity have its name resolved from the ExternalFolderEntity.
+   *
+   * @param {array<ExternalFolderEntity>} externalFoldersCollection
+   * @returns {FoldersCollection}
+   */
+  static toFoldersCollection(externalFoldersCollection) {
+    const foldersCollection = [];
+    externalFoldersCollection.forEach(externalFolder => {
+      const folderDto = Object.assign(externalFolder.toDto(), {
+        name: ExternalFolderEntity.resolveEscapedName(externalFolder.name),
+      });
+      foldersCollection.push(folderDto);
+    });
+    return new FoldersCollection(foldersCollection);
   }
 
   /**
@@ -88,9 +124,11 @@ class ExternalFoldersCollection extends EntityCollection {
     return this._items.map(r => r.id);
   }
 
-  // ==================================================
-  // Finders / Filters
-  // ==================================================
+  /*
+   * ==================================================
+   * Finders / Filters
+   * ==================================================
+   */
 
   /**
    * Check if a folder external of the list has the given path.
@@ -141,9 +179,11 @@ class ExternalFoldersCollection extends EntityCollection {
     return this.externalFolders.filter(externalFolderEntity => externalFolderEntity.folderParentId === folderParentId);
   }
 
-  // ==================================================
-  // Setters
-  // ==================================================
+  /*
+   * ==================================================
+   * Setters
+   * ==================================================
+   */
   /**
    * Push a copy of the external folder to the list
    * @param {object} externalFolder DTO or ExternalFolderEntity
@@ -173,9 +213,9 @@ class ExternalFoldersCollection extends EntityCollection {
     if (!path.length) {
       return;
     }
-    const split = path.split('/');
+    const split = ExternalFolderEntity.splitFolderPath(path);
     let pathCursor = "";
-    for (let folderName of split) {
+    for (const folderName of split) {
       pathCursor = pathCursor.length ? `${pathCursor}/${folderName}` : folderName;
       if (this.hasPath(pathCursor)) {
         continue;
@@ -185,7 +225,7 @@ class ExternalFoldersCollection extends EntityCollection {
     }
 
     // If no error, persist the folders in the collection.
-    externalFoldersEntities.forEach(externalFolderEntity => this.push(externalFolderEntity))
+    externalFoldersEntities.forEach(externalFolderEntity => this.push(externalFolderEntity));
   }
 
   /**
@@ -194,7 +234,7 @@ class ExternalFoldersCollection extends EntityCollection {
    * @param {string} folderParentId The corresponding folder parent id
    */
   setFolderParentIdsByPath(folderParentPath, folderParentId) {
-    for (let externalFolderEntity of this.externalFolders) {
+    for (const externalFolderEntity of this.externalFolders) {
       if (externalFolderEntity.folderParentPath === folderParentPath) {
         externalFolderEntity.folderParentId = folderParentId;
       }
@@ -214,7 +254,7 @@ class ExternalFoldersCollection extends EntityCollection {
    * @param {string} path the path to remove
    */
   removeByPath(path) {
-    for (let i = this.externalFolders.length - 1; i>=0; i--) {
+    for (let i = this.externalFolders.length - 1; i >= 0; i--) {
       const externalFolderEntity = this.externalFolders[i];
       const escapedPath = path.replace(/[.*+\-?^${}()|[\]\\\/]/g, '\\$&');
       const regex = new RegExp(`^${escapedPath}($|\/)`);
@@ -224,9 +264,11 @@ class ExternalFoldersCollection extends EntityCollection {
     }
   }
 
-  // ==================================================
-  // Static getters
-  // ==================================================
+  /*
+   * ==================================================
+   * Static getters
+   * ==================================================
+   */
   /**
    * ExternalFoldersCollection.ENTITY_NAME
    * @returns {string}
@@ -236,4 +278,4 @@ class ExternalFoldersCollection extends EntityCollection {
   }
 }
 
-exports.ExternalFoldersCollection = ExternalFoldersCollection;
+export default ExternalFoldersCollection;

package/src/all/background_page/model/entity/folder/external/externalFoldersCollection.test.js

@@ -10,16 +10,9 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-import Validator from 'validator';
-import {EntitySchema} from "../../abstract/entitySchema";
-import {ExternalFoldersCollection} from "./externalFoldersCollection";
-import {ExternalFolderEntity} from "./externalFolderEntity";
-
-// Reset the modules before each test.
-beforeEach(() => {
-  window.Validator = Validator;
-  jest.resetModules();
-});
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+import ExternalFoldersCollection from "./externalFoldersCollection";
+import ExternalFolderEntity from "./externalFolderEntity";
 
 describe("ExternalFoldersCollection", () => {
   it("schema must validate", () => {
@@ -58,14 +51,14 @@ describe("ExternalFoldersCollection", () => {
 
   it("createAndPushMissingPathFolders creates and pushes missing path folders into the collection", () => {
     const collection = new ExternalFoldersCollection([]);
-    const rootFolder = new ExternalFolderEntity({"name": "Root"});
+    const rootFolder = new ExternalFolderEntity({"name": "Root /"});
     collection.push(rootFolder);
-    collection.pushFromPath("///Root /  Folder 1 //// Folder 2////");
+    collection.pushFromPath("///Root //Folder 1////Folder 2 // ");
 
     expect(collection.items).toHaveLength(3);
-    const folder1 = buildExternalFolderDto(1, {folder_parent_path: "Root"});
+    const folder1 = buildExternalFolderDto(1, {folder_parent_path: "Root /"});
     expect(collection.toJSON()).toEqual(expect.arrayContaining([folder1]));
-    const folder2 = buildExternalFolderDto(2, {folder_parent_path: "Root/Folder 1"});
+    const folder2 = buildExternalFolderDto('2 // ', {folder_parent_path: "Root //Folder 1"});
     expect(collection.toJSON()).toEqual(expect.arrayContaining([folder2]));
   });
 
@@ -87,8 +80,16 @@ describe("ExternalFoldersCollection", () => {
     const collection = new ExternalFoldersCollection([{"name": "Folder 1"}, {"name": "Folder 2"}]);
     const rootFolder = new ExternalFolderEntity({"name": "Root", "folder_parent_path": "New"});
     collection.changeRootPath(rootFolder);
-    for (let externalFolderEntity of collection) {
+    for (const externalFolderEntity of collection) {
       expect(externalFolderEntity.folderParentPath).toEqual("New/Root");
     }
   });
+
+  it("should build a FoldersCollection while resolving escaped folder name", () => {
+    const externalFolderEntityList = [new ExternalFolderEntity({name: "/ Ro / ot /"})];
+    const foldersCollection = ExternalFoldersCollection.toFoldersCollection(externalFolderEntityList);
+
+    const folderEntity = foldersCollection.items[0];
+    expect(folderEntity.name).toBe("/Ro/ot/");
+  });
 });

package/src/all/background_page/model/entity/folder/folderEntity.js

@@ -11,44 +11,45 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         2.13.0
  */
-const {Entity} = require('../abstract/entity');
-const {EntitySchema} = require('../abstract/entitySchema');
-const {EntityValidationError} = require('../abstract/entityValidationError');
-const {PermissionEntity} = require('../permission/permissionEntity');
-const {PermissionsCollection} = require('../permission/permissionsCollection');
+import Entity from "passbolt-styleguide/src/shared/models/entity/abstract/entity";
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+import EntityValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/entityValidationError";
+import PermissionEntity from "../permission/permissionEntity";
+import PermissionsCollection from "../permission/permissionsCollection";
 
 const ENTITY_NAME = 'Folder';
 const FOLDER_NAME_MIN_LENGTH = 1;
-const FOLDER_NAME_MAX_LENGTH = 64;
+const FOLDER_NAME_MAX_LENGTH = 256;
 
 class FolderEntity extends Entity {
   /**
-   * Folder entity constructor
-   *
-   * @param {Object} folderDto folder
-   * @throws {EntityValidationError} if the dto cannot be converted into an entity
-   * @throws {EntityValidationError} if permissions are not for folder or not matching foreign key
+   * @inheritDoc
+   * Note: Sanitize, if not provided, the DTO folder parent id should be null.
+   * @throws {EntityValidationError} Build Rule: Verify that the permission is designated for a folder, and its
+   * associated aco foreign key corresponds with the folder ID.
+   * @throws {EntityValidationError} Build Rule: Verify that the permissions are designated for a folder, and their
+   * associated aco foreign keys correspond with the folder ID.
    */
-  constructor(folderDto) {
+  constructor(folderDto, options = {}) {
     super(EntitySchema.validate(
       FolderEntity.ENTITY_NAME,
       folderDto,
       FolderEntity.getSchema()
-    ));
+    ), options);
 
     // if no parent id specified set it to null
-    if(!this._props.hasOwnProperty('folder_parent_id')) {
+    if (!Object.prototype.hasOwnProperty.call(this._props, 'folder_parent_id')) {
       this._props.folder_parent_id = null;
     }
 
     // Associations
     if (this._props.permission) {
-      this._permission = new PermissionEntity(this._props.permission);
+      this._permission = new PermissionEntity(this._props.permission, {clone: false});
       FolderEntity.assertValidPermission(this._permission, this.id);
       delete this._props.permission;
     }
     if (this._props.permissions) {
-      this._permissions = new PermissionsCollection(this._props.permissions);
+      this._permissions = new PermissionsCollection(this._props.permissions, {clone: false});
       FolderEntity.assertValidPermissions(this._permissions, this.id);
       delete this._props.permissions;
     }
@@ -71,12 +72,11 @@ class FolderEntity extends Entity {
         },
         "folder_parent_id": {
           "anyOf": [{
-              "type": "string",
-              "format": "uuid"
-            }, {
-              "type": "null"
-            }
-          ]
+            "type": "string",
+            "format": "uuid"
+          }, {
+            "type": "null"
+          }]
         },
         "name": {
           "type": "string",
@@ -105,12 +105,14 @@ class FolderEntity extends Entity {
         "permission": PermissionEntity.getSchema(), // current user permission
         "permissions": PermissionsCollection.getSchema() // all users permissions
       }
-    }
+    };
   }
 
-  // ==================================================
-  // Serialization
-  // ==================================================
+  /*
+   * ==================================================
+   * Serialization
+   * ==================================================
+   */
   /**
    * Return a DTO ready to be sent to API
    *
@@ -141,9 +143,11 @@ class FolderEntity extends Entity {
     return this.toDto(FolderEntity.ALL_CONTAIN_OPTIONS);
   }
 
-  // ==================================================
-  // Dynamic properties getters
-  // ==================================================
+  /*
+   * ==================================================
+   * Dynamic properties getters
+   * ==================================================
+   */
   /**
    * Get folder id
    * @returns {(string|null)} uuid
@@ -184,10 +188,11 @@ class FolderEntity extends Entity {
     return this._props.modified || null;
   }
 
-
-  // ==================================================
-  // Associated properties methods
-  // ==================================================
+  /*
+   * ==================================================
+   * Associated properties methods
+   * ==================================================
+   */
   /**
    * Get all the current user permissions
    * @returns {{PermissionEntity|null}} permission
@@ -242,7 +247,7 @@ class FolderEntity extends Entity {
    * @returns {(boolean|null)}
    */
   isPersonal() {
-    if (this._props.hasOwnProperty('personal')) {
+    if (Object.prototype.hasOwnProperty.call(this._props, 'personal')) {
       return this._props.personal;
     }
     if (this.permissions) {
@@ -294,7 +299,7 @@ class FolderEntity extends Entity {
     if (!permissions || !permissions.length) {
       throw new EntityValidationError('FolderEntity assertValidPermissions expect an array of permissions.');
     }
-    for (let permission of permissions) {
+    for (const permission of permissions) {
       FolderEntity.assertValidPermission(permission, folderId);
     }
   }
@@ -308,15 +313,17 @@ class FolderEntity extends Entity {
    */
   static canFolderMove(folderToMove, parentFolder, destinationFolder) {
     if (folderToMove.isReadOnly()) {
-       return ((parentFolder === null || parentFolder.isPersonal()) &&
+      return ((parentFolder === null || parentFolder.isPersonal()) &&
          (destinationFolder === null || destinationFolder.isPersonal()));
     }
     return (destinationFolder === null || !destinationFolder.isReadOnly());
   }
 
-  // ==================================================
-  // Default properties setters
-  // ==================================================
+  /*
+   * ==================================================
+   * Default properties setters
+   * ==================================================
+   */
   /**
    * Folder Parent Id
    * @param {string|null} folderParentId optional
@@ -324,17 +331,19 @@ class FolderEntity extends Entity {
    */
   set folderParentId(folderParentId) {
     const propName = 'folder_parent_id';
-    if (!folderParentId ) {
+    if (!folderParentId) {
       this._props[propName] = null;
       return;
     }
     const propSchema = FolderEntity.getSchema().properties[propName];
-    this._props[propName] = EntitySchema.validateProp(propName, folderParentId, propSchema)
+    this._props[propName] = EntitySchema.validateProp(propName, folderParentId, propSchema);
   }
 
-  // ==================================================
-  // Static properties getters
-  // ==================================================
+  /*
+   * ==================================================
+   * Static properties getters
+   * ==================================================
+   */
   /**
    * FolderEntity.ENTITY_NAME
    * @returns {string}
@@ -348,8 +357,8 @@ class FolderEntity extends Entity {
    * @returns {object} all contain options that can be used in toDto()
    */
   static get ALL_CONTAIN_OPTIONS() {
-    return {permission:true, permissions:true};
+    return {permission: true, permissions: true};
   }
 }
 
-exports.FolderEntity = FolderEntity;
+export default FolderEntity;