js: change in initialization ancd connection handling
[gpgme.git] / lang / js / src / Keyring.js
1 /* gpgme.js - Javascript integration for gpgme
2  * Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * GPGME is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  * SPDX-License-Identifier: LGPL-2.1+
19  */
20
21 import {GPGME_Message} from './Message'
22 import {GPGME_Key} from './Key'
23 import { isFingerprint, isLongId } from './Helpers';
24
25 export class GPGME_Keyring {
26     constructor(connection){
27         this.connection = connection;
28     }
29
30     set connection(connection){
31         if (!this._connection && connection instanceof Connection){
32             this._connection = connection;
33         }
34     }
35     get connection(){
36         if (this._connection instanceof Connection){
37             if (this._connection.isConnected){
38                 return this._connection;
39             }
40             return undefined; //TODO: connection was lost!
41         }
42         return undefined; //TODO: no connection there
43     }
44
45     /**
46      * @param {String} (optional) pattern A pattern to search for, in userIds or KeyIds
47      * @param {Boolean} (optional) Include listing of secret keys
48      * @returns {Promise.<Array<GPGME_Key>>}
49      *
50      */
51     getKeys(pattern, include_secret){
52         let msg = new GPGME_Message('listkeys');
53         if (pattern && typeof(pattern) === 'string'){
54             msg.setParameter('pattern', pattern);
55         }
56         if (include_secret){
57             msg.setParameter('with-secret', true);
58         }
59
60         this.connection.post(msg).then(function(result){
61             let fpr_list = [];
62             let resultset = [];
63             if (!Array.isArray(result.keys)){
64             //TODO check assumption keys = Array<String fingerprints>
65                 fpr_list = [result.keys];
66             } else {
67                 fpr_list = result.keys;
68             }
69             for (let i=0; i < fpr_list.length; i++){
70                 let newKey = new GPGME_Key(fpr_list[i]);
71                 if (newKey instanceof GPGME_Key){
72                     resultset.push(newKey);
73                 }
74             }
75             return Promise.resolve(resultset);
76         });
77     }
78
79     /**
80      * @param {Object} flags subset filter expecting at least one of the
81      * filters described below. True will filter on the condition, False will
82      * reverse the filter, if not present or undefined, the filter will not be
83      * considered. Please note that some combination may not make sense
84      * @param {Boolean} flags.defaultKey Only Keys marked as Default Keys
85      * @param {Boolean} flags.secret Only Keys containing a secret part.
86      * @param {Boolean} flags.valid Valid Keys only
87      * @param {Boolean} flags.revoked revoked Keys only
88      * @param {Boolean} flags.expired Expired Keys only
89      * @param {String} (optional) pattern A pattern to search for, in userIds or KeyIds
90      * @returns {Promise Array<GPGME_Key>}
91      *
92      */
93     getSubset(flags, pattern){
94         if (flags === undefined) {
95             throw('ERR_WRONG_PARAM');
96         };
97         let secretflag = false;
98         if (flags.hasOwnProperty(secret) && flags.secret){
99             secretflag = true;
100         }
101         this.getKeys(pattern, secretflag).then(function(queryset){
102             let resultset = [];
103             for (let i=0; i < queryset.length; i++ ){
104                 let conditions = [];
105                 let anticonditions = [];
106                 if (secretflag === true){
107                     conditions.push('hasSecret');
108                 } else if (secretflag === false){
109                     anticonditions.push('hasSecret');
110                 }
111                 if (flags.defaultKey === true){
112                     conditions.push('isDefault');
113                 } else if (flags.defaultKey === false){
114                     anticonditions.push('isDefault');
115                 }
116                 if (flags.valid === true){
117                     anticonditions.push('isInvalid');
118                 } else if (flags.valid === false){
119                     conditions.push('isInvalid');
120                 }
121                 if (flags.revoked === true){
122                     conditions.push('isRevoked');
123                 } else if (flags.revoked === false){
124                     anticonditions.push('isRevoked');
125                 }
126                 if (flags.expired === true){
127                     conditions.push('isExpired');
128                 } else if (flags.expired === false){
129                     anticonditions.push('isExpired');
130                 }
131                 let decision = undefined;
132                 for (let con = 0; con < conditions.length; con ++){
133                     if (queryset[i][conditions[con]] !== true){
134                         decision = false;
135                     }
136                 }
137                 for (let acon = 0; acon < anticonditions.length; acon ++){
138                     if (queryset[i][anticonditions[acon]] === true){
139                         decision = false;
140                     }
141                 }
142                 if (decision !== false){
143                     resultset.push(queryset[i]);
144                 }
145             }
146             return Promise.resolve(resultset);
147         });
148     }
149
150 };