17369349134

Committed 01 Sep 2025 06:19AM UTC coverage: 77.379% (-0.2%) from 77.554%

Build # 17369349134

Build Type

Pull #817

github

Committed by

web-flow

Commit Message

Merge 201d0fa4e into eed715581

Pull Request Pull Request #817: [WIP] upgrade dep driver mongodb to 4

Run Details

756 of 1117 branches covered (67.68%)

Branch coverage included in aggregate %.

107 of 124 new or added lines in 6 files covered. (86.29%)

4 existing lines in 3 files now uncovered.

2196 of 2698 relevant lines covered (81.39%)

68.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.5

/lib/models/rulesStore.js

/*
 * Copyright 2015 Telefonica Investigación y Desarrollo, S.A.U
 *
 * This file is part of perseo-fe
 *
 * perseo-fe is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 *
 * perseo-fe is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License along with perseo-fe.
 * If not, see http://www.gnu.org/licenses/.
 *
 * For those usages not covered by the GNU Affero General Public License
 * please contact with::[contacto@tid.es]
 */
'use strict';

var util = require('util'),
    appContext = require('../appContext'),
    rulesCollectionName = require('../../config').collections.rules,
    myutils = require('../myutils'),
    logger = require('logops'),
    errors = {};

function parsePostAxnParams(rule) {
    if (rule && rule.action && rule.action.type === 'post') {
        if (rule.action.parameters.json) {
            try {
                rule.action.parameters.json = JSON.parse(rule.action.parameters.json);
            } catch (ex) {
                myutils.logErrorIf(ex);
            }
        }
        if (rule.action.parameters.qs) {
            try {
                rule.action.parameters.qs = JSON.parse(rule.action.parameters.qs);
            } catch (ex) {
                myutils.logErrorIf(ex);
            }
        }
        if (rule.action.parameters.headers) {
            try {
                rule.action.parameters.headers = JSON.parse(rule.action.parameters.headers);
            } catch (ex) {
                myutils.logErrorIf(ex);
            }
        }
    }
}

function stringifyPostAxnParams(rule) {
    if (rule && rule.action && rule.action.type === 'post') {
        if (rule.action.parameters.json) {
            try {
                rule.action.parameters.json = JSON.stringify(rule.action.parameters.json);
            } catch (e) {
                myutils.logErrorIf(e);
            }
        }
        if (rule.action.parameters.qs) {
            try {
                rule.action.parameters.qs = JSON.stringify(rule.action.parameters.qs);
            } catch (e) {
                myutils.logErrorIf(e);
            }
        }
        if (rule.action.parameters.headers) {
            try {
                rule.action.parameters.headers = JSON.stringify(rule.action.parameters.headers);
            } catch (e) {
                myutils.logErrorIf(e);
            }
        }
    }
}

function search(rule, callback) {
    myutils.collectionExists(appContext.Db(), rulesCollectionName, function(exists) {
        if (!exists) {
            return callback('collection ' + rulesCollectionName + ' does not exist');
        }
        var col = appContext.Db().collection(rulesCollectionName);
        col.findOne({ name: rule.name, subservice: rule.subservice, service: rule.service }, callback);
    });
}

function findAll(service, subservice, callback) {
    var criterion = {};

    if (typeof service === 'function') {
        callback = service;
    } else {
        criterion.service = service;
        criterion.subservice = subservice;
    }
    var db = appContext.Db();
    myutils.collectionExists(db, rulesCollectionName, function(exists) {
        if (!exists) {
            return callback('collection ' + rulesCollectionName + ' does not exist');
        }
        const col = db.collection(rulesCollectionName);
        col.find(criterion).toArray(function(err, rules) {
            if (rules && util.isArray(rules)) {
                rules.forEach(function(r) {
                    parsePostAxnParams(r);
                });
            }
            myutils.logErrorIf(err);
            logger.info('rulesStore.FindAll %s', myutils.firstChars(rules));
            return callback(err, rules);
        });
    });
}

module.exports = {
    Find: function Find(rule, callback) {
        search(rule, function(err, result) {
            myutils.logErrorIf(err);
            if (err) {
                return callback(err, null);
            }
            if (!result) {
                return callback(new errors.NotFoundRule(rule.name), null);
            }
            parsePostAxnParams(result);
            logger.info('rulesStore.Find %s', myutils.firstChars(result));
            return callback(err, result);
        });
    },
    Exists: function Exists(rule, callback) {
        search(rule, function(err, result) {
            myutils.logErrorIf(err);
            callback(err, Boolean(result));
        });
    },
    FindAll: findAll,
    Remove: function Remove(rule, callback) {
        myutils.collectionExists(appContext.Db(), rulesCollectionName, function(exists) {
            if (!exists) {
                return callback('collection ' + rulesCollectionName + ' does not exist');
            }

            var col = appContext.Db().collection(rulesCollectionName);
            col.remove(
                {
                    name: rule.name,
                    subservice: rule.subservice,
                    service: rule.service
                },
                function(err, result) {
                    myutils.logErrorIf(err);
                    logger.info('rulesStore.Remove %j', myutils.firstChars(result));
                    return callback(err, result);
                }
            );
        });
    },
    Save: function Save(r, callback) {
        var cb = function(err, result) {
            myutils.logErrorIf(err);
            logger.info('rulesStore.Save %j', myutils.firstChars(result));
            return callback(err, result);
        };

        myutils.collectionExists(appContext.Db(), rulesCollectionName, function(exists) {
            if (!exists) {
                return cb('collection ' + rulesCollectionName + ' does not exist');
            }

            var col = appContext.Db().collection(rulesCollectionName);
            stringifyPostAxnParams(r);
            // Depending if r has _id or not we use updateOne or insertOne
            if (r._id) {
                col.updateOne({ _id: r._id }, r, cb);
            } else {
                col.insertOne(r, cb);
            }
        });
    },
    Update: function Update(id, r, callback) {
        var cb = function(err, result) {
            myutils.logErrorIf(err);
            logger.info('rulesStore.Update %j', myutils.firstChars(result));
            return callback(err, result);
        };

        myutils.collectionExists(appContext.Db(), rulesCollectionName, function(exists) {
            if (!exists) {
                return cb('collection ' + rulesCollectionName + ' does not exist');
            }
            var col = appContext.Db().collection(rulesCollectionName);
            stringifyPostAxnParams(r);

            col.findOneAndUpdate(
                { name: id },
                { $set: r },
                {
                    upsert: false,
                    returnNewDocument: true
                },
                function(err, result) {
                    if (result && result.lastErrorObject && result.lastErrorObject.updatedExisting === false) {
                        return cb(new errors.NotFoundRule(id), null);
                    }
                    parsePostAxnParams(r);
                    logger.debug('rulesStore.findOneAndUpdate %s', myutils.firstChars(r));
                    return cb(err, r);
                }
            );
        });
    }
};
/**
 * Constructors for possible errors from this module
 *
 * @type {Object}
 */
module.exports.errors = errors;

(function() {
    errors.NotFoundRule = function NotFoundRule(msg) {
        this.name = 'RULE_NOTFOUND';
        this.message = 'rule not found ' + msg;
        this.httpCode = 404;
    };
    Object.keys(errors).forEach(function(element) {
        util.inherits(errors[element], Error);
    });
})();

1	/*
2	* Copyright 2015 Telefonica Investigación y Desarrollo, S.A.U
3	*
4	* This file is part of perseo-fe
5	*
6	* perseo-fe is free software: you can redistribute it and/or
7	* modify it under the terms of the GNU Affero General Public License as
8	* published by the Free Software Foundation, either version 3 of the License,
9	* or (at your option) any later version.
10	*
11	* perseo-fe is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14	* See the GNU Affero General Public License for more details.
15	*
16	* You should have received a copy of the GNU Affero General Public
17	* License along with perseo-fe.
18	* If not, see http://www.gnu.org/licenses/.
19	*
20	* For those usages not covered by the GNU Affero General Public License
21	* please contact with::[contacto@tid.es]
22	*/
23	'use strict';
24
25	var util = require('util'),	1✔
26	appContext = require('../appContext'),	1✔
27	rulesCollectionName = require('../../config').collections.rules,	1✔
28	myutils = require('../myutils'),	1✔
29	logger = require('logops'),	1✔
30	errors = {};	1✔
31
32	function parsePostAxnParams(rule) {
33	if (rule && rule.action && rule.action.type === 'post') {	54✔
34	if (rule.action.parameters.json) {	8!
35	try {	×
36	rule.action.parameters.json = JSON.parse(rule.action.parameters.json);	×
37	} catch (ex) {
38	myutils.logErrorIf(ex);	×
39	}
40	}
41	if (rule.action.parameters.qs) {	8!
42	try {	×
43	rule.action.parameters.qs = JSON.parse(rule.action.parameters.qs);	×
44	} catch (ex) {
45	myutils.logErrorIf(ex);	×
46	}
47	}
48	if (rule.action.parameters.headers) {	8!
49	try {	×
50	rule.action.parameters.headers = JSON.parse(rule.action.parameters.headers);	×
51	} catch (ex) {
52	myutils.logErrorIf(ex);	×
53	}
54	}
55	}
56	}
57
58	function stringifyPostAxnParams(rule) {
59	if (rule && rule.action && rule.action.type === 'post') {	137✔
60	if (rule.action.parameters.json) {	22!
61	try {	×
62	rule.action.parameters.json = JSON.stringify(rule.action.parameters.json);	×
63	} catch (e) {
64	myutils.logErrorIf(e);	×
65	}
66	}
67	if (rule.action.parameters.qs) {	22!
68	try {	×
69	rule.action.parameters.qs = JSON.stringify(rule.action.parameters.qs);	×
70	} catch (e) {
71	myutils.logErrorIf(e);	×
72	}
73	}
74	if (rule.action.parameters.headers) {	22!
75	try {	×
76	rule.action.parameters.headers = JSON.stringify(rule.action.parameters.headers);	×
77	} catch (e) {
78	myutils.logErrorIf(e);	×
79	}
80	}
81	}
82	}
83
84	function search(rule, callback) {
85	myutils.collectionExists(appContext.Db(), rulesCollectionName, function(exists) {	249✔
86	if (!exists) {	249✔
87	return callback('collection ' + rulesCollectionName + ' does not exist');	44✔
88	}
89	var col = appContext.Db().collection(rulesCollectionName);	205✔
90	col.findOne({ name: rule.name, subservice: rule.subservice, service: rule.service }, callback);	205✔
91	});
92	}
93
94	function findAll(service, subservice, callback) {
95	var criterion = {};	103✔
96
97	if (typeof service === 'function') {	103✔
98	callback = service;	98✔
99	} else {
100	criterion.service = service;	5✔
101	criterion.subservice = subservice;	5✔
102	}
103	var db = appContext.Db();	103✔
104	myutils.collectionExists(db, rulesCollectionName, function(exists) {	103✔
105	if (!exists) {	103✔
106	return callback('collection ' + rulesCollectionName + ' does not exist');	2✔
107	}
108	const col = db.collection(rulesCollectionName);	101✔
109	col.find(criterion).toArray(function(err, rules) {	101✔
110	if (rules && util.isArray(rules)) {	101!
111	rules.forEach(function(r) {	101✔
112	parsePostAxnParams(r);	12✔
113	});
114	}
115	myutils.logErrorIf(err);	101✔
116	logger.info('rulesStore.FindAll %s', myutils.firstChars(rules));	101✔
117	return callback(err, rules);	101✔
118	});
119	});
120	}
121
122	module.exports = {	1✔
123	Find: function Find(rule, callback) {
124	search(rule, function(err, result) {	80✔
125	myutils.logErrorIf(err);	80✔
126	if (err) {	80✔
127	return callback(err, null);	22✔
128	}
129	if (!result) {	58✔
130	return callback(new errors.NotFoundRule(rule.name), null);	17✔
131	}
132	parsePostAxnParams(result);	41✔
133	logger.info('rulesStore.Find %s', myutils.firstChars(result));	41✔
134	return callback(err, result);	41✔
135	});
136	},
137	Exists: function Exists(rule, callback) {
138	search(rule, function(err, result) {	169✔
139	myutils.logErrorIf(err);	169✔
140	callback(err, Boolean(result));	169✔
141	});
142	},
143	FindAll: findAll,
144	Remove: function Remove(rule, callback) {
145	myutils.collectionExists(appContext.Db(), rulesCollectionName, function(exists) {	30✔
146	if (!exists) {	30✔
147	return callback('collection ' + rulesCollectionName + ' does not exist');	22✔
148	}
149
150	var col = appContext.Db().collection(rulesCollectionName);	8✔
151	col.remove(	8✔
152	{
153	name: rule.name,
154	subservice: rule.subservice,
155	service: rule.service
156	},
157	function(err, result) {
158	myutils.logErrorIf(err);	8✔
159	logger.info('rulesStore.Remove %j', myutils.firstChars(result));	8✔
160	return callback(err, result);	8✔
161	}
162	);
163	});
164	},
165	Save: function Save(r, callback) {
166	var cb = function(err, result) {	135✔
167	myutils.logErrorIf(err);	135✔
168	logger.info('rulesStore.Save %j', myutils.firstChars(result));	135✔
169	return callback(err, result);	135✔
170	};
171
172	myutils.collectionExists(appContext.Db(), rulesCollectionName, function(exists) {	135✔
173	if (!exists) {	135!
NEW 174	return cb('collection ' + rulesCollectionName + ' does not exist');	×
175	}
176
177	var col = appContext.Db().collection(rulesCollectionName);	135✔
178	stringifyPostAxnParams(r);	135✔
179	// Depending if r has _id or not we use updateOne or insertOne
180	if (r._id) {	135!
NEW 181	col.updateOne({ _id: r._id }, r, cb);	×
182	} else {
183	col.insertOne(r, cb);	135✔
184	}
185	});
186	},
187	Update: function Update(id, r, callback) {
188	var cb = function(err, result) {	2✔
189	myutils.logErrorIf(err);	2✔
190	logger.info('rulesStore.Update %j', myutils.firstChars(result));	2✔
191	return callback(err, result);	2✔
192	};
193
194	myutils.collectionExists(appContext.Db(), rulesCollectionName, function(exists) {	2✔
195	if (!exists) {	2!
NEW 196	return cb('collection ' + rulesCollectionName + ' does not exist');	×
197	}
198	var col = appContext.Db().collection(rulesCollectionName);	2✔
199	stringifyPostAxnParams(r);	2✔
200
201	col.findOneAndUpdate(	2✔
202	{ name: id },
203	{ $set: r },
204	{
205	upsert: false,
206	returnNewDocument: true
207	},
208	function(err, result) {
209	if (result && result.lastErrorObject && result.lastErrorObject.updatedExisting === false) {	2✔
210	return cb(new errors.NotFoundRule(id), null);	1✔
211	}
212	parsePostAxnParams(r);	1✔
213	logger.debug('rulesStore.findOneAndUpdate %s', myutils.firstChars(r));	1✔
214	return cb(err, r);	1✔
215	}
216	);
217	});
218	}
219	};
220	/**
221	* Constructors for possible errors from this module
222	*
223	* @type {Object}
224	*/
225	module.exports.errors = errors;	1✔
226
227	(function() {	1✔
228	errors.NotFoundRule = function NotFoundRule(msg) {	1✔
229	this.name = 'RULE_NOTFOUND';	18✔
230	this.message = 'rule not found ' + msg;	18✔
231	this.httpCode = 404;	18✔
232	};
233	Object.keys(errors).forEach(function(element) {	1✔
234	util.inherits(errors[element], Error);	1✔
235	});
236	})();

telefonicaid / perseo-fe / 17369349134

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous