js: implement import/delete Key, some fixes

--

* Keyring.js
   - implemented importKey: importing one or more armored public key
     blocks.
   - implemented deleteKey: deleting a public Key from gpg.

* Key.js renamed property Key.armor to Key.armored

* Helpers.js: toKeyIDArray does not complain anymore if there are no
  keys. Not having Keys in e.g. signing keys in encrypt is legitimate
  and common, the complaints were getting spammy

* Errors.js: gpgme_errors now always pass an optional additional
  message, for easier debugging in minified code

* Connection.js: Fix in gpgme-json responses containing objects

* eslintrc.json: Start using eslint. A cleanup to conform to it is not
  done yet

* Added further tests for the new functionality

1 files changed, 118 insertions, 26 deletions

diff --git a/lang/js/src/Keyring.js b/lang/js/src/Keyring.js
index 9081cbe9..c5e613ec 100644
--- a/lang/js/src/Keyring.js
+++ b/lang/js/src/Keyring.js
@@ -18,9 +18,9 @@
  * SPDX-License-Identifier: LGPL-2.1+
  */
 
-import {createMessage} from './Message'
-import {GPGME_Key, createKey} from './Key'
-import { isFingerprint, toKeyIdArray } from './Helpers';
+import {createMessage} from './Message';
+import {createKey} from './Key';
+import { isFingerprint } from './Helpers';
 import { gpgme_error } from './Errors';
 
 export class GPGME_Keyring {
@@ -39,10 +39,8 @@ export class GPGME_Keyring {
      *
      */
     getKeys(pattern, prepare_sync){
-        let me = this;
         return new Promise(function(resolve, reject) {
-            let msg;
-            msg = createMessage('keylist');
+            let msg = createMessage('keylist');
             if (pattern !== undefined){
                 msg.setParameter('keys', pattern);
             }
@@ -50,25 +48,28 @@ export class GPGME_Keyring {
             msg.post().then(function(result){
                 let resultset = [];
                 let promises = [];
-                // TODO check if result.key is not empty
-                for (let i=0; i< result.keys.length; i++){
-                    let k = createKey(result.keys[i].fingerprint, me);
-                    k.setKeyData(result.keys[i]);
-                    if (prepare_sync === true){
-                        promises.push(k.getArmor());
-                        promises.push(k.getHasSecret());
+                if (result.keys.length === 0){
+                    resolve([]);
+                } else {
+                    for (let i=0; i< result.keys.length; i++){
+                        let k = createKey(result.keys[i].fingerprint);
+                        k.setKeyData(result.keys[i]);
+                        if (prepare_sync === true){
+                            promises.push(k.getArmor());
+                            promises.push(k.getHasSecret());
+                        }
+                        resultset.push(k);
                     }
-                    resultset.push(k);
-                }
-                if (promises.length > 0) {
-                    Promise.all(promises).then(function (res){
+                    if (promises.length > 0) {
+                        Promise.all(promises).then(function() {
+                            resolve(resultset);
+                        }, function(error){
+                            reject(error);
+                        });
+                    } else {
                         resolve(resultset);
-                    }, function(error){
-                        reject(error);
-                    });
+                    }
                 }
-            }, function(error){
-                reject(error);
             });
         });
     }
@@ -80,7 +81,6 @@ export class GPGME_Keyring {
      * @returns {Promise<String>} Armored Key blocks
      */
     getKeysArmored(pattern) {
-        if (pattern)
         return new Promise(function(resolve, reject) {
             let msg = createMessage('export');
             msg.setParameter('armor', true);
@@ -92,10 +92,102 @@ export class GPGME_Keyring {
             }, function(error){
                 reject(error);
             });
+        });
     }
 
     // getDefaultKey() Big TODO
-    // importKeys(armoredKeys)
-    // generateKey  --> TODO (Andre noch anfragen!)
 
-};
+    /**
+     *
+     * @param {String} armored Armored Key block of the Kex(s) to be imported into gnupg
+     * @param {Boolean} prepare_sync prepare the keys for synched use (see getKeys()).
+     * @returns {Promise<Array<Object>>} An array of objects for the Keys considered.
+    *       Key.key The key itself as a GPGME_Key
+     *      Key.status String:
+     *          'nochange' if the Key was not changed,
+     *          'newkey' if the Key was imported in gpg, and did not exist previously,
+     *          'change' if the key existed, but details were updated. For details,
+     *              Key.changes is available.
+     *      Key.changes.userId: Boolean userIds changed
+     *      Key.changes.signature: Boolean signatures changed
+     *      Key.changes.subkey: Boolean subkeys changed
+     * // TODO: not yet implemented: Information about Keys that failed
+     *          (e.g. malformed Keys, secretKeys are not accepted)
+     */
+    importKey(armored, prepare_sync) {
+        if (!armored || typeof(armored) !== 'string'){
+            return Promise.reject(gpgme_error('PARAM_WRONG'));
+        }
+        let me = this;
+        return new Promise(function(resolve, reject){
+            let msg = createMessage('import');
+            msg.setParameter('data', armored);
+            msg.post().then(function(response){
+                let infos = {};
+                let fprs = [];
+                for (var res=0; res < response.result[0].imports.length; res++) {
+                    let result = response.result[0].imports[res];
+                    let status = '';
+                    if (result.status === 0){
+                        status = 'nochange';
+                    } else if ((result.status & 1) === 1){
+                        status = 'newkey';
+                    } else {
+                        status = 'change';
+                    }
+                    let changes = {};
+                    changes.userId = (result.status & 2) === 2;
+                    changes.signature = (result.status & 4) === 4;
+                    changes.subkey = (result.status & 8) === 8;
+                    //16 new secret key: not implemented
+
+                    fprs.push(result.fingerprint);
+                    infos[result.fingerprint] = {
+                        changes: changes,
+                        status: status
+                    };
+                }
+                let resultset = [];
+                if (prepare_sync === true){
+                    me.getKeys(fprs, true).then(function(result){
+                        for (let i=0; i < result.length; i++) {
+                            resultset.push({
+                                key: result[i],
+                                changes: infos[result[i].fingerprint].changes,
+                                status: infos[result[i].fingerprint].status
+                            });
+                        }
+                        resolve(resultset);
+                    }, function(error){
+                        reject(error);
+                    });
+                } else {
+                    for (let i=0; i < fprs.length; i++) {
+                        resultset.push({
+                            key: createKey(fprs[i]),
+                            changes: infos[fprs[i]].changes,
+                            status: infos[fprs[i]].status
+                        });
+                    }
+                    resolve(resultset);
+                }
+
+            }, function(error){
+                reject(error);
+            });
+
+
+        });
+
+
+    }
+
+    deleteKey(fingerprint){
+        if (isFingerprint(fingerprint) === true) {
+            let key = createKey(fingerprint);
+            key.delete();
+        }
+    }
+
+    // generateKey
+}