passbolt-browser-extension 5.3.2 → 5.4.1

package/src/all/background_page/model/entity/permission/actionLog/updatedPermissionsCollection.test.js

@@ -0,0 +1,204 @@
+/**
+ * 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         5.4.0
+ */
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+import UpdatedPermissionsCollection from "./updatedPermissionsCollection";
+import {defaultUserDto} from "passbolt-styleguide/src/shared/models/entity/user/userEntity.test.data";
+import {defaultGroupDto} from "passbolt-styleguide/src/shared/models/entity/group/groupEntity.test.data";
+import {defaultUpdatePermissionDto} from "./updatedPermissionEntity.test.data";
+import UpdatedPermissionEntity from "./updatedPermissionEntity";
+
+describe("UpdatedPermissionsCollection", () => {
+  it("schema must validate", () => {
+    EntitySchema.validateSchema(UpdatedPermissionsCollection.ENTITY_NAME, UpdatedPermissionsCollection.getSchema());
+  });
+
+  describe("::constructor", () => {
+    it("works with empty data", () => {
+      expect.assertions(1);
+      const collection = new UpdatedPermissionsCollection([]);
+      expect(collection).toHaveLength(0);
+    });
+
+    it("works if valid DTOs are provided", () => {
+      expect.assertions(6);
+
+      const dto1 = defaultUpdatePermissionDto({user: defaultUserDto()});
+      const dto2 = defaultUpdatePermissionDto({group: defaultGroupDto()});
+      const dtos = [dto1, dto2];
+      const collection = new UpdatedPermissionsCollection(dtos);
+
+      expect(collection.items).toHaveLength(2);
+      expect(collection.toDto()).toEqual(dtos);
+
+      expect(collection.items[0]).toBeInstanceOf(UpdatedPermissionEntity);
+      expect(collection.items[0].toDto(UpdatedPermissionEntity.ALL_CONTAIN_OPTIONS)).toStrictEqual(dto1);
+      expect(collection.items[1]).toBeInstanceOf(UpdatedPermissionEntity);
+      expect(collection.items[1].toDto(UpdatedPermissionEntity.ALL_CONTAIN_OPTIONS)).toEqual(dto2);
+    });
+
+    it("should throw if the collection schema does not validate", () => {
+      expect.assertions(1);
+      expect(() => new UpdatedPermissionsCollection({}))
+        .toThrowEntityValidationError("items");
+    });
+
+    it("should throw if one of data item does not validate the collection entity schema", () => {
+      expect.assertions(1);
+
+      const dto1 = defaultUpdatePermissionDto();
+      const dto2 = defaultUpdatePermissionDto({user: 42});
+
+      expect(() => new UpdatedPermissionsCollection([dto1, dto2])).toThrow();
+    });
+
+    it("should throw if one of data item does not validate the unique id build rule", () => {
+      expect.assertions(1);
+
+      const dto1 = defaultUpdatePermissionDto();
+
+      expect(() => new UpdatedPermissionsCollection([dto1, dto1])).toThrow();
+    });
+  });
+
+  describe("::sortPermissionsByGranteeTypeAndName", () => {
+    it("should order users by their name", () => {
+      expect.assertions(3);
+
+      const userA = defaultUserDto();
+      userA.profile.first_name = "user A";
+      const userB = defaultUserDto();
+      userB.profile.first_name = "user B";
+
+      const permissionA = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: userA}));
+      const permissionB = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: userB}));
+
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionB)).toStrictEqual(-1);
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionB, permissionA)).toStrictEqual(1);
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionA)).toStrictEqual(0);
+    });
+
+    it("should consider equal permisions with users having the same name", () => {
+      expect.assertions(1);
+
+      const userA = defaultUserDto();
+      userA.profile.first_name = "user";
+      const userB = defaultUserDto();
+      userB.profile.first_name = "user";
+
+      const permissionA = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: userA}));
+      const permissionB = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: userB}));
+
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionB)).toStrictEqual(0);
+    });
+
+    it("should put user without definition after users with definition", () => {
+      expect.assertions(2);
+
+      const userB = defaultUserDto();
+      userB.profile.first_name = "user B";
+
+      const permissionA = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null}));
+      const permissionB = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: userB}));
+
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionB)).toStrictEqual(1);
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionB, permissionA)).toStrictEqual(-1);
+    });
+
+    it("both undfined users should be considered equal", () => {
+      expect.assertions(1);
+
+      const permissionA = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null}));
+      const permissionB = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null}));
+
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionB)).toStrictEqual(0);
+    });
+
+    it("should order groups by their name", () => {
+      expect.assertions(3);
+
+      const groupA = defaultGroupDto({name: "Group A"});
+      const groupB = defaultGroupDto({name: "Group B"});
+
+      const permissionA = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null, group: groupA}));
+      const permissionB = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null, group: groupB}));
+
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionB)).toStrictEqual(-1);
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionB, permissionA)).toStrictEqual(1);
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionA)).toStrictEqual(0);
+    });
+
+    it("should consider equal permisions with groups having the same name", () => {
+      expect.assertions(1);
+
+      const groupA = defaultGroupDto({name: "Group"});
+      const groupB = defaultGroupDto({name: "Group"});
+
+      const permissionA = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null, group: groupA}));
+      const permissionB = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null, group: groupB}));
+
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionB)).toStrictEqual(0);
+    });
+
+    it("should put group without definition after groups with definition", () => {
+      expect.assertions(2);
+
+      const groupB = defaultGroupDto({name: "Group B"});
+
+      const permissionA = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null, group: null}));
+      const permissionB = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null, group: groupB}));
+
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionB)).toStrictEqual(1);
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionB, permissionA)).toStrictEqual(-1);
+    });
+
+    it("should put group after users", () => {
+      expect.assertions(2);
+
+      const permissionA = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null, group: defaultGroupDto()}));
+      const permissionB = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: defaultUserDto()}));
+
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionB)).toStrictEqual(1);
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionB, permissionA)).toStrictEqual(-1);
+    });
+
+    it("should put undefined group after users", () => {
+      expect.assertions(2);
+
+      const permissionA = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null, group: null}));
+      const permissionB = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: defaultUserDto()}));
+
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionB)).toStrictEqual(1);
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionB, permissionA)).toStrictEqual(-1);
+    });
+
+    it("should put undefined users after group", () => {
+      expect.assertions(2);
+
+      const permissionA = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null,  group: defaultGroupDto()}));
+      const permissionB = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null}));
+
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionB)).toStrictEqual(-1);
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionB, permissionA)).toStrictEqual(1);
+    });
+
+    it("should put undefined grantees at the same level", () => {
+      expect.assertions(1);
+
+      const permissionA = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null, group: null}));
+      const permissionB = new UpdatedPermissionEntity(defaultUpdatePermissionDto({user: null, group: null}));
+
+      expect(UpdatedPermissionsCollection.sortPermissionsByGranteeTypeAndName(permissionA, permissionB)).toStrictEqual(0);
+    });
+  });
+});

package/src/all/background_page/model/entity/permission/permissionsCollection.js

@@ -348,6 +348,84 @@ class PermissionsCollection extends EntityV2Collection {
     return permissions;
   }
 
+  /**
+   * Sort the current collection by aro and names.
+   * This method is mutatative
+   */
+  sort() {
+    this._items.sort(PermissionsCollection.sortPermissionsByAroAndName);
+  }
+
+  /**
+   * Delegate function to use as a callback to sort permissions.
+   * Permissions are sorted this way:
+   * - Defined users first
+   * - Defined groups second
+   * - Unknown users third
+   * - Unknown groups fourth
+   * Users are sorted by their `${user.first_name} ${user.last_name}`
+   * Groups are sorted by their `${group.name}`
+   *
+   * @param {PermissionEntity} permissionA
+   * @param {PermissionEntity} permissionB
+   * @returns {number} -1 if permissionA comes first, 1 if permissionB comes first, 0 it they are "equals"
+   * @static
+   * @private
+   */
+  static sortPermissionsByAroAndName(permissionA, permissionB) {
+    //compare AROs, if they are different, aro User is coming first in the list
+    const isADefinedUserPermission = permissionA.aro === PermissionEntity.ARO_USER && Boolean(permissionA.user);
+    const isBDefinedUserPermission = permissionB.aro === PermissionEntity.ARO_USER && Boolean(permissionB.user);
+
+    if (isADefinedUserPermission && isBDefinedUserPermission) {
+      //both users are defined, we need to order by their full name.
+      const userAName = permissionA.user.profile.name;
+      const userBName = permissionB.user.profile.name;
+
+      return userAName.localeCompare(userBName);
+    }
+
+    if (isADefinedUserPermission) {
+      // permissionA is a user, permissionB is either an undefined user, a group, an undefined group. So permissionA comes first.
+      return -1;
+    } else if (isBDefinedUserPermission) {
+      // permissionB is a user, permissionA is either an undefined user, a group, an undefined group. So permissionB comes first.
+      return 1;
+    }
+
+    //here both permissionA and permissionB are for group permission. But their group could be undefined though
+    const isADefinedGroupPermission = permissionA.aro === PermissionEntity.ARO_GROUP && Boolean(permissionA.group);
+    const isBDefinedGroupPermission = permissionB.aro === PermissionEntity.ARO_GROUP && Boolean(permissionB.group);
+
+    if (isADefinedGroupPermission && isBDefinedGroupPermission) {
+      // both permission are for defined group, we need to order them by their group name
+      const groupAName = permissionA.group.name;
+      const groupBName = permissionB.group.name;
+
+      return groupAName.localeCompare(groupBName);
+    }
+
+    if (isADefinedGroupPermission) {
+      // permissionA is for a defined group and permissionB is for an undefined group. permissionA comes first
+      return -1;
+    } else if (isBDefinedGroupPermission) {
+      // permissionB is for a defined group and permissionA is for an undefined group. permissionB comes first
+      return 1;
+    }
+
+    // both permissions are for undefined group or user
+    const isAUserPermission = permissionA.aro === PermissionEntity.ARO_USER;
+    const isBUserPermission = permissionB.aro === PermissionEntity.ARO_USER;
+    if ((isAUserPermission && isBUserPermission) || (!isAUserPermission && !isBUserPermission)) {
+      //they are both permissions for undefined user or both for undefined group. they are consider "equals"
+      return 0;
+    }
+
+    return isAUserPermission
+      ? -1 // permissionA is for an undefined user and permissionB for an undefined group. permissionA comes first
+      : 1; // permissionB is for an undefined user and permissionA for an undefined group. permissionB comes first
+  }
+
   /*
    * ==================================================
    * Static getters

package/src/all/background_page/model/entity/permission/permissionsCollection.test.js

@@ -12,10 +12,8 @@
  * @since         2.13.0
  */
 import PermissionEntity from "./permissionEntity";
-import permissionEntity from "./permissionEntity";
 import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
 import PermissionsCollection from "./permissionsCollection";
-import permissionsCollection from "./permissionsCollection";
 import {
   defaultPermissionDto,
   minimumPermissionDto,
@@ -30,6 +28,8 @@ import {
 import {
   defaultPermissionsDtos
 } from "passbolt-styleguide/src/shared/models/entity/permission/permissionCollection.test.data";
+import {defaultUserDto} from "passbolt-styleguide/src/shared/models/entity/user/userEntity.test.data";
+import {defaultGroupDto} from "passbolt-styleguide/src/shared/models/entity/group/groupEntity.test.data";
 
 describe("PermissionsCollection", () => {
   it("schema must validate", () => {
@@ -77,9 +77,9 @@ describe("PermissionsCollection", () => {
     it("works if valid complete entities are provided", () => {
       expect.assertions(19);
       const acoForeignKey = crypto.randomUUID();
-      const entity1 = new permissionEntity(defaultPermissionDto({aco_foreign_key: acoForeignKey}));
-      const entity2 = new permissionEntity(defaultPermissionDto({aco_foreign_key: acoForeignKey}));
-      const entity3 = new permissionEntity(defaultPermissionDto({aco_foreign_key: acoForeignKey}));
+      const entity1 = new PermissionEntity(defaultPermissionDto({aco_foreign_key: acoForeignKey}));
+      const entity2 = new PermissionEntity(defaultPermissionDto({aco_foreign_key: acoForeignKey}));
+      const entity3 = new PermissionEntity(defaultPermissionDto({aco_foreign_key: acoForeignKey}));
       const entities = [entity1, entity2, entity3];
       const collection = new PermissionsCollection(entities);
       expect(collection.items).toHaveLength(3);
@@ -165,7 +165,7 @@ describe("PermissionsCollection", () => {
       const dto3 = ownerPermissionDto({aco_foreign_key: acoForeignKey});
 
       expect.assertions(3);
-      const collection = new permissionsCollection([dto1, dto2, dto3], {ignoreInvalidEntity: true});
+      const collection = new PermissionsCollection([dto1, dto2, dto3], {ignoreInvalidEntity: true});
       expect(collection.items).toHaveLength(2);
       expect(collection.items[0].id).toEqual(dto1.id);
       expect(collection.items[1].id).toEqual(dto3.id);
@@ -323,7 +323,7 @@ describe("PermissionsCollection", () => {
       const collection = new PermissionsCollection([dto1, dto2]);
 
       // same same
-      collection.addOrReplace(new permissionEntity(dto3));
+      collection.addOrReplace(new PermissionEntity(dto3));
       expect(collection.permissions.length).toBe(2);
       expect(collection.permissions[1].type).toBe(1);
 
@@ -525,4 +525,136 @@ describe("PermissionsCollection", () => {
       expect(resultSet.toDto()).toEqual([]);
     });
   });
+
+  describe("::sortPermissionsByAroAndName", () => {
+    it("should order users by their name", () => {
+      expect.assertions(3);
+
+      const userA = defaultUserDto();
+      userA.profile.first_name = "user A";
+      const userB = defaultUserDto();
+      userB.profile.first_name = "user B";
+
+      const permissionA = new PermissionEntity(defaultPermissionDto({aro: "User", user: userA}));
+      const permissionB = new PermissionEntity(defaultPermissionDto({aro: "User", user: userB}));
+
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionB)).toStrictEqual(-1);
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionB, permissionA)).toStrictEqual(1);
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionA)).toStrictEqual(0);
+    });
+
+    it("should consider equal permisions with users having the same name", () => {
+      expect.assertions(1);
+
+      const userA = defaultUserDto();
+      userA.profile.first_name = "user";
+      const userB = defaultUserDto();
+      userB.profile.first_name = "user";
+
+      const permissionA = new PermissionEntity(defaultPermissionDto({aro: "User", user: userA}));
+      const permissionB = new PermissionEntity(defaultPermissionDto({aro: "User", user: userB}));
+
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionB)).toStrictEqual(0);
+    });
+
+    it("should put user without definition after users with definition", () => {
+      expect.assertions(2);
+
+      const userB = defaultUserDto();
+      userB.profile.first_name = "user B";
+
+      const permissionA = new PermissionEntity(defaultPermissionDto({aro: "User", user: null}));
+      const permissionB = new PermissionEntity(defaultPermissionDto({aro: "User", user: userB}));
+
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionB)).toStrictEqual(1);
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionB, permissionA)).toStrictEqual(-1);
+    });
+
+    it("both undfined users should be considered equal", () => {
+      expect.assertions(1);
+
+      const permissionA = new PermissionEntity(defaultPermissionDto({aro: "User", user: null}));
+      const permissionB = new PermissionEntity(defaultPermissionDto({aro: "User", user: null}));
+
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionB)).toStrictEqual(0);
+    });
+
+    it("should order groups by their name", () => {
+      expect.assertions(3);
+
+      const groupA = defaultGroupDto({name: "Group A"});
+      const groupB = defaultGroupDto({name: "Group B"});
+
+      const permissionA = new PermissionEntity(defaultPermissionDto({aro: "Group", group: groupA}));
+      const permissionB = new PermissionEntity(defaultPermissionDto({aro: "Group", group: groupB}));
+
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionB)).toStrictEqual(-1);
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionB, permissionA)).toStrictEqual(1);
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionA)).toStrictEqual(0);
+    });
+
+    it("should consider equal permisions with groups having the same name", () => {
+      expect.assertions(1);
+
+      const groupA = defaultGroupDto({name: "Group"});
+      const groupB = defaultGroupDto({name: "Group"});
+
+      const permissionA = new PermissionEntity(defaultPermissionDto({aro: "Group", group: groupA}));
+      const permissionB = new PermissionEntity(defaultPermissionDto({aro: "Group", group: groupB}));
+
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionB)).toStrictEqual(0);
+    });
+
+    it("should put group without definition after groups with definition", () => {
+      expect.assertions(2);
+
+      const groupB = defaultGroupDto({name: "Group B"});
+
+      const permissionA = new PermissionEntity(defaultPermissionDto({aro: "Group", group: null}));
+      const permissionB = new PermissionEntity(defaultPermissionDto({aro: "Group", group: groupB}));
+
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionB)).toStrictEqual(1);
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionB, permissionA)).toStrictEqual(-1);
+    });
+
+    it("should put group after users", () => {
+      expect.assertions(2);
+
+      const permissionA = new PermissionEntity(defaultPermissionDto({aro: "Group", group: defaultGroupDto()}));
+      const permissionB = new PermissionEntity(defaultPermissionDto({aro: "User", user: defaultUserDto()}));
+
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionB)).toStrictEqual(1);
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionB, permissionA)).toStrictEqual(-1);
+    });
+
+    it("should put undefined group after users", () => {
+      expect.assertions(2);
+
+      const permissionA = new PermissionEntity(defaultPermissionDto({aro: "Group", group: null}));
+      const permissionB = new PermissionEntity(defaultPermissionDto({aro: "User", user: defaultUserDto()}));
+
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionB)).toStrictEqual(1);
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionB, permissionA)).toStrictEqual(-1);
+    });
+
+    it("should put undefined users after group", () => {
+      expect.assertions(2);
+
+      const permissionA = new PermissionEntity(defaultPermissionDto({aro: "Group", group: defaultGroupDto()}));
+      const permissionB = new PermissionEntity(defaultPermissionDto({aro: "User", user: null}));
+
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionB)).toStrictEqual(-1);
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionB, permissionA)).toStrictEqual(1);
+    });
+
+    it("should put undefined group after undefined user", () => {
+      expect.assertions(2);
+
+      const permissionA = new PermissionEntity(defaultPermissionDto({aro: "Group", group: null}));
+      const permissionB = new PermissionEntity(defaultPermissionDto({aro: "User", user: null}));
+
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionA, permissionB)).toStrictEqual(1);
+      expect(PermissionsCollection.sortPermissionsByAroAndName(permissionB, permissionA)).toStrictEqual(-1);
+    });
+  });
 });

package/src/all/background_page/model/entity/plaintext/plaintextEntity.js

@@ -76,6 +76,15 @@ class PlaintextEntity extends EntityV2 {
   get totp() {
     return this._props.totp || null;
   }
+
+  /**
+   * Return custom fields prop if any
+   *
+   * @returns {object|null} custom fields
+   */
+  get customFields() {
+    return this._props.custom_fields || null;
+  }
 }
 
 export default PlaintextEntity;

package/src/all/background_page/model/entity/resource/external/externalResourceEntity.js

@@ -19,8 +19,11 @@ import EntityV2 from "passbolt-styleguide/src/shared/models/entity/abstract/enti
 import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
 import {assertType} from "../../../../utils/assertions";
 import IconEntity from "passbolt-styleguide/src/shared/models/entity/resource/metadata/IconEntity";
+import CustomFieldsCollection from "passbolt-styleguide/src/shared/models/entity/customField/customFieldsCollection";
 
 const DEFAULT_RESOURCE_NAME = '(no name)';
+const RESOURCE_URI_MAX_LENGTH = 1024;
+const RESOURCE_URIS_MAX_ITEMS = 32;
 
 class ExternalResourceEntity extends EntityV2 {
   /**
@@ -54,6 +57,18 @@ class ExternalResourceEntity extends EntityV2 {
     }
   }
 
+
+  /**
+   *  @inheritDoc
+   * @returns {{custom_fields: CustomFieldsCollection}}
+   */
+  static get associations() {
+    return {
+      custom_fields: CustomFieldsCollection,
+    };
+  }
+
+
   /**
    * @inheritdoc
    * Sanitize:
@@ -91,9 +106,13 @@ class ExternalResourceEntity extends EntityV2 {
         "id": resourceEntitySchema.properties.id,
         "name": metadataEntitySchema.properties.name,
         "username": metadataEntitySchema.properties.username,
-        "uri": {
-          "type": "string",
-          "maxLength": ResourceMetadataEntity.URI_MAX_LENGTH,
+        "uris": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "maxLength": RESOURCE_URI_MAX_LENGTH
+          },
+          "maxItems": RESOURCE_URIS_MAX_ITEMS
         },
         "description": metadataEntitySchema.properties.description,
         "secrets": resourceEntitySchema.properties.secrets,
@@ -111,6 +130,10 @@ class ExternalResourceEntity extends EntityV2 {
         },
         "expired": resourceEntitySchema.properties.expired,
         "icon": IconEntity.getSchema(),
+        "custom_fields": {
+          ...CustomFieldsCollection.getSchema(),
+          "nullable": true,
+        },
       }
     };
   }
@@ -140,6 +163,10 @@ class ExternalResourceEntity extends EntityV2 {
       result.icon = this._icon.toDto();
     }
 
+    if (this._customFields) {
+      result.custom_fields = this._customFields.toDto();
+    }
+
     return result;
   }
 
@@ -162,13 +189,14 @@ class ExternalResourceEntity extends EntityV2 {
       id: resourceEntityDto.id,
       name: resourceEntityDto.metadata.name,
       username: resourceEntityDto.metadata.username,
-      uri: resourceEntityDto.metadata.uris?.[0] || "",
+      uris: resourceEntityDto.metadata.uris || [],
       description: resourceEntityDto.metadata.description || null,
       secrets: resourceEntityDto.secrets || [],
       folder_parent_id: externalFolderParent?.id || null,
       resource_type_id: resourceEntityDto.resource_type_id,
       folder_parent_path: externalFolderParent?.path || "",
       expired: resourceEntityDto.expired || null,
+      custom_fields: resourceEntityDto.metadata.custom_fields || [],
     };
 
     if (resourceEntityDto.metadata.icon) {
@@ -178,6 +206,15 @@ class ExternalResourceEntity extends EntityV2 {
     return data;
   }
 
+  /**
+   * ResourceMetadataEntity.URI_MAX_LENGTH
+   * @returns {number}
+   */
+  static get URI_MAX_LENGTH() {
+    return RESOURCE_URI_MAX_LENGTH;
+  }
+
+
   /**
    * Returns a Resource DTO in v5 format.
    * @returns {Object}
@@ -188,9 +225,10 @@ class ExternalResourceEntity extends EntityV2 {
         object_type: ResourceMetadataEntity.METADATA_OBJECT_TYPE,
         name: this.name,
         username: this.username,
-        uris: [this.uri || ""],
+        uris: this.uris,
         description: this.description,
         resource_type_id: this.resourceTypeId,
+        custom_fields: this.customFields?.toMetadataDto()
       },
       secrets: this._secrets.toDto(),
       folder_parent_id: this.folderParentId,
@@ -237,11 +275,11 @@ class ExternalResourceEntity extends EntityV2 {
   }
 
   /**
-   * Get resource uri
+   * Get resource uris
    * @returns {string|null}
    */
-  get uri() {
-    return this._props.uri || null;
+  get uris() {
+    return this._props.uris || [];
   }
 
   /**
@@ -430,11 +468,30 @@ class ExternalResourceEntity extends EntityV2 {
     return this._icon || null;
   }
 
+  /**
+   * Get the custom fields collection
+   * @returns {CustomFieldsCollection|null}
+   */
+  get customFields() {
+    return this._customFields || null;
+  }
+
+  /**
+   * Set the custom fields
+   * @param {CustomFieldsCollection} customFields the custom fields collection to us
+   * @returns {void}
+   */
+  set customFields(customFields) {
+    assertType(customFields, CustomFieldsCollection);
+    this._customFields = customFields;
+  }
+
   /*
    * ==================================================
    * Static properties getters
    * ==================================================
    */
+
   /**
    * ExternalResourceEntity.DEFAULT_RESOURCE_NAME
    * @returns {string}