passbolt-browser-extension 5.2.0 → 5.3.0

package/src/all/background_page/service/resource/findAndUpdateResourcesLocalStorageService.test.js

@@ -371,4 +371,104 @@ describe("UpdateResourcesLocalStorage", () => {
       expect(expectLocalStorageResult[1]).toEqual(ResourceEntity.transformDtoFromV4toV5(resourceDto2));
     });
   });
+
+  describe("::findAndUpdateAllByParentFolderId", () => {
+    let service;
+
+    beforeEach(() => {
+      service = new FindAndUpdateResourcesLocalStorage(account, apiClientOptions);
+      jest.spyOn(ResourceTypeService.prototype, "findAll").mockImplementation(() => resourceTypesCollectionDto());
+    });
+
+    it("should extract the id from the resource collection", async() => {
+      expect.assertions(2);
+
+      const parentFolderId = uuidv4();
+
+      const resourcesDto = multipleResourceDtos();
+      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => resourcesDto);
+      jest.spyOn(service.findResourcesServices, "findAllByParentFolderIdForLocalStorage");
+
+      await service.findAndUpdateAllByParentFolderId(parentFolderId);
+
+      expect(service.findResourcesServices.findAllByParentFolderIdForLocalStorage).toHaveBeenCalledTimes(1);
+      expect(service.findResourcesServices.findAllByParentFolderIdForLocalStorage).toHaveBeenCalledWith(parentFolderId);
+    });
+
+    it("should assert its parameter", async() => {
+      expect.assertions(1);
+      await expect(() => service.findAndUpdateAllByParentFolderId("test")).rejects.toThrow();
+    });
+
+    it("should update the local storage resource collection by removing deleted resources, moving resources and updating resources data", async() => {
+      expect.assertions(8);
+
+      const parentFolderId = uuidv4();
+      const otherParentFolderId = uuidv4();
+
+      /*
+       * Resources collection in local storage:
+       * Resource0.folderParentId = null;
+       * Resource1.folderParentId = parentFolderId; // on API it should be modified only
+       * Resource2.folderParentId = parentFolderId; // on API it should be moved
+       * Resource3.folderParentId = parentFolderId; // on API it should be removed
+       */
+
+      const resourcesDto = multipleResourceDtos();
+      resourcesDto[1].folder_parent_id = parentFolderId;
+      resourcesDto[2].folder_parent_id = parentFolderId;
+      resourcesDto[3].folder_parent_id = parentFolderId;
+
+      delete resourcesDto[0].name;
+      delete resourcesDto[1].name;
+      delete resourcesDto[2].name;
+      delete resourcesDto[3].name;
+
+      const localStorageResourceCollection = new ResourcesCollection(resourcesDto);
+      await ResourceLocalStorage.set(localStorageResourceCollection);
+
+      // the resources in the folder on the API does not have resource2 anymore but resources1 remains and is changed.
+      const apiResourcesDtoInFolder = [
+        {...resourcesDto[1]},
+      ];
+      apiResourcesDtoInFolder[0].metadata.name = "Resource1 - UPDATED";
+      apiResourcesDtoInFolder[0].modified = (new Date()).toISOString();
+
+      // resource2 on the API will be return and updated, resource3 will never be sent back as it is deleted
+      const allIdsApiResourcesDto = [
+        {...resourcesDto[2]},
+      ];
+      allIdsApiResourcesDto[0].folder_parent_id = otherParentFolderId;
+
+      async function mockedFindAllApi(_, filter) {
+        const isParentFolderSearchRequest = Boolean(filter["has-parent"]);
+
+        return isParentFolderSearchRequest
+          ? apiResourcesDtoInFolder
+          : allIdsApiResourcesDto;
+      }
+
+      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(mockedFindAllApi);
+
+      await service.findAndUpdateAllByParentFolderId(parentFolderId);
+
+      const updatedResourceLocalStorage = new ResourcesCollection(await ResourceLocalStorage.get());
+
+      expect(updatedResourceLocalStorage).toHaveLength(3); //1 resource should be removed compared to the original data
+      const resource0 = updatedResourceLocalStorage.getFirstById(resourcesDto[0].id);
+      expect(resource0.toDto(ResourceEntity.ALL_CONTAIN_OPTIONS)).toStrictEqual(resourcesDto[0]); //this resource should remain unchanged
+
+      const updatedResource1 = updatedResourceLocalStorage.getFirstById(resourcesDto[1].id); // this resource should have been updated but not moved
+      expect(updatedResource1.metadata.name).toStrictEqual("Resource1 - UPDATED");
+      expect(updatedResource1.modified).toStrictEqual(apiResourcesDtoInFolder[0].modified);
+      expect(updatedResource1.folderParentId).toStrictEqual(parentFolderId);
+
+      const updatedResource2 = updatedResourceLocalStorage.getFirstById(resourcesDto[2].id); // this resource should not have changed per say but only moved
+      expect(updatedResource2.modified).toStrictEqual(resourcesDto[2].modified);
+      expect(updatedResource2.folderParentId).toStrictEqual(otherParentFolderId);
+
+      const updatedResource3 = updatedResourceLocalStorage.getFirstById(resourcesDto[3].id); // this resource should have been removed
+      expect(updatedResource3).toBeUndefined();
+    });
+  });
 });

package/src/all/background_page/service/resource/findResourcesService.js

@@ -46,18 +46,9 @@ export default class FindResourcesService {
    * @returns {Promise<ResourcesCollection>}
    * @private
    */
-  async findAll(contains, filters, ignoreInvalidEntity) {
-    //Assert contains
-    const supportedOptions = ResourceService.getSupportedContainOptions();
-    const supportedFilter = ResourceService.getSupportedFiltersOptions();
-
-    if (contains && !Object.keys(contains).every(option => supportedOptions.includes(option))) {
-      throw new Error("Unsupported contains parameter used, please check supported contains");
-    }
-
-    if (filters && !Object.keys(filters).every(filter => supportedFilter.includes(filter))) {
-      throw new Error("Unsupported filter parameter used, please check supported filters");
-    }
+  async findAll(contains, filters, ignoreInvalidEntity = false) {
+    this.assertContains(contains);
+    this.assertFilters(filters);
 
     const resourcesDto = await this.resourceService.findAll(contains, filters);
     return new ResourcesCollection(resourcesDto, {clone: false, ignoreInvalidEntity: ignoreInvalidEntity});
@@ -69,7 +60,7 @@ export default class FindResourcesService {
    * @param {Array<string>} resourcesIds
    * @returns {Promise<ResourcesCollection>}
    */
-  async findAllByIds(resourcesIds, contains = {}) {
+  async findAllByIds(resourcesIds, contains = {}, ignoreInvalidEntity = false) {
     assertArrayUUID(resourcesIds);
 
     // We split the requests in chunks in order to avoid any too long url error.
@@ -78,7 +69,7 @@ export default class FindResourcesService {
       const filter = {
         "has-id": resourceIds
       };
-      return async() => await this.findAll(contains, filter);
+      return async() => await this.findAll(contains, filter, ignoreInvalidEntity);
     });
 
     // @todo Later (tm). The Collection should provide this capability, ensuring that validation build rules are executed and performance is guaranteed.
@@ -196,12 +187,8 @@ export default class FindResourcesService {
    */
   async findOneById(resourceId, contains = {}) {
     assertUuid(resourceId);
-    //Assert contains
-    const supportedOptions = ResourceService.getSupportedContainOptions();
+    this.assertContains(contains);
 
-    if (contains && !Object.keys(contains).every(option => supportedOptions.includes(option))) {
-      throw new Error("Unsupported contains parameter used, please check supported contains");
-    }
     const resourcesDto  = await this.resourceService.get(resourceId, contains);
 
     return new ResourceEntity(resourcesDto);
@@ -224,4 +211,51 @@ export default class FindResourcesService {
     const resource = this.findOneById(resourceId, contains);
     return resource;
   }
+
+  /**
+   * Find all the resources matching the given ids for the local storage.
+   * All entities that cannot be validated will be ignored and excluded from the resulting collection.
+   * @param {Array<uuid>} resourceIds
+   * @returns {Promise<ResourcesCollection>}
+   */
+  async findAllByIdsForLocalStorage(resourceIds) {
+    assertArrayUUID(resourceIds);
+    return await this.findAllByIds(resourceIds, ResourceLocalStorage.DEFAULT_CONTAIN, true);
+  }
+
+  /**
+   * Find all the resources having the given parentFolderId as direct ancestor for the local storage
+   * All entities that cannot be validated will be ignored and excluded from the resulting collection.
+   * @param {uuid} parentFolderId
+   * @returns {Promise<ResourcesCollection>}
+   */
+  async findAllByParentFolderIdForLocalStorage(parentFolderId) {
+    assertUuid(parentFolderId);
+    const filters = {"has-parent": parentFolderId};
+    return await this.findAll(ResourceLocalStorage.DEFAULT_CONTAIN, filters, true);
+  }
+
+  /**
+   * Assert the contains to ensure they match the supported ones.
+   * @param {object} contains
+   * @private
+   */
+  assertContains(contains) {
+    const supportedOptions = ResourceService.getSupportedContainOptions();
+    if (contains && !Object.keys(contains).every(option => supportedOptions.includes(option))) {
+      throw new Error("Unsupported contains parameter used, please check supported contains");
+    }
+  }
+
+  /**
+   * Assert the filters to ensure they match the supported ones.
+   * @param {object} filters
+   * @private
+   */
+  assertFilters(filters) {
+    const supportedFilter = ResourceService.getSupportedFiltersOptions();
+    if (filters && !Object.keys(filters).every(filter => supportedFilter.includes(filter))) {
+      throw new Error("Unsupported filter parameter used, please check supported filters");
+    }
+  }
 }

package/src/all/background_page/service/resource/findResourcesService.test.js

@@ -590,4 +590,195 @@ describe("FindResourcesService", () => {
       await expect(promise).rejects.toThrowError("API error");
     });
   });
+
+  describe("::findAllByIdsForLocalStorage", () => {
+    let service, expectedContains;
+
+    beforeEach(() => {
+      service = new FindResourcesService(account, apiClientOptions);
+      expectedContains = {
+        permission: true,
+        favorite: true,
+        tag: true
+      };
+    });
+
+    it("should retrieve all resources by their ids", async() => {
+      expect.assertions(3);
+
+      const ressourcesDto = multipleResourceDtos();
+      const resourcesIds = ressourcesDto.map(r => r.id);
+
+      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => ressourcesDto);
+
+      const result = await service.findAllByIdsForLocalStorage(resourcesIds);
+
+      const resourcesIdsFilter = {"has-id": resourcesIds};
+
+      expect(result).toEqual(new ResourcesCollection(ressourcesDto));
+      expect(ResourceService.prototype.findAll).toHaveBeenCalledTimes(1);
+      expect(ResourceService.prototype.findAll).toHaveBeenCalledWith(expectedContains, resourcesIdsFilter);
+    });
+
+    it("should assert the given ids", async() => {
+      expect.assertions(1);
+
+      const resourcesIds = [uuidv4(), "test"];
+      await expect(() => service.findAllByIdsForLocalStorage(resourcesIds)).rejects.toThrowError();
+    });
+  });
+
+  describe("::findAllByParentFolderIdForLocalStorage", () => {
+    let service, expectedContains, expectedFilters;
+    const parentFolderId = uuidv4();
+
+    beforeEach(() => {
+      service = new FindResourcesService(account, apiClientOptions);
+      expectedContains = {
+        permission: true,
+        favorite: true,
+        tag: true
+      };
+
+      expectedFilters = {
+        'has-parent': parentFolderId
+      };
+    });
+
+    it("should retrieve all resources by parent folder id", async() => {
+      expect.assertions(3);
+
+      const ressourcesDto = multipleResourceDtos();
+
+      jest.spyOn(ResourceService.prototype, "findAll").mockImplementation(() => ressourcesDto);
+
+      const result = await service.findAllByParentFolderIdForLocalStorage(parentFolderId);
+
+      expect(result).toEqual(new ResourcesCollection(ressourcesDto));
+      expect(ResourceService.prototype.findAll).toHaveBeenCalledTimes(1);
+      expect(ResourceService.prototype.findAll).toHaveBeenCalledWith(expectedContains, expectedFilters);
+    });
+
+    it("should assert the given id", async() => {
+      expect.assertions(1);
+      await expect(() => service.findAllByParentFolderIdForLocalStorage("test")).rejects.toThrowError();
+    });
+  });
+
+  describe("::assertContains", () => {
+    it("should not throw errors if all given contains are fine", () => {
+      expect.assertions(1);
+
+      const service = new FindResourcesService(account, apiClientOptions);
+      const allContains = {
+        'creator': true,
+        'favorite': true,
+        'modifier': true,
+        'secret': true,
+        'permission': true,
+        'permissions': true,
+        'permissions.user.profile': true,
+        'permissions.group': true,
+        'tag': true,
+        'resource-type': true,
+      };
+
+      expect(() => service.assertContains(allContains)).not.toThrow();
+    });
+
+    it("should not throw errors if the contain has 1 element only", () => {
+      expect.assertions(1);
+
+      const service = new FindResourcesService(account, apiClientOptions);
+      const contains = {'permissions.user.profile': true};
+
+      expect(() => service.assertContains(contains)).not.toThrow();
+    });
+
+    it("should not throw errors if the contain is empty", () => {
+      expect.assertions(1);
+
+      const service = new FindResourcesService(account, apiClientOptions);
+      const contains = {};
+
+      expect(() => service.assertContains(contains)).not.toThrow();
+    });
+
+    it("should throw an error if at least of the contain is wrong", () => {
+      expect.assertions(1);
+
+      const service = new FindResourcesService(account, apiClientOptions);
+      const allContains = {
+        'creator': true,
+        'favorite': true,
+        'modifier': true,
+        'secret': true,
+        'permission': true,
+        'permissions': true,
+        'permissions.user.profile': true,
+        'permissions.group': true,
+        'tag': true,
+        'resource-type': true,
+        'resource-type-wrong': true,
+      };
+
+      expect(() => service.assertContains(allContains)).toThrow();
+    });
+  });
+
+
+  describe("::assertFilters", () => {
+    it("should not throw errors if all given filters are fine", () => {
+      expect.assertions(1);
+
+      const service = new FindResourcesService(account, apiClientOptions);
+      const allFilters = {
+        'is-favorite': true,
+        'is-shared-with-group': uuidv4(),
+        'is-owned-by-me': true,
+        'is-shared-with-me': true,
+        'has-id': uuidv4(),
+        'has-tag': uuidv4(),
+        "has-parent": uuidv4(),
+      };
+
+      expect(() => service.assertFilters(allFilters)).not.toThrow();
+    });
+
+    it("should not throw errors if the contain has 1 element only", () => {
+      expect.assertions(1);
+
+      const service = new FindResourcesService(account, apiClientOptions);
+      const contains = {'is-shared-with-me': true};
+
+      expect(() => service.assertFilters(contains)).not.toThrow();
+    });
+
+    it("should not throw errors if the filters is empty", () => {
+      expect.assertions(1);
+
+      const service = new FindResourcesService(account, apiClientOptions);
+      const contains = {};
+
+      expect(() => service.assertFilters(contains)).not.toThrow();
+    });
+
+    it("should throw an error if at least of the filters is wrong", () => {
+      expect.assertions(1);
+
+      const service = new FindResourcesService(account, apiClientOptions);
+      const allContains = {
+        'is-favorite': true,
+        'is-shared-with-group': uuidv4(),
+        'is-owned-by-me': true,
+        'is-shared-with-me': true,
+        'has-id': uuidv4(),
+        'has-tag': uuidv4(),
+        "has-parent": uuidv4(),
+        "has-parent-wrong": uuidv4(),
+      };
+
+      expect(() => service.assertFilters(allContains)).toThrow();
+    });
+  });
 });

package/src/all/background_page/service/resourceType/updateResourceTypesService.test.js

@@ -152,7 +152,7 @@ describe("UpdateResourceTypesService", () => {
 
       await service.updateAllDeletedStatus(resourcesTypesCollection);
 
-      expect(service.resourceTypeService.delete).toHaveBeenCalledTimes(4);
+      expect(service.resourceTypeService.delete).toHaveBeenCalledTimes(5);
       expect(service.resourceTypeService.undelete).toHaveBeenCalledTimes(4);
 
       expect(service.resourceTypeService.delete).toHaveBeenCalledWith(resourceTypesDto[0].id);

package/src/all/background_page/service/share/shareResourceService.test.js

@@ -51,7 +51,7 @@ import ResourcesCollection from "../../model/entity/resource/resourcesCollection
 import MetadataKeysSessionStorage from "../session_storage/metadataKeysSessionStorage";
 import PermissionChangesCollection from "../../model/entity/permission/change/permissionChangesCollection";
 import expect from "expect";
-import MockPort from "passbolt-styleguide/test/mocks/mockPort";
+import MockPort from "passbolt-styleguide/src/react-extension/test/mock/MockPort";
 import ProgressService from "../progress/progressService";
 import {METADATA_KEY_TYPE_METADATA_KEY, METADATA_KEY_TYPE_USER_KEY} from "../../model/entity/resource/resourceEntity";
 import ResourceTypeModel from "../../model/resourceType/resourceTypeModel";

package/src/all/locales/de-DE/common.json

@@ -105,8 +105,8 @@
   "The server key is expired.": "Der Server-Schlüssel ist abgelaufen.",
   "The service is unavailable": "Der Dienst ist nicht verfügbar",
   "The verificationResult keyID should be a valid keyID Object.": "The verificationResult keyID should be a valid keyID Object.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "The verificationResult verified should be a valid verified Promise<boolean>.",
   "This is not a valid passphrase": "Dies ist kein gültiges Kennwort",
   "This key does not match any account.": "Dieser Schlüssel stimmt mit keinem Konto überein.",
   "This key is already used by another user.": "Dieser Schlüssel wird bereits von einem anderen Benutzer verwendet.",

package/src/all/locales/es-ES/common.json

@@ -105,8 +105,8 @@
   "The server key is expired.": "La clave del servidor ha caducado.",
   "The service is unavailable": "El servicio no está disponible",
   "The verificationResult keyID should be a valid keyID Object.": "El ID de clave de la verificación de resultado debe ser un objeto ID de clave válido.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "La firma verificationResult debe ser un Promise<openpgp.Signature> verificado válido.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "El verificationResult debe ser un Promise<boolean> verificado válido.",
   "This is not a valid passphrase": "Esta no es una contraseña válida",
   "This key does not match any account.": "Esta clave no coincide con ninguna cuenta.",
   "This key is already used by another user.": "Esta clave ya está siendo usada por otro usuario.",

package/src/all/locales/fr-FR/common.json

@@ -73,7 +73,7 @@
   "Synchronizing keyring": "Synchronisation du porte-clés",
   "Synchronizing keys": "Synchronisation des clés en cours",
   "Tagging passwords {{taggedCount}}/{{total}}": "Étiquetage des mots de passe {{taggedCount}}/{{total}}",
-  "The encryption key used to share metadata between users could not be verified and is considered untrusted.": "The encryption key used to share metadata between users could not be verified and is considered untrusted.",
+  "The encryption key used to share metadata between users could not be verified and is considered untrusted.": "La clé de chiffrement utilisée pour partager les métadonnées entre les utilisateurs n'a pas pu être vérifiée et est considérée comme n'étant pas fiable.",
   "The external service is unavailable": "Le service externe est indisponible",
   "The external service raised an error": "Le service externe a généré une erreur",
   "The folder cannot be moved inside itself.": "Le dossier ne peut pas être déplacé à l'intérieur de lui-même.",
@@ -92,7 +92,7 @@
   "The message should be decrypted.": "Le message doit être déchiffré.",
   "The message should be of type string.": "Le message doit être de type string.",
   "The message should contain at least one session key.": "Le message doit contenir au moins une clé de session.",
-  "The operation has been aborted to maintain security integrity.": "The operation has been aborted to maintain security integrity.",
+  "The operation has been aborted to maintain security integrity.": "L'opération a été interrompue afin de maintenir l'intégrité de la sécurité.",
   "The private key should be a valid openpgp key.": "La clé privée doit être une clé OpenPGP valide.",
   "The private key should be decrypted.": "La clé privée doit être déchiffrée.",
   "The private key should be encrypted.": "La clé privée doit être chiffrée.",
@@ -104,9 +104,9 @@
   "The server key has changed.": "La clé du serveur a été modifiée.",
   "The server key is expired.": "La clé du serveur est expirée.",
   "The service is unavailable": "Le service est indisponible",
-  "The verificationResult keyID should be a valid keyID Object.": "The verificationResult keyID should be a valid keyID Object.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult keyID should be a valid keyID Object.": "L'identifiant de la clé verificationResult devrait être un objet d'identifiant de clé valide.",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "La signature verificationResult devrait être une Promise<openpgp.Signature> vérifiée valide.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "The verificationResult verified should be a valid verified Promise<boolean>.",
   "This is not a valid passphrase": "Ce n'est pas une phrase de passe valide",
   "This key does not match any account.": "Cette clé ne correspond à aucun compte.",
   "This key is already used by another user.": "Cette clé est déjà utilisée par un autre utilisateur.",

package/src/all/locales/it-IT/common.json

@@ -105,8 +105,8 @@
   "The server key is expired.": "La chiave del server è scaduta.",
   "The service is unavailable": "Il servizio non è disponibile",
   "The verificationResult keyID should be a valid keyID Object.": "The verificationResult keyID should be a valid keyID Object.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "The verificationResult verified should be a valid verified Promise<boolean>.",
   "This is not a valid passphrase": "Questa non è una frase segreta valida",
   "This key does not match any account.": "Questa chiave non corrisponde a nessun account.",
   "This key is already used by another user.": "Questa chiave è già utilizzata da un altro utente.",

package/src/all/locales/ja-JP/common.json

@@ -105,8 +105,8 @@
   "The server key is expired.": "サーバーキーの有効期限が切れています。",
   "The service is unavailable": "サービスはご利用いただけません",
   "The verificationResult keyID should be a valid keyID Object.": "The verificationResult keyID should be a valid keyID Object.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "The verificationResult verified should be a valid verified Promise<boolean>.",
   "This is not a valid passphrase": "これは有効なパスフレーズではありません",
   "This key does not match any account.": "この鍵はどのアカウントとも一致しません。",
   "This key is already used by another user.": "この鍵はすでに他のユーザーが使用しています。",

package/src/all/locales/ko-KR/common.json

@@ -105,8 +105,8 @@
   "The server key is expired.": "서버키가 만료되었습니다.",
   "The service is unavailable": "서버키를 사용할 수 없습니다.",
   "The verificationResult keyID should be a valid keyID Object.": "validationResult keyID는 유효한 keyID 개체여야 합니다.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "verificationResult 서명은 유효하게 검증된 Promise<openpgp.Signature>이어야 합니다.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "verificationResult의 verified는 유효하게 검증된 Promise<boolean>이어야 합니다.",
   "This is not a valid passphrase": "유효하지 않은 비밀문구",
   "This key does not match any account.": "키가 맞는 계정이 없습니다.",
   "This key is already used by another user.": "키를 다른 사용자가 이미 사용 중입니다.",

package/src/all/locales/lt-LT/common.json

@@ -105,8 +105,8 @@
   "The server key is expired.": "Serverio raktas nebegalioja.",
   "The service is unavailable": "Paslauga yra nepasiekiama",
   "The verificationResult keyID should be a valid keyID Object.": "The verificationResult keyID should be a valid keyID Object.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "The verificationResult verified should be a valid verified Promise<boolean>.",
   "This is not a valid passphrase": "Tai nėra tinkama slaptafrazė",
   "This key does not match any account.": "Šis raktas neatitinka jokios paskyros.",
   "This key is already used by another user.": "Šį raktą jau naudoja kitas vartotojas.",

package/src/all/locales/nl-NL/common.json

@@ -105,8 +105,8 @@
   "The server key is expired.": "De serversleutel is verlopen.",
   "The service is unavailable": "Deze service is niet beschikbaar",
   "The verificationResult keyID should be a valid keyID Object.": "The verificationResult keyID should be a valid keyID Object.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "The verificationResult verified should be a valid verified Promise<boolean>.",
   "This is not a valid passphrase": "Dit is geen geldige wachtwoordzin",
   "This key does not match any account.": "Deze sleutel komt niet overeen met een account.",
   "This key is already used by another user.": "Deze sleutel wordt al gebruikt door een andere gebruiker.",

package/src/all/locales/pl-PL/common.json

@@ -73,7 +73,7 @@
   "Synchronizing keyring": "Synchronizacja kluczy",
   "Synchronizing keys": "Synchronizowanie kluczy",
   "Tagging passwords {{taggedCount}}/{{total}}": "Tagowanie haseł {{taggedCount}}/{{total}}",
-  "The encryption key used to share metadata between users could not be verified and is considered untrusted.": "The encryption key used to share metadata between users could not be verified and is considered untrusted.",
+  "The encryption key used to share metadata between users could not be verified and is considered untrusted.": "Nie udało się zweryfikować klucza szyfrowania do udostępniania metadanych pomiędzy użytkownikami i jest uważany za niezaufany.",
   "The external service is unavailable": "Usługa zewnętrzna jest niedostępna",
   "The external service raised an error": "Usługa zewnętrzna spowodowała błąd",
   "The folder cannot be moved inside itself.": "Folder nie może być przeniesiony do siebie samego.",
@@ -92,7 +92,7 @@
   "The message should be decrypted.": "Wiadomość powinna zostać odszyfrowana.",
   "The message should be of type string.": "Wiadomość powinna być ciągiem.",
   "The message should contain at least one session key.": "Wiadomość powinna zawierać przynajmniej jeden klucz sesji.",
-  "The operation has been aborted to maintain security integrity.": "The operation has been aborted to maintain security integrity.",
+  "The operation has been aborted to maintain security integrity.": "To działanie zostało przerwane, aby utrzymać integralność zabezpieczeń.",
   "The private key should be a valid openpgp key.": "Klucz prywatny powinien być prawidłowym kluczem openpgp.",
   "The private key should be decrypted.": "Klucz prywatny powinien być odszyfrowany.",
   "The private key should be encrypted.": "Klucz prywatny powinien być zaszyfrowany.",
@@ -104,9 +104,9 @@
   "The server key has changed.": "Klucz serwera został zmieniony.",
   "The server key is expired.": "Klucz serwera wygasł.",
   "The service is unavailable": "Usługa jest niedostępna",
-  "The verificationResult keyID should be a valid keyID Object.": "The verificationResult keyID should be a valid keyID Object.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult keyID should be a valid keyID Object.": "KeyID dla verificationResult powinien być prawidłowym obiektem keyID.",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "The verificationResult verified should be a valid verified Promise<boolean>.",
   "This is not a valid passphrase": "To nie jest prawidłowe hasło dostępu",
   "This key does not match any account.": "Ten klucz nie pasuje do żadnego konta.",
   "This key is already used by another user.": "Ten klucz jest już używany przez innego użytkownika.",

package/src/all/locales/pt-BR/common.json

@@ -105,8 +105,8 @@
   "The server key is expired.": "A chave do servidor expirou.",
   "The service is unavailable": "O serviço está indisponível",
   "The verificationResult keyID should be a valid keyID Object.": "The verificationResult keyID should be a valid keyID Object.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "The verificationResult verified should be a valid verified Promise<boolean>.",
   "This is not a valid passphrase": "Esta não é uma senha válida",
   "This key does not match any account.": "Esta chave não corresponde a nenhuma conta.",
   "This key is already used by another user.": "Essa chave já está sendo usada por outro usuário.",

package/src/all/locales/ro-RO/common.json

@@ -105,8 +105,8 @@
   "The server key is expired.": "Cheia serverului a expirat.",
   "The service is unavailable": "Serviciul nu este disponibil",
   "The verificationResult keyID should be a valid keyID Object.": "The verificationResult keyID should be a valid keyID Object.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "The verificationResult verified should be a valid verified Promise<boolean>.",
   "This is not a valid passphrase": "Aceasta nu este o parolă validă",
   "This key does not match any account.": "Această cheie nu se potrivește cu niciun cont.",
   "This key is already used by another user.": "Această cheie este deja folosită de un alt utilizator.",

package/src/all/locales/ru-RU/common.json

@@ -105,8 +105,8 @@
   "The server key is expired.": "Срок действия ключа сервера истёк.",
   "The service is unavailable": "Сервис недоступен",
   "The verificationResult keyID should be a valid keyID Object.": "The verificationResult keyID should be a valid keyID Object.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "The verificationResult verified should be a valid verified Promise<boolean>.",
   "This is not a valid passphrase": "Это недействительная парольная фраза",
   "This key does not match any account.": "Этот ключ не соответствует ни одной учетной записи.",
   "This key is already used by another user.": "Этот ключ уже используется другим пользователем.",