passbolt-browser-extension 5.3.2 → 5.4.1

package/src/all/background_page/model/import/resources/csvRowParser/csvLogMeOnceRowParser.js

@@ -23,7 +23,7 @@ class CsvLogMeOnceRowParser extends AbstractCsvRowParser {
   static get mapping() {
     return {
       "name": "name",
-      "uri": "url",
+      "uris": "url",
       "description": "note",
       "folder_parent_path": "group",
       "username": "username",
@@ -44,10 +44,13 @@ class CsvLogMeOnceRowParser extends AbstractCsvRowParser {
     const externalResourceDto = {};
 
     for (const propertyName in this.mapping) {
-      if (data[this.mapping[propertyName]]) {
+      if (propertyName === "uris") {
+        externalResourceDto[propertyName] = [data[this.mapping[propertyName]]];
+      } else if (data[this.mapping[propertyName]]) {
         externalResourceDto[propertyName] = data[this.mapping[propertyName]];
       }
     }
+
     resourceTypesCollection.filterByResourceTypeVersion(metadataTypesSettings.defaultResourceTypes);
     const scores = ResourcesTypeImportParser.getScores(externalResourceDto, resourceTypesCollection);
     let resourceType = ResourcesTypeImportParser.findMatchingResourceType(resourceTypesCollection, scores);

package/src/all/background_page/model/import/resources/csvRowParser/csvLogMeOnceRowParser.test.js

@@ -68,7 +68,7 @@ describe("CsvLogMeOnceRowParser", () => {
     const expectedEntity = new ExternalResourceEntity({
       name: data.name,
       username: data.username,
-      uri: data.url,
+      uris: [data.url],
       resource_type_id: expectedResourceType.id,
       secret_clear: data.password,
       description: data.note,
@@ -105,7 +105,7 @@ describe("CsvLogMeOnceRowParser", () => {
     const expectedEntity = new ExternalResourceEntity({
       name: data.name,
       username: data.username,
-      uri: data.url,
+      uris: [data.url],
       resource_type_id: expectedResourceType.id,
       secret_clear: data.password,
       description: data.note,

package/src/all/background_page/model/import/resources/csvRowParser/csvMozillaPlatformRowParser.js

@@ -24,7 +24,7 @@ class CsvMozillaPlatformRowParser extends AbstractCsvRowParser {
     return {
       "name": "url",
       "username": "username",
-      "uri": "url",
+      "uris": "url",
       "secret_clear": "password",
     };
   }
@@ -41,7 +41,9 @@ class CsvMozillaPlatformRowParser extends AbstractCsvRowParser {
     const externalResourceDto = {};
 
     for (const propertyName in this.mapping) {
-      if (data[this.mapping[propertyName]]) {
+      if (propertyName === "uris") {
+        externalResourceDto[propertyName] = [data[this.mapping[propertyName]]];
+      } else if (data[this.mapping[propertyName]]) {
         externalResourceDto[propertyName] = data[this.mapping[propertyName]];
       }
     }
@@ -56,7 +58,7 @@ class CsvMozillaPlatformRowParser extends AbstractCsvRowParser {
       }
       if (!resourceType) {
         //Fallback default content type not supported
-        resourceType = ResourcesTypeImportParser.fallbackDefaulResourceType(resourceTypesCollection, scores);
+        resourceType = ResourcesTypeImportParser.fallbackDefaulResourceType(resourceTypesCollection, metadataTypesSettings);
         importEntity.importResourcesErrors.push(new ImportError("Imported with default content type", externalResourceDto, new Error("No resource type associated to this row.")));
       }
     }

package/src/all/background_page/model/import/resources/csvRowParser/csvMozillaPlatformRowParser.test.js

@@ -65,7 +65,7 @@ describe("CsvMozillaPlatformRowParser", () => {
     const expectedEntity = new ExternalResourceEntity({
       name: data.name,
       username: data.username,
-      uri: data.url,
+      uris: [data.url],
       resource_type_id: expectedResourceType.id,
       secret_clear: data.password,
     });
@@ -98,7 +98,7 @@ describe("CsvMozillaPlatformRowParser", () => {
     const expectedEntity = new ExternalResourceEntity({
       name: data.name,
       username: data.username,
-      uri: data.url,
+      uris: [data.url],
       resource_type_id: expectedResourceType.id,
       secret_clear: data.password,
     });

package/src/all/background_page/model/import/resources/csvRowParser/csvNordpassRowParser.js

@@ -23,7 +23,7 @@ class CsvNordpassRowParser extends AbstractCsvRowParser {
   static get mapping() {
     return {
       "name": "name",
-      "uri": "url",
+      "uris": "url",
       "username": "username",
       "secret_clear": "password",
       "description": "note",
@@ -57,7 +57,9 @@ class CsvNordpassRowParser extends AbstractCsvRowParser {
     const externalResourceDto = {};
 
     for (const propertyName in this.mapping) {
-      if (data[this.mapping[propertyName]]) {
+      if (propertyName === "uris") {
+        externalResourceDto[propertyName] = [data[this.mapping[propertyName]]];
+      } else if (data[this.mapping[propertyName]]) {
         externalResourceDto[propertyName] = data[this.mapping[propertyName]];
       }
     }

package/src/all/background_page/model/import/resources/csvRowParser/csvNordpassRowParser.test.js

@@ -66,7 +66,7 @@ describe("CsvNordpassRowParser", () => {
     const expectedEntity = new ExternalResourceEntity({
       name: data.name,
       username: data.username,
-      uri: data.url,
+      uris: [data.url],
       resource_type_id: expectedResourceType.id,
       secret_clear: data.password,
       description: data.note,
@@ -102,7 +102,7 @@ describe("CsvNordpassRowParser", () => {
     const expectedEntity = new ExternalResourceEntity({
       name: data.name,
       username: data.username,
-      uri: data.url,
+      uris: [data.url],
       resource_type_id: expectedResourceType.id,
       secret_clear: data.password,
       description: data.note,

package/src/all/background_page/model/import/resources/csvRowParser/csvSafariRowParser.js

@@ -23,7 +23,7 @@ class CsvSafariRowParser extends AbstractCsvRowParser {
   static get mapping() {
     return {
       "name": "Title",
-      "uri": "URL",
+      "uris": "URL",
       "username": "Username",
       "secret_clear": "Password",
       "description": "Notes",
@@ -42,7 +42,9 @@ class CsvSafariRowParser extends AbstractCsvRowParser {
   static parse(data, importEntity, resourceTypesCollection, metadataTypesSettings) {
     const externalResourceDto = {};
     for (const propertyName in this.mapping) {
-      if (data[this.mapping[propertyName]]) {
+      if (propertyName === "uris") {
+        externalResourceDto[propertyName] = [data[this.mapping[propertyName]]];
+      } else if (data[this.mapping[propertyName]]) {
         externalResourceDto[propertyName] = data[this.mapping[propertyName]];
       }
     }

package/src/all/background_page/model/import/resources/csvRowParser/csvSafariRowParser.test.js

@@ -65,7 +65,7 @@ describe("CsvSafariRowParser", () => {
     const expectedEntity = new ExternalResourceEntity({
       name: data.Title,
       username: data.Username,
-      uri: data.URL,
+      uris: [data.URL],
       resource_type_id: expectedResourceType.id,
       secret_clear: data.Password,
       description: data.Notes,
@@ -99,7 +99,7 @@ describe("CsvSafariRowParser", () => {
     const expectedEntity = new ExternalResourceEntity({
       name: data.Title,
       username: data.Username,
-      uri: data.URL,
+      uris: [data.URL],
       resource_type_id: expectedResourceType.id,
       secret_clear: data.Password,
       description: data.Notes,

package/src/all/background_page/model/import/resources/resourcesCsvImportParser.test.js

@@ -315,7 +315,7 @@ describe("ResourcesCsvImportParser", () => {
     return Object.assign({
       name: `Password ${num}`,
       username: `username${num}`,
-      uri: `https://url${num}.com`,
+      uris: [`https://url${num}.com`],
       description: `Description ${num}`,
       secret_clear: `Secret ${num}`,
       folder_parent_path: ``,

package/src/all/background_page/model/import/resources/resourcesKdbxImportParser.js

@@ -17,6 +17,11 @@ import * as kdbxweb from 'kdbxweb';
 import ExternalTotpEntity from "../../entity/totp/externalTotpEntity";
 import ResourcesTypeImportParser from "./resourcesTypeImportParser";
 import {ICON_TYPE_KEEPASS_ICON_SET} from "passbolt-styleguide/src/shared/models/entity/resource/metadata/IconEntity";
+import {CUSTOM_FIELD_TYPE} from "passbolt-styleguide/src/shared/models/entity/customField/customFieldEntity";
+import {v4 as uuidv4} from "uuid";
+
+const KDBX_SUPPORTED_FIELDS = ['Title', 'URL', 'UserName', 'Notes', 'otp', 'TimeOtp-Secret-Base32', 'TimeOtp-Algorithm', 'TimeOtp-Length', 'TimeOtp-Period', 'Password'];
+
 
 class ResourcesKdbxImportParser {
   /**
@@ -126,7 +131,6 @@ class ResourcesKdbxImportParser {
   parseResource(kdbxEntry) {
     const externalResourceDto = {
       name: kdbxEntry.fields.get('Title') ? kdbxEntry.fields.get('Title').trim() : "",
-      uri: kdbxEntry.fields.get('URL') ? kdbxEntry.fields.get('URL').trim() : "",
       username: kdbxEntry.fields.get('UserName') ? kdbxEntry.fields.get('UserName').trim() : "",
       description: kdbxEntry.fields.get('Notes') ? kdbxEntry.fields.get('Notes').trim() : "",
       folder_parent_path: this.getKdbxEntryPath(kdbxEntry),
@@ -137,44 +141,14 @@ class ResourcesKdbxImportParser {
     if (typeof kdbxEntry.fields.get('Password') === 'object') {
       externalResourceDto.secret_clear = kdbxEntry.fields.get('Password').getText();
     }
-
     try {
-      const totp = this.getTotp(kdbxEntry);
-      if (totp) {
-        externalResourceDto.totp = totp;
-      }
-
-      this.resourceTypesCollection.filterByResourceTypeVersion(this.metadataTypesSettings.defaultResourceTypes);
-
-      const scores = ResourcesTypeImportParser.getScores(externalResourceDto, this.resourceTypesCollection);
-
-      let resourceType = ResourcesTypeImportParser.findMatchingResourceType(this.resourceTypesCollection, scores);
-
-      if (!resourceType) {
-        resourceType = ResourcesTypeImportParser.findPartialResourceType(this.resourceTypesCollection, scores);
-        if (resourceType) {
-          this.importEntity.importResourcesErrors.push(new ImportError("Resource partially imported", externalResourceDto));
-        }
-        if (!resourceType) {
-          //Fallback default content type not supported
-          resourceType = ResourcesTypeImportParser.fallbackDefaulResourceType(this.resourceTypesCollection, this.metadataTypesSettings);
-          this.importEntity.importResourcesErrors.push(new ImportError("Content type not supported but imported with default resource type", externalResourceDto));
-        }
-      }
-
-      if ((kdbxEntry.bgColor || kdbxEntry.icon) && resourceType.isV5()) {
-        externalResourceDto.icon = {};
-
-        if (kdbxEntry.icon) {
-          externalResourceDto.icon.type = ICON_TYPE_KEEPASS_ICON_SET;
-          externalResourceDto.icon.value = kdbxEntry.icon;
-        }
+      this.parseUris(kdbxEntry, externalResourceDto);
+      this.parseTotp(kdbxEntry, externalResourceDto);
 
-        if (kdbxEntry.bgColor) {
-          externalResourceDto.icon.background_color = kdbxEntry.bgColor;
-        }
-      }
+      const resourceType = this.getResourceType(externalResourceDto);
 
+      this.parseIcon(kdbxEntry, externalResourceDto, resourceType);
+      this.parseCustomFields(kdbxEntry, externalResourceDto, resourceType);
       //resourceType should never be empty to not block end user
       externalResourceDto.resource_type_id = resourceType.id;
 
@@ -189,20 +163,129 @@ class ResourcesKdbxImportParser {
   }
 
   /**
-   * Get the totp
+   * Parse URIs from a kdbx entry
+   * @param {KdbxEntry} kdbxEntry The kdbx entry
+   * @param {ExternalResourceDto} externalResourceDto The external resource dto
+   * @private
+   * @return {void}
+   */
+  parseUris(kdbxEntry, externalResourceDto) {
+    const uri = kdbxEntry.fields.get('URL') ? kdbxEntry.fields.get('URL').trim() : "";
+    const additionalUris = [uri];
+
+    let additionalEntriesUris = [...kdbxEntry.fields.entries()]
+      .filter(([key]) => key.startsWith('KP2A_URL'))
+      .map(([, value]) => (value));
+
+    if (additionalEntriesUris.length > 31) {
+      this.importEntity.importResourcesErrors.push(new ImportError(
+        "Resource has more than 32 URIs, only the first 32 will be imported",
+        externalResourceDto
+      ));
+    }
+    additionalEntriesUris = additionalEntriesUris.slice(0, 31);
+
+    for (const additionalUri of additionalEntriesUris) {
+      additionalUris.push(additionalUri.trim());
+    }
+
+    externalResourceDto.uris = additionalUris;
+  }
+  /**
+   * Parse the icon of the kdbx entry
+   * @param {kdbxweb.KdbxEntry} kdbxEntry
+   * @param {ExternalResourceDto} externalResourceDto
+   * @param {ResourceTypeEntity} resourceType
+   * @private
+   * @returns {void}
+   */
+  parseIcon(kdbxEntry, externalResourceDto, resourceType) {
+    if ((kdbxEntry.bgColor || kdbxEntry.icon) && resourceType.isV5()) {
+      externalResourceDto.icon = {};
+
+      if (kdbxEntry.icon) {
+        externalResourceDto.icon.type = ICON_TYPE_KEEPASS_ICON_SET;
+        externalResourceDto.icon.value = kdbxEntry.icon;
+      }
+
+      if (kdbxEntry.bgColor) {
+        externalResourceDto.icon.background_color = kdbxEntry.bgColor;
+      }
+    }
+  }
+
+  /**
+   * Parse the custom fields of the kdbx entry
+   * @param {kdbxEntry} kdbxEntry
+   * @param {ExternalResourceDto} externalResourceDto
+   * @param {ResourceTypeEntity} resourceType
+   * @private
+   * @returns {void}
+   */
+  parseCustomFields(kdbxEntry, externalResourceDto, resourceType) {
+    if (resourceType.isV5()) {
+      const customFields = [];
+      kdbxEntry.fields.forEach((value, key) => {
+        if (!KDBX_SUPPORTED_FIELDS.includes(key) && !key.startsWith('KP2A_URL')) {
+          const customFieldValue = typeof value === 'string' ? value : value.getText();
+          customFields.push({
+            id: uuidv4(),
+            type: CUSTOM_FIELD_TYPE.TEXT,
+            metadata_key: key,
+            secret_value: customFieldValue
+          });
+        }
+      });
+      if (customFields.length > 0) {
+        externalResourceDto.custom_fields = customFields;
+      }
+    }
+  }
+
+  /**
+   * parse the totp of the kdbx entry
    * @param {kdbxweb.KdbxEntry} kdbxEntry
-   * @return {*}
+   * @param {ExternalResourceDto} externalResourceDto
+   * @private
+   * @returns {void}
    */
-  getTotp(kdbxEntry) {
+  parseTotp(kdbxEntry, externalResourceDto) {
     if (kdbxEntry.fields.get('otp')) {
       const totpUrl = typeof kdbxEntry.fields.get('otp') === 'object' ? kdbxEntry.fields.get('otp').getText() : kdbxEntry.fields.get('otp');
       const totpUrlDecoded = new URL(decodeURIComponent(totpUrl));
       const totp = ExternalTotpEntity.createTotpFromUrl(totpUrlDecoded);
-      return totp.toDto();
+      externalResourceDto.totp = totp.toDto();
     } else if (typeof kdbxEntry.fields.get('TimeOtp-Secret-Base32') === 'object') {
       const totp = ExternalTotpEntity.createTotpFromKdbxWindows(kdbxEntry.fields);
-      return totp.toDto();
+      externalResourceDto.totp = totp.toDto();
+    }
+  }
+
+  /**
+   * Get the resource type
+   * @param {ExternalResourceDto} externalResourceDto
+   * @return {ResourceTypeDto}
+   */
+  getResourceType(externalResourceDto) {
+    this.resourceTypesCollection.filterByResourceTypeVersion(this.metadataTypesSettings.defaultResourceTypes);
+
+    const scores = ResourcesTypeImportParser.getScores(externalResourceDto, this.resourceTypesCollection);
+
+    let resourceType = ResourcesTypeImportParser.findMatchingResourceType(this.resourceTypesCollection, scores);
+
+    if (resourceType) {
+      return resourceType;
+    }
+
+    resourceType = ResourcesTypeImportParser.findPartialResourceType(this.resourceTypesCollection, scores);
+    if (resourceType) {
+      this.importEntity.importResourcesErrors.push(new ImportError("Resource partially imported", externalResourceDto));
+    } else {
+      //Fallback default content type not supported
+      resourceType = ResourcesTypeImportParser.fallbackDefaulResourceType(this.resourceTypesCollection, this.metadataTypesSettings);
+      this.importEntity.importResourcesErrors.push(new ImportError("Content type not supported but imported with default resource type", externalResourceDto));
     }
+    return resourceType;
   }
 
   /**

package/src/all/background_page/model/import/resources/resourcesKdbxImportParser.test.js

@@ -129,7 +129,7 @@ describe("ResourcesKdbxImportParser", () => {
     return Object.assign({
       name: `Password ${num}`,
       username: `username${num}`,
-      uri: `https://url${num}.com`,
+      uris: [`https://url${num}.com`],
       description: `Description ${num}`,
       secret_clear: `Secret ${num}`,
       folder_parent_path: ``,
@@ -355,6 +355,138 @@ describe("ResourcesKdbxImportParser", () => {
     expect(importEntity.importResources.items[1]._icon).toBeUndefined();
   });
 
+
+  it("should import the multiple uris", async() => {
+    expect.assertions(2);
+
+    const metadataTypesSettings = new MetadataTypesSettingsEntity(defaultMetadataTypesSettingsV6Dto());
+
+    const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-multiple-uris.kdbx", {encoding: 'base64'});
+    const importDto = {
+      "ref": "import-ref",
+      "file_type": "kdbx",
+      "file": file,
+      "options": {
+        "credentials": {
+          "password": "passbolt"
+        }
+      }
+    };
+    const importEntity = new ImportResourcesFileEntity(importDto);
+    const parser = new ResourcesKdbxImportParser(importEntity, resourceTypesCollection, metadataTypesSettings);
+    await parser.parseImport();
+
+    // Assert resources
+    expect(importEntity.importResources.items).toHaveLength(1);
+    expect(importEntity.importResources.items[0].uris).toEqual([
+      'https://main.url',
+      'https://additional1.url',
+      'https://additional2.url',
+      'https://additional3.url'
+    ]);
+  });
+
+  it("should import max 32 multiple uris", async() => {
+    expect.assertions(3);
+
+    const metadataTypesSettings = new MetadataTypesSettingsEntity(defaultMetadataTypesSettingsV6Dto());
+
+    const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-multiple-uris-with-33-entries.kdbx", {encoding: 'base64'});
+    const importDto = {
+      "ref": "import-ref",
+      "file_type": "kdbx",
+      "file": file,
+      "options": {
+        "credentials": {
+          "password": "passbolt"
+        }
+      }
+    };
+    const importEntity = new ImportResourcesFileEntity(importDto);
+    const parser = new ResourcesKdbxImportParser(importEntity, resourceTypesCollection, metadataTypesSettings);
+    await parser.parseImport();
+
+    // Assert resources
+    expect(importEntity.importResources.items).toHaveLength(1);
+    expect(importEntity.importResources.items[0].uris).toHaveLength(32);
+    expect(importEntity.importResourcesErrors).toHaveLength(1);
+  });
+
+  it("should import custom fields", async() => {
+    expect.assertions(4);
+
+    const metadataTypesSettings = new MetadataTypesSettingsEntity(defaultMetadataTypesSettingsV6Dto());
+
+    const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-custom-fields-with-uris.kdbx", {encoding: 'base64'});
+    const importDto = {
+      "ref": "import-ref",
+      "file_type": "kdbx",
+      "file": file,
+      "options": {
+        "credentials": {
+          "password": "passbolt"
+        }
+      }
+    };
+    const importEntity = new ImportResourcesFileEntity(importDto);
+    const parser = new ResourcesKdbxImportParser(importEntity, resourceTypesCollection, metadataTypesSettings);
+    await parser.parseImport();
+
+    // Assert resources
+    expect(importEntity.importResources.items).toHaveLength(1);
+    expect(importEntity.importResources.items[0].customFields).toHaveLength(3);
+    expect(importEntity.importResources.items[0].uris).toHaveLength(3);
+    expect(importEntity.importResourcesErrors).toHaveLength(0);
+  });
+
+  it("should import custom fields with protected values", async() => {
+    expect.assertions(4);
+
+    const metadataTypesSettings = new MetadataTypesSettingsEntity(defaultMetadataTypesSettingsV6Dto());
+
+    const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-with-protected-custom-fields.kdbx", {encoding: 'base64'});
+    const importDto = {
+      "ref": "import-ref",
+      "file_type": "kdbx",
+      "file": file,
+      "options": {
+        "credentials": {
+          "password": "passbolt"
+        }
+      }
+    };
+    const importEntity = new ImportResourcesFileEntity(importDto);
+    const parser = new ResourcesKdbxImportParser(importEntity, resourceTypesCollection, metadataTypesSettings);
+    await parser.parseImport();
+
+    // Assert resources
+    expect(importEntity.importResources.items).toHaveLength(1);
+    expect(importEntity.importResources.items[0].customFields).toHaveLength(1);
+    expect(importEntity.importResources.items[0].uris).toHaveLength(1);
+    expect(importEntity.importResourcesErrors).toHaveLength(1);
+  });
+
+  it("should not import custom fields  if the default is v4", async() => {
+    expect.assertions(2);
+    const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-custom-fields-with-uris.kdbx", {encoding: 'base64'});
+    const importDto = {
+      "ref": "import-ref",
+      "file_type": "kdbx",
+      "file": file,
+      "options": {
+        "credentials": {
+          "password": "passbolt"
+        }
+      }
+    };
+    const importEntity = new ImportResourcesFileEntity(importDto);
+    const parser = new ResourcesKdbxImportParser(importEntity, resourceTypesCollection, metadataTypesSettings);
+    await parser.parseImport();
+
+    // Assert resources
+    expect(importEntity.importResources.items).toHaveLength(1);
+    expect(importEntity.importResources.items[0].customFields).toBeNull();
+  });
   it("should not import the icon if the default is v4", async() => {
     expect.assertions(3);
     const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-protected-with-color-and-icon.kdbx", {encoding: 'base64'});

package/src/all/background_page/model/import/resourcesImportParser.test.js

@@ -18,7 +18,6 @@ import ResourcesImportParser from "./resourcesImportParser";
 import ImportResourcesFileEntity from "../entity/import/importResourcesFileEntity";
 import ResourcesCsvImportParser from "./resources/resourcesCsvImportParser";
 
-
 describe("ResourcesImportParser", () => {
   it("should be able to parse CSV file", async() => {
     const file = "VGl0bGUsVXNlcm5hbWUsVVJMLFBhc3N3b3JkLE5vdGVzLEdyb3VwClBhc3N3b3JkIDEsdXNlcm5hbWUxLGh0dHBzOi8vdXJsMS5jb20sU2VjcmV0IDEsRGVzY3JpcHRpb24gMSxGb2xkZXIgMS9Gb2xkZXIgMgpQYXNzd29yZCAyLHVzZXJuYW1lMixodHRwczovL3VybDIuY29tLFNlY3JldCAyLERlc2NyaXB0aW9uIDIsRm9sZGVyIDEKUGFzc3dvcmQgMyx1c2VybmFtZTMsaHR0cHM6Ly91cmwzLmNvbSxTZWNyZXQgMyxEZXNjcmlwdGlvbiAzLEZvbGRlciAzL0ZvbGRlciA0ClBhc3N3b3JkIDQsdXNlcm5hbWU0LGh0dHBzOi8vdXJsNC5jb20sU2VjcmV0IDQsRGVzY3JpcHRpb24gNCxGb2xkZXIgMi9Gb2xkZXIgMQ==";

package/src/all/background_page/model/resource/resourceModel.js

@@ -19,9 +19,7 @@ import ResourceEntity from "../entity/resource/resourceEntity";
 import PermissionChangesCollection from "../entity/permission/change/permissionChangesCollection";
 import ResourceService from "../../service/api/resource/resourceService";
 import PlaintextEntity from "../entity/plaintext/plaintextEntity";
-import splitBySize from "../../utils/array/splitBySize";
 
-const BULK_OPERATION_SIZE = 5;
 const MAX_LENGTH_PLAINTEXT = 4096;
 
 class ResourceModel {
@@ -199,72 +197,6 @@ class ResourceModel {
     await ResourceLocalStorage.updateResourcesCollection(resourcesCollection);
   }
 
-  /**
-   * Delete a resource using Passbolt API and remove the resource from the local storage
-   *
-   * @param {string} resourceId The resource id
-   * @returns {Promise<void>}
-   */
-  async delete(resourceId) {
-    await this.resourceService.delete(resourceId);
-    await ResourceLocalStorage.delete(resourceId);
-  }
-
-  /*
-   * ==============================================================
-   *  Bulk operations
-   * ==============================================================
-   */
-
-  /**
-   * Delete a bulk of resources
-   * @param {Array<string>} resourcesIds collection The list of uuids to delete
-   * @param {{successCallback: function, errorCallback: function}?} callbacks The intermediate operation callbacks
-   * @returns {Promise<array<*>>}
-   */
-  async bulkDelete(resourcesIds, callbacks) {
-    let result = [];
-
-    // Parallelize the operations by chunk of BULK_OPERATION_SIZE operations.
-    const chunks = splitBySize(resourcesIds, BULK_OPERATION_SIZE);
-    for (const chunkIndex in chunks) {
-      const chunk = chunks[chunkIndex];
-      const promises = chunk.map(async(resourceId, mapIndex) => {
-        const collectionIndex = (chunkIndex * BULK_OPERATION_SIZE) + mapIndex;
-        return this._bulkDelete_deleteResource(resourceId, collectionIndex, callbacks);
-      });
-
-      const bulkPromises = await Promise.allSettled(promises);
-      const intermediateResult = bulkPromises.map(promiseResult => promiseResult.value);
-      result = [...result, ...intermediateResult];
-    }
-
-    return result;
-  }
-
-  /**
-   * Delete a resource for the bulkDelete function.
-   * @param {string} resourceId The resource to delete
-   * @param {int} collectionIndex The index of the resource in the initial collection
-   * @param {{successCallback: function, errorCallback: function}?} callbacks The intermediate operation callbacks
-   * @returns {Promise<ResourceEntity|Error>}
-   * @private
-   */
-  async _bulkDelete_deleteResource(resourceId, collectionIndex, callbacks) {
-    callbacks = callbacks || {};
-    const successCallback = callbacks.successCallback || (() => {});
-    const errorCallback = callbacks.errorCallback || (() => {});
-
-    try {
-      await this.delete(resourceId);
-      successCallback(collectionIndex);
-    } catch (error) {
-      console.error(error);
-      errorCallback(error, collectionIndex);
-      throw error;
-    }
-  }
-
   /*
    * ==============================================================
    *  Secret plaintext serialization

package/src/all/background_page/service/api/comment/commentApiService.test.js

@@ -25,7 +25,7 @@ import PassboltServiceUnavailableError from "passbolt-styleguide/src/shared/lib/
 import CommentEntity from "../../../model/entity/comment/commentEntity";
 import {mockApiResponseError} from "../../../../../../test/mocks/mockApiResponse";
 
-describe.only("ActionLogService", () => {
+describe("ActionLogService", () => {
   let apiClientOptions, account;
   beforeEach(async() => {
     enableFetchMocks();