passbolt-browser-extension 5.2.0 → 5.3.2

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/background_page/service/user/deleteUserService.js

@@ -0,0 +1,97 @@
+/**
+ * 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 UserService from "../api/user/userService";
+import {assertType, assertUuid} from "../../utils/assertions";
+import DeleteDryRunError from "../../error/deleteDryRunError";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+import UserDeleteTransferEntity from "../../model/entity/user/transfer/userDeleteTransferEntity";
+import UserLocalStorage from "../local_storage/userLocalStorage";
+
+/**
+ * The service aims to delete user from the API.
+ */
+export default class DeleteUserService {
+  /**
+   *
+   * @param {AccountEntity} account The user account
+   * @param {ApiClientOptions} apiClientOptions The api client options
+   */
+  constructor(account, apiClientOptions) {
+    this.account = account;
+    this.userServiceApi = new UserService(apiClientOptions);
+  }
+
+  /**
+   * Delete dry run a user.
+   * Check if a user can be deleted.
+   *
+   * A user can not be deleted if:
+   * - they are the only owner of a shared resource
+   * - they are the only group manager of a group that owns a shared resource
+   * In such case ownership transfer is required.
+   *
+   * @param {string} userId The user id.
+   * @returns {Promise<void>}
+   * @throws {DeleteDryRunError} if the data should be transferred to someone.
+   * @throws {Error} if the data returned by the API is not a PassboltApiFetchError with error code 400 and groups, resources or folders to transfer.
+   */
+  async deleteDryRun(userId) {
+    assertUuid(userId, "The parameter \"userId\" should be a UUID");
+    try {
+      await this.userServiceApi.delete(userId, {}, true);
+    } catch (error) {
+      await this.handleError(error);
+    }
+  }
+
+  /**
+   * Delete a user and transfer ownership if needed.
+   * @param {string} userId The user id.
+   * @param {UserDeleteTransferEntity} [transfer] optional ownership transfer information if needed.
+   * @returns {Promise<void>}
+   * @throws {DeleteDryRunError} if some permissions must be transferred.
+   * @throws {Error} if the data returned by the API is not a PassboltApiFetchError with error code 400 and groups, resources or folders to transfer.
+   */
+  async delete(userId, transfer) {
+    assertUuid(userId, "The parameter \"userId\" should be a UUID");
+    if (transfer !== null) {
+      assertType(transfer, UserDeleteTransferEntity, 'The `transfer` parameter should be a UserDeleteTransferEntity.');
+    }
+    try {
+      const deleteData = transfer ? transfer.toDto() : {};
+      await this.userServiceApi.delete(userId, deleteData);
+    } catch (error) {
+      await this.handleError(error);
+    }
+    // Update local storage
+    await UserLocalStorage.delete(userId);
+  }
+
+  /**
+   * @private
+   * @param {object} error The error
+   * @throws {DeleteDryRunError} if some permissions must be transferred.
+   * @throws {Error} if the data returned by the API is not a PassboltApiFetchError with error code 400 and groups, resources or folders to transfer.
+   */
+  async handleError(error) {
+    if (error instanceof PassboltApiFetchError && error.data.code === 400 && error.data.body.errors) {
+      /*
+       * recast generic 400 error into a delete dry run error
+       * allowing validation of the returned entities and reuse down the line to transfer permissions
+       */
+      throw new DeleteDryRunError(error.message, error.data.body.errors);
+    }
+    throw error;
+  }
+}

package/src/all/background_page/service/user/deleteUserService.test.js

@@ -0,0 +1,178 @@
+/**
+ * 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 AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import DeleteUserService from "./deleteUserService";
+import {v4 as uuidv4} from "uuid";
+import DeleteDryRunError from "../../error/deleteDryRunError";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
+import UserDeleteTransferEntity from "../../model/entity/user/transfer/userDeleteTransferEntity";
+import {defaultUserDeleteTransferDto} from "passbolt-styleguide/src/shared/models/entity/user/userDeleteTransferEntity.test.data";
+import {defaultResourceDto} from "passbolt-styleguide/src/shared/models/entity/resource/resourceEntity.test.data";
+import UserLocalStorage from "../local_storage/userLocalStorage";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("DeleteUserService", () => {
+  let deleteUserService, apiClientOptions;
+  const account = new AccountEntity(defaultAccountDto());
+
+  beforeEach(async() => {
+    apiClientOptions = defaultApiClientOptions();
+    deleteUserService = new DeleteUserService(account, apiClientOptions);
+  });
+
+  describe("::deleteDryRun", () => {
+    it("Do not need to transfer ownership.", async() => {
+      expect.assertions(1);
+
+      const usersId = uuidv4();
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => {});
+
+      await deleteUserService.deleteDryRun(usersId);
+
+      expect(deleteUserService.userServiceApi.delete).toHaveBeenCalledWith(usersId, {}, true);
+    });
+
+    it("Need to transfer ownership.", async() => {
+      expect.assertions(1);
+
+      const usersId = uuidv4();
+      const resourceDto = defaultResourceDto();
+      const error = {
+        code: 400,
+        body: {
+          errors: {
+            resources: {
+              sole_owner: [resourceDto]
+            }
+          }
+        }
+      };
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => { throw new PassboltApiFetchError("Error", error); });
+
+      try {
+        await deleteUserService.deleteDryRun(usersId);
+      } catch (error) {
+        expect(error).toBeInstanceOf(DeleteDryRunError);
+      }
+    });
+
+    it("throw any error not handled.", async() => {
+      expect.assertions(1);
+
+      const usersId = uuidv4();
+      const error = {
+        code: 404,
+      };
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => { throw new PassboltApiFetchError("Error", error); });
+
+      try {
+        await deleteUserService.deleteDryRun(usersId);
+      } catch (error) {
+        expect(error).toBeInstanceOf(PassboltApiFetchError);
+      }
+    });
+
+    it("throws if user id is not an uuid.", async() => {
+      expect.assertions(1);
+
+      const promise = deleteUserService.deleteDryRun({});
+
+      expect(promise).rejects.toThrow(Error("The parameter \"userId\" should be a UUID"));
+    });
+  });
+
+  describe("::delete", () => {
+    it("delete a user with no transfer.", async() => {
+      expect.assertions(2);
+
+      const usersId = uuidv4();
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => {});
+      jest.spyOn(UserLocalStorage, "delete").mockImplementationOnce(() => {});
+
+      await deleteUserService.delete(usersId, null);
+
+      expect(deleteUserService.userServiceApi.delete).toHaveBeenCalledWith(usersId, {});
+      expect(UserLocalStorage.delete).toHaveBeenCalledWith(usersId);
+    });
+
+    it("delete a user with transfer.", async() => {
+      expect.assertions(2);
+
+      const usersId = uuidv4();
+      const dto = defaultUserDeleteTransferDto();
+      const userDeleteTransfer = new UserDeleteTransferEntity(dto);
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => {});
+      jest.spyOn(UserLocalStorage, "delete").mockImplementationOnce(() => {});
+
+      await deleteUserService.delete(usersId, userDeleteTransfer);
+
+      expect(deleteUserService.userServiceApi.delete).toHaveBeenCalledWith(usersId, dto);
+      expect(UserLocalStorage.delete).toHaveBeenCalledWith(usersId);
+    });
+
+    it("delete a user with an error and need to transfer ownership.", async() => {
+      expect.assertions(1);
+
+      const usersId = uuidv4();
+      const resourceDto = defaultResourceDto();
+      const error = {
+        code: 400,
+        body: {
+          errors: {
+            resources: {
+              sole_owner: [resourceDto]
+            }
+          }
+        }
+      };
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => { throw new PassboltApiFetchError("Error", error); });
+
+      try {
+        await deleteUserService.delete(usersId, null);
+      } catch (error) {
+        expect(error).toBeInstanceOf(DeleteDryRunError);
+      }
+    });
+
+    it("delete a user with an unexpected error.", async() => {
+      expect.assertions(1);
+
+      const usersId = uuidv4();
+      const error = {
+        code: 404,
+      };
+      jest.spyOn(deleteUserService.userServiceApi, "delete").mockImplementationOnce(() => { throw new PassboltApiFetchError("Error", error); });
+
+      try {
+        await deleteUserService.delete(usersId, null);
+      } catch (error) {
+        expect(error).toBeInstanceOf(PassboltApiFetchError);
+      }
+    });
+
+    it("throws if user id is not an uuid.", async() => {
+      expect.assertions(1);
+
+      const promise = deleteUserService.delete({});
+
+      expect(promise).rejects.toThrow(Error("The parameter \"userId\" should be a UUID"));
+    });
+  });
+});

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.",