passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/model/gpgauth.js

@@ -11,25 +11,25 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         2.9.0
  */
-const Uuid = require('../utils/uuid');
-const __ = require('../sdk/l10n').get;
-
-const {AuthService} = require('../service/auth');
-const {User} = require('./user');
-const {Keyring} = require('./keyring');
-const {Crypto} = require('./crypto');
-const {GpgAuthToken} = require('./gpgAuthToken');
-const {GpgAuthHeader} = require('./gpgAuthHeader');
-const {MfaAuthenticationRequiredError} = require('../error/mfaAuthenticationRequiredError');
-const {Request} = require('./request');
-const {SiteSettings} = require('./siteSettings');
-const {AuthStatusLocalStorage} = require('../service/local_storage/authStatusLocalStorage');
+import {OpenpgpAssertion} from "../utils/openpgp/openpgpAssertions";
+import Keyring from "./keyring";
+import EncryptMessageService from "../service/crypto/encryptMessageService";
+import DecryptMessageService from "../service/crypto/decryptMessageService";
+import CompareGpgKeyService from "../service/crypto/compareGpgKeyService";
+import User from "./user";
+import AuthStatusLocalStorage from "../service/local_storage/authStatusLocalStorage";
+import {Uuid} from "../utils/uuid";
+import GpgAuthToken from "./gpgAuthToken";
+import MfaAuthenticationRequiredError from "../error/mfaAuthenticationRequiredError";
+import GpgAuthHeader from "./gpgAuthHeader";
+import GetGpgKeyInfoService from "../service/crypto/getGpgKeyInfoService";
+import AuthService from "../service/auth";
+import Request from "./request";
+import urldecode from 'locutus/php/url/urldecode';
+import stripslashes from 'locutus/php/strings/stripslashes';
 
 const URL_VERIFY = '/auth/verify.json?api-version=v2';
 const URL_LOGIN = '/auth/login.json?api-version=v2';
-const URL_LOGOUT = '/auth/logout.json?api-version=v2';
-const CHECK_IS_AUTHENTICATED_INTERVAL_PERIOD = 60000;
-const MAX_IS_AUTHENTICATED_INTERVAL_PERIOD = 2147483647;
 
 /**
  * GPGAuth authentication
@@ -41,10 +41,7 @@ class GpgAuth {
    */
   constructor(keyring) {
     this.keyring = keyring ? keyring : new Keyring();
-    this.crypto = new Crypto(this.keyring);
 
-    // Check the authentication status interval.
-    this.checkIsAuthenticatedTimeout = null;
     // Latest stored auth user status.
     this.authStatus = null;
   }
@@ -63,24 +60,25 @@ class GpgAuth {
    * Verify the server identify
    *
    * @param {string} [serverUrl] optional
-   * @param {string} [armoredServerKey] optional
+   * @param {string} [serverArmoredKey] optional
    * @param {string} [userFingerprint] optional
    * @throws {Error} if domain is undefined in settings and serverUrl is not provided
    * @throws {Error} if verification procedure fails
    * @returns {Promise<void>}
    */
-  async verify(serverUrl, armoredServerKey, userFingerprint) {
-    let domain = serverUrl || this.getDomain();
-    let serverKey = armoredServerKey || this.keyring.findPublic(Uuid.get(domain)).key;
-    let fingerprint = userFingerprint || this.keyring.findPrivate().fingerprint;
+  async verify(serverUrl, serverArmoredKey, userFingerprint) {
+    const domain = serverUrl || this.getDomain();
+    serverArmoredKey = serverArmoredKey || this.keyring.findPublic(Uuid.get(domain)).armoredKey;
+    const fingerprint = userFingerprint || this.keyring.findPrivate().fingerprint;
 
     // Encrypt a random token
     let encrypted, originalToken;
     try {
       originalToken = new GpgAuthToken();
-      encrypted = await this.crypto.encrypt(originalToken.token, serverKey)
+      const serverKey = await OpenpgpAssertion.readKeyOrFail(serverArmoredKey);
+      encrypted = await EncryptMessageService.encrypt(originalToken.token, serverKey);
     } catch (error) {
-      throw new Error(__('Unable to encrypt the verify token.') + ' ' + error.message);
+      throw new Error(`Unable to encrypt the verify token. ${error.message}`);
     }
 
     // Prepare the request data
@@ -89,7 +87,7 @@ class GpgAuth {
     data.append('data[gpg_auth][server_verify_token]', encrypted);
 
     // Send the data
-    let fetchOptions = {
+    const fetchOptions = {
       method: 'POST',
       credentials: 'include',
       body: data
@@ -99,11 +97,11 @@ class GpgAuth {
 
     // If the server responded with an error build a relevant message
     if (!response.ok) {
-      let json = await response.json();
+      const json = await response.json();
       if (typeof json.header !== 'undefined') {
         throw new Error(json.header.message);
       } else {
-        const msg = __('Server request failed without providing additional information.') + ' (' + response.status + ')';
+        const msg = `Server request failed (${response.status}) without providing additional information.`;
         throw new Error(msg);
       }
     }
@@ -112,35 +110,37 @@ class GpgAuth {
     const auth = new GpgAuthHeader(response.headers, 'verify');
     const verifyToken = new GpgAuthToken(auth.headers['x-gpgauth-verify-response']);
     if (verifyToken.token !== originalToken.token) {
-      throw new Error(__('The server was unable to prove it can use the advertised OpenPGP key.'));
+      throw new Error('The server was unable to prove it can use the advertised OpenPGP key.');
     }
   }
 
   /**
    * Check if the server key has changed
-   * @return {boolean} true if key has changed
+   * @return {Promise<boolean>} true if key has changed
    */
   async serverKeyChanged() {
-    const remoteKey = await this.getServerKey();
-    const localKey = await this.getServerKeyFromKeyring();
-    return remoteKey.keydata.trim() !== localKey.trim();
-  };
+    const remoteServerArmoredKey = (await this.getServerKey()).keydata;
+    const remoteServerKey = await OpenpgpAssertion.readKeyOrFail(remoteServerArmoredKey);
+    const serverLocalArmoredKey = this.getServerKeyFromKeyring().armoredKey;
+    const serverLocalKey = await OpenpgpAssertion.readKeyOrFail(serverLocalArmoredKey);
+    return !await CompareGpgKeyService.areKeysTheSame(remoteServerKey, serverLocalKey);
+  }
 
   /**
    * Get Server key from keyring
-   * @returns {Promise<*>}
+   * @returns {ExternalGpgKeyEntity}
    */
-  async getServerKeyFromKeyring() {
-    return await this.keyring.findPublic(Uuid.get(this.getDomain())).key;
+  getServerKeyFromKeyring() {
+    return this.keyring.findPublic(Uuid.get(this.getDomain()));
   }
 
   /**
    * isServerKeyExpired
-   * @returns {Promise<boolean>}
+   * @returns {boolean}
    */
-  async isServerKeyExpired() {
-    const key = await this.getServerKeyFromKeyring();
-    return await this.keyring.keyIsExpired(key);
+  isServerKeyExpired() {
+    const key = this.getServerKeyFromKeyring();
+    return key.isExpired;
   }
 
   /**
@@ -149,17 +149,17 @@ class GpgAuth {
    * @param {string} [serverUrl] optional domain where to get the key.
    * if domain is not provided, then look in the settings.
    *
-   * @returns {Promise.<string>}
+   * @returns {Promise.<object>}
    */
   async getServerKey(serverUrl) {
-    let domain = serverUrl || this.getDomain();
+    const domain = serverUrl || this.getDomain();
     const response = await fetch(domain + URL_VERIFY, {
       method: 'GET',
       credentials: 'include'
     });
 
     if (!response.ok) {
-      const msg = __('There was a problem when trying to communicate with the server') + ` (Code: ${response.status})`;
+      const msg = 'There was a problem when trying to communicate with the server' + ` (Code: ${response.status})`;
       throw new Error(msg);
     }
 
@@ -170,25 +170,26 @@ class GpgAuth {
   /**
    * GPGAuth Login - handle stage1, stage2 and complete
    *
-   * @param privateKey {openpgp.key.Key} The decrypted private key to use to decrypt the message.
-   * @returns {Promise.<string>} referrer url
+   * @param {openpgp.PrivateKey} privateKey The decrypted private key to use to decrypt the message.
+   * @returns {Promise<void>}
    */
   async login(privateKey) {
-    const userAuthToken = await this.stage1(privateKey);
-    await this.stage2(userAuthToken, privateKey);
+    const privateKeyInfo = await GetGpgKeyInfoService.getKeyInfo(privateKey);
+    const userAuthToken = await this.stage1(privateKeyInfo);
+    await this.stage2(userAuthToken, privateKeyInfo);
   }
 
   /**
    * GPGAuth stage1 - get and decrypt a verification given by the server
    *
-   * @param privateKey {openpgp.key.Key} The decrypted private key to use to decrypt the message.
+   * @param {ExternalGpgKeyEntity} privateKey The decrypted private key to use to decrypt the message.
    * @returns {Promise.<string>} token
    */
   async stage1(privateKey) {
     // Prepare request data
     const url = this.getDomain() + URL_LOGIN;
     const body = new FormData();
-    body.append('data[gpg_auth][keyid]', privateKey.primaryKey.getFingerprint());
+    body.append('data[gpg_auth][keyid]', privateKey.fingerprint);
     const fetchOptions = {
       method: 'POST',
       credentials: 'include',
@@ -207,10 +208,12 @@ class GpgAuth {
 
     // Try to decrypt the User Auth Token
     const encryptedUserAuthToken = stripslashes(urldecode(auth.headers['x-gpgauth-user-auth-token']));
-    let userAuthToken = await this.crypto.decryptWithKey(encryptedUserAuthToken, privateKey);
+    const decryptionKey = await OpenpgpAssertion.readKeyOrFail(privateKey.armoredKey);
+    const encryptedMessage = await OpenpgpAssertion.readMessageOrFail(encryptedUserAuthToken);
+    const userAuthToken = await DecryptMessageService.decrypt(encryptedMessage, decryptionKey);
 
     // Validate the User Auth Token
-    let authToken = new GpgAuthToken(userAuthToken);
+    const authToken = new GpgAuthToken(userAuthToken);
     return authToken.token;
   }
 
@@ -218,15 +221,14 @@ class GpgAuth {
    * Stage 2. send back the token to the server to get auth cookie
    *
    * @param userAuthToken {string} The user authentication token
-   * @param {openpgp.key.Key} privateKey decrypted private key
-   * @returns {Promise.<string>} url to redirect the user to
+   * @param {ExternalGpgKeyEntity} privateKey decrypted private key
+   * @returns {Promise<void>}
    */
   async stage2(userAuthToken, privateKey) {
     // Prepare request data
     const url = this.getDomain() + URL_LOGIN;
-    const domain = User.getInstance().settings.getDomain();
     const data = new FormData();
-    data.append('data[gpg_auth][keyid]', privateKey.primaryKey.getFingerprint());
+    data.append('data[gpg_auth][keyid]', privateKey.fingerprint);
     data.append('data[gpg_auth][user_token_result]', userAuthToken);
 
     // Send it over
@@ -244,8 +246,7 @@ class GpgAuth {
     }
 
     // Check the headers and return the redirection url
-    const auth = new GpgAuthHeader(response.headers, 'complete');
-    return domain + auth.headers['x-gpgauth-refer'];
+    new GpgAuthHeader(response.headers, 'complete');
   }
 
   /**
@@ -255,7 +256,7 @@ class GpgAuth {
    * @returns {Promise.<error>} throw a relevant exception
    */
   async onResponseError(response) {
-    const error_msg = __('There was a server error. No additional information provided') + `(${response.status})`;
+    const error_msg = 'There was a server error. No additional information provided' + `(${response.status}`;
     let json;
     try {
       json = await response.json();
@@ -306,8 +307,10 @@ class GpgAuth {
       requestApi: true
     }, options);
 
-    // No request to API required, return the latest stored information.
-    // Check in the local storage if any
+    /*
+     * No request to API required, return the latest stored information.
+     * Check in the local storage if any
+     */
     if (!options.requestApi) {
       try {
         const storedStatus = await AuthStatusLocalStorage.get();
@@ -315,9 +318,11 @@ class GpgAuth {
           this.authStatus = storedStatus;
           return this.authStatus;
         }
-      } catch(error) {
-        // Nothing found, check with the API
-        // continue...
+      } catch (error) {
+        /*
+         * Nothing found, check with the API
+         * continue...
+         */
       }
     }
 
@@ -333,76 +338,10 @@ class GpgAuth {
       }
     }
 
-    this.authStatus = {isAuthenticated, isMfaRequired};
+    this.authStatus = {isAuthenticated: isAuthenticated, isMfaRequired: isMfaRequired};
     await AuthStatusLocalStorage.set(isAuthenticated, isMfaRequired);
     return this.authStatus;
-  };
-
-  /**
-   * Start an invertval to check if the user is authenticated.
-   * - In the case the user is logged out, trigger a passbolt.auth.after-logout event.
-   *
-   * @return {void}
-   */
-  async startCheckAuthStatusLoop() {
-    const timeoutPeriod = await this.getCheckAuthStatusTimeoutPeriod();
-
-    if (this.checkAuthStatusTimeout) {
-      clearTimeout(this.checkAuthStatusTimeout);
-    }
-
-    this.checkAuthStatusTimeout = setTimeout(async () => {
-      if (!await this.isAuthenticated()) {
-        window.dispatchEvent(new Event('passbolt.auth.after-logout'));
-      } else {
-        this.startCheckAuthStatusLoop();
-      }
-    }, timeoutPeriod);
   }
-
-  /**
-   * Get the interval period the is authenticated check should be performed.
-   *
-   * The interval varies regarding the version of the API.
-   * - With API >= v2.11.0 the check can be performed every CHECK_IS_AUTHENTICATED_INTERVAL_PERIOD seconds.
-   *   The entry point introduced with v2.11.0 (/auth/is-authenticated) does not extend the user session.
-   * - With API < v2.11.0 the check cannot be performed every CHECK_IS_AUTHENTICATED_INTERVAL_PERIOD seconds.
-   *   The entry point /auth/checksession is extending the session, and therefor the check should be done
-   *   as per the session timeout.
-   *
-   * @return {int}
-   */
-  async getCheckAuthStatusTimeoutPeriod() {
-    let timeoutPeriod = CHECK_IS_AUTHENTICATED_INTERVAL_PERIOD;
-
-    // The entry point available before v2.11.0 extends the session expiry period.
-    // Define the check interval based on the server session timeout.
-    if (AuthService.useLegacyIsAuthenticatedEntryPoint === true) {
-      const domain = User.getInstance().settings.getDomain();
-      const siteSettings = new SiteSettings(domain);
-      const settings = await siteSettings.get();
-      // By default a default php session expires after 24 min.
-      let sessionTimeout = 24;
-      // Check if the session timeout is provided in the settings.
-      // If not provided it means the user is not logged in or the MFA is required.
-      if (settings && settings.app && settings.app.session_timeout) {
-        sessionTimeout = settings.app.session_timeout;
-      }
-      // Convert the timeout in millisecond and add 1 second to ensure the session is well expired
-      // when the request is made.
-      timeoutPeriod = ((sessionTimeout * 60) + 1) * 1000;
-
-      // Fix https://github.com/passbolt/passbolt_browser_extension/issues/84
-      if (timeoutPeriod > MAX_IS_AUTHENTICATED_INTERVAL_PERIOD) {
-        timeoutPeriod = MAX_IS_AUTHENTICATED_INTERVAL_PERIOD;
-      }
-      if (timeoutPeriod < CHECK_IS_AUTHENTICATED_INTERVAL_PERIOD) {
-        timeoutPeriod = CHECK_IS_AUTHENTICATED_INTERVAL_PERIOD;
-      }
-    }
-
-    return timeoutPeriod;
-  };
 }
 // Exports the Authentication model object.
-exports.GpgAuth = GpgAuth;
+export default GpgAuth;

package/src/all/background_page/model/group/groupModel.js

@@ -11,16 +11,14 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         3.0.0
  */
-const {GroupEntity} = require('../entity/group/groupEntity');
-const {GroupsCollection} = require('../entity/group/groupsCollection');
-const {GroupDeleteTransferEntity} = require('../entity/group/transfer/groupDeleteTransfer');
-const {GroupUpdateDryRunResultEntity} = require("../entity/group/update/groupUpdateDryRunResultEntity");
-
-const {GroupService} = require('../../service/api/group/groupService');
-const {GroupLocalStorage} = require('../../service/local_storage/groupLocalStorage');
-
-const {PassboltApiFetchError} = require('../../error/passboltApiFetchError');
-const {DeleteDryRunError} = require('../../error/deleteDryRunError');
+import GroupLocalStorage from "../../service/local_storage/groupLocalStorage";
+import GroupsCollection from "../entity/group/groupsCollection";
+import DeleteDryRunError from "../../error/deleteDryRunError";
+import GroupEntity from "../entity/group/groupEntity";
+import GroupService from "../../service/api/group/groupService";
+import GroupUpdateDryRunResultEntity from "../entity/group/update/groupUpdateDryRunResultEntity";
+import GroupDeleteTransferEntity from "../entity/group/transfer/groupDeleteTransfer";
+import PassboltApiFetchError from "passbolt-styleguide/src/shared/lib/Error/PassboltApiFetchError";
 
 class GroupModel {
   /**
@@ -85,7 +83,7 @@ class GroupModel {
     if (preSanitize) {
       groupsDto = GroupsCollection.sanitizeDto(groupsDto);
     }
-    return new GroupsCollection(groupsDto);
+    return new GroupsCollection(groupsDto, {clone: false});
   }
 
   /**
@@ -128,7 +126,7 @@ class GroupModel {
     const data = groupUpdateEntity.toDto();
     let groupDto = await this.groupService.update(groupUpdateEntity.id, data);
     if (preSanitize) {
-      groupDto = GroupEntity.sanitizeDto(groupDto)
+      groupDto = GroupEntity.sanitizeDto(groupDto);
     }
     const updatedGroupEntity = new GroupEntity(groupDto);
     await GroupLocalStorage.updateGroup(updatedGroupEntity);
@@ -193,4 +191,4 @@ class GroupModel {
   }
 }
 
-exports.GroupModel = GroupModel;
+export default GroupModel;

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

@@ -26,9 +26,11 @@ class AbstractCsvRowParser {
    * @param {ResourceTypesCollection} resourceTypesCollection The available resource types
    * @returns {ExternalResourceEntity}
    */
+  /* eslint-disable no-unused-vars */
   static parse(data, resourceTypesCollection) {
     throw new Error("parse should be overridden by the inherited csv row parser.");
   }
+  /* eslint-enable no-unused-vars */
 
   /**
    * Check that the parser can parse the format represented by the given fields.
@@ -36,7 +38,7 @@ class AbstractCsvRowParser {
    * @return {int} The matching score. the number of fields the parser match. the greater the better.
    */
   static canParse(csvFields) {
-    let score = 0;
+    const score = 0;
     const requiredFields = ["name", "secret_clear"];
     const csvHasField = fieldName => csvFields.some(csvFieldName => this.mapping[fieldName] === csvFieldName);
 
@@ -56,4 +58,4 @@ class AbstractCsvRowParser {
   }
 }
 
-exports.AbstractCsvRowParser = AbstractCsvRowParser;
+export default AbstractCsvRowParser;

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

@@ -10,8 +10,8 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {AbstractCsvRowParser} = require("./abstractCsvRowParser");
-const {ExternalResourceEntity} = require("../../../entity/resource/external/externalResourceEntity");
+import ExternalResourceEntity from "../../../entity/resource/external/externalResourceEntity";
+import AbstractCsvRowParser from "./abstractCsvRowParser";
 
 class Csv1PasswordRowParser extends AbstractCsvRowParser {
   /**
@@ -22,11 +22,11 @@ class Csv1PasswordRowParser extends AbstractCsvRowParser {
     return {
       "name": "Title",
       "username": "Username",
-      "uri": "URL",
+      "uri": "Url",
       "secret_clear": "Password",
       "description": "Notes",
       "folder_parent_path": "Type"
-    }
+    };
   }
 
   /**
@@ -41,7 +41,7 @@ class Csv1PasswordRowParser extends AbstractCsvRowParser {
     if (resourceType) {
       externalResourceDto.resource_type_id = resourceType.id;
     }
-    for (let propertyName in this.mapping) {
+    for (const propertyName in this.mapping) {
       if (data[this.mapping[propertyName]]) {
         externalResourceDto[propertyName] = data[this.mapping[propertyName]];
       }
@@ -62,4 +62,4 @@ class Csv1PasswordRowParser extends AbstractCsvRowParser {
   }
 }
 
-exports.Csv1PasswordRowParser = Csv1PasswordRowParser;
+export default Csv1PasswordRowParser;

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

@@ -10,15 +10,8 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-import Validator from "validator";
-import {Csv1PasswordRowParser} from "./csv1PasswordRowParser";
-import {ExternalResourceEntity} from "../../../entity/resource/external/externalResourceEntity";
-
-// Reset the modules before each test.
-beforeEach(() => {
-  window.Validator = Validator;
-  jest.resetModules();
-});
+import Csv1PasswordRowParser from "./csv1PasswordRowParser";
+import ExternalResourceEntity from "../../../entity/resource/external/externalResourceEntity";
 
 describe("Csv1PasswordRowParser", () => {
   it("can parse 1password csv", () => {
@@ -26,13 +19,13 @@ describe("Csv1PasswordRowParser", () => {
     let fields = ["Title", "Password"];
     expect(Csv1PasswordRowParser.canParse(fields)).toEqual(2);
     // all fields
-    fields = ["Title", "Username", "URL", "Password", "Notes", "Type"];
+    fields = ["Title", "Username", "Url", "Password", "Notes", "Type"];
     expect(Csv1PasswordRowParser.canParse(fields)).toEqual(6);
     // Missing one required field
-    fields = ["Title", "Username", "URL", "Notes", "Type"];
+    fields = ["Title", "Username", "Url", "Notes", "Type"];
     expect(Csv1PasswordRowParser.canParse(fields)).toEqual(0);
     // Duplicate field
-    fields = ["Title", "Username", "URL", "Password", "Notes", "Type", "Type"];
+    fields = ["Title", "Username", "Url", "Password", "Notes", "Type", "Type"];
     expect(Csv1PasswordRowParser.canParse(fields)).toEqual(6);
     // additional fields not supported
     fields = ["Title", "Password", "Unsupported field"];
@@ -57,7 +50,7 @@ describe("Csv1PasswordRowParser", () => {
     const data = {
       "Title": "Password 1",
       "Username": "Username 1",
-      "URL": "https://url1.com",
+      "Url": "https://url1.com",
       "Password": "Secret 1",
       "Notes": "Description 1",
       "Type": "Folder 1"
@@ -66,7 +59,7 @@ describe("Csv1PasswordRowParser", () => {
     expect(externalResourceEntity).toBeInstanceOf(ExternalResourceEntity);
     expect(externalResourceEntity.name).toEqual(data.Title);
     expect(externalResourceEntity.username).toEqual(data.Username);
-    expect(externalResourceEntity.uri).toEqual(data.URL);
+    expect(externalResourceEntity.uri).toEqual(data.Url);
     expect(externalResourceEntity.secretClear).toEqual(data.Password);
     expect(externalResourceEntity.description).toEqual(data.Notes);
     expect(externalResourceEntity.folderParentPath).toEqual(data.Type);

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

@@ -0,0 +1,65 @@
+/**
+ * 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)
+ */
+import ExternalResourceEntity from "../../../entity/resource/external/externalResourceEntity";
+import AbstractCsvRowParser from "./abstractCsvRowParser";
+
+class CsvBitWardenRowParser extends AbstractCsvRowParser {
+  /**
+   * Get the row parser properties mapping.
+   * @returns {object}
+   */
+  static get mapping() {
+    return {
+      "name": "name",
+      "username": "login_username",
+      "uri": "login_uri",
+      "secret_clear": "login_password",
+      "description": "notes",
+      "folder_parent_path": "folder"
+    };
+  }
+
+  /**
+   * Parse a csv row
+   * @param {object} data the csv row data
+   * @param {ResourceTypesCollection?} resourceTypesCollection (Optional) The available resource types
+   * @returns {ExternalResourceEntity}
+   */
+  static parse(data, resourceTypesCollection) {
+    const externalResourceDto = {};
+    const resourceType = this.parseResourceType(data, resourceTypesCollection);
+    if (resourceType) {
+      externalResourceDto.resource_type_id = resourceType.id;
+    }
+    for (const propertyName in this.mapping) {
+      if (data[this.mapping[propertyName]]) {
+        externalResourceDto[propertyName] = data[this.mapping[propertyName]];
+      }
+    }
+    return new ExternalResourceEntity(externalResourceDto);
+  }
+
+  /**
+   * Parse the resource type id
+   * @param {object} data the csv row data
+   * @param {ResourceTypesCollection} resourceTypesCollection The available resource types
+   * @returns {ResourceTypeEntity}
+   */
+  static parseResourceType(data, resourceTypesCollection) {
+    if (resourceTypesCollection) {
+      return resourceTypesCollection.getFirst('slug', 'password-and-description');
+    }
+  }
+}
+
+export default CsvBitWardenRowParser;