11957182454

Committed 21 Nov 2024 04:11PM UTC coverage: 79.712% (-0.5%) from 80.208%

Build # 11957182454

Build Type

Pull #1670

github

Committed by

web-flow

Commit Message

Merge ea16a2c57 into 518d322ef

Pull Request Pull Request #1670: Task/store last measure

Run Details

1935 of 2600 branches covered (74.42%)

Branch coverage included in aggregate %.

11 of 33 new or added lines in 5 files covered. (33.33%)

7 existing lines in 1 file now uncovered.

3711 of 4483 relevant lines covered (82.78%)

283.84 hits per line

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

57.53

/lib/services/devices/deviceRegistryMongoDB.js

/*
 * Copyright 2014 Telefonica Investigación y Desarrollo, S.A.U
 *
 * This file is part of fiware-iotagent-lib
 *
 * fiware-iotagent-lib 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.
 *
 * fiware-iotagent-lib 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 fiware-iotagent-lib.
 * If not, see http://www.gnu.org/licenses/.
 *
 * For those usages not covered by the GNU Affero General Public License
 * please contact with::daniel.moranjimenez@telefonica.com
 */

const logger = require('logops');
const dbService = require('../../model/dbConn');
const config = require('../../commonConfig');
const fillService = require('./../common/domain').fillService;
const alarmsInt = require('../common/alarmManagement').intercept;
const errors = require('../../errors');
const constants = require('../../constants');
const Device = require('../../model/Device');
const async = require('async');
let context = {
    op: 'IoTAgentNGSI.MongoDBDeviceRegister'
};

const attributeList = [
    'id',
    'type',
    'name',
    'service',
    'subservice',
    'lazy',
    'commands',
    'staticAttributes',
    'active',
    'registrationId',
    'internalId',
    'internalAttributes',
    'resource',
    'apikey',
    'protocol',
    'endpoint',
    'transport',
    'polling',
    'timestamp',
    'explicitAttrs',
    'ngsiVersion',
    'subscriptions',
    'payloadType'
];

/**
 * Generates a handler for the save device operations. The handler will take the customary error and the saved device
 * as the parameters (and pass the serialized DAO as the callback value).
 *
 * @return {Function}       The generated handler.
 */
function saveDeviceHandler(callback) {
    return function saveHandler(error, deviceDAO) {
        if (error) {
            logger.debug(fillService(context, deviceDAO), 'Error storing device information: %s', error);

            callback(new errors.InternalDbError(error));
        } else {
            callback(null, deviceDAO.toObject());
        }
    };
}

/**
 * Create a new register for a device. The device object should contain the id, type and registrationId
 *
 * @param {Object} newDevice           Device object to be stored
 */
function storeDevice(newDevice, callback) {
    /* eslint-disable-next-line  new-cap */
    const deviceObj = new Device.model();
    attributeList.forEach((key) => {
        deviceObj[key] = newDevice[key];
    });

    // Ensure protocol is in newDevice
    if (!newDevice.protocol && config.getConfig().iotManager && config.getConfig().iotManager.protocol) {
        deviceObj.protocol = config.getConfig().iotManager.protocol;
    }

    logger.debug(context, 'Storing device with id [%s] and type [%s]', newDevice.id, newDevice.type);

    deviceObj.save(function saveHandler(error, deviceDAO) {
        if (error) {
            if (error.code === 11000) {
                logger.debug(context, 'Tried to insert a device with duplicate ID in the database: %s', error);

                callback(new errors.DuplicateDeviceId(newDevice));
            } else {
                logger.debug(context, 'Error storing device information: %s', error);

                callback(new errors.InternalDbError(error));
            }
        } else {
            callback(null, deviceDAO.toObject());
        }
    });
}

/**
 * Remove the device identified by its id and service.
 *
 * @param {String} id           Device ID of the device to remove.
 * @param {String} service      Service of the device to remove.
 * @param {String} subservice   Subservice inside the service for the removed device.
 */
function removeDevice(id, apikey, service, subservice, callback) {
    const condition = {
        id,
        service,
        subservice
    };
    if (apikey) {
        condition.apikey = apikey;
    }
    logger.debug(context, 'Removing device with id [%s]', id);

    Device.model.deleteOne(condition, function (error) {
        if (error) {
            logger.debug(context, 'Internal MongoDB Error getting device: %s', error);

            callback(new errors.InternalDbError(error));
        } else {
            logger.debug(context, 'Device [%s] successfully removed.', id);

            callback(null);
        }
    });
}

/**
 * Return the list of currently registered devices (via callback).
 *
 * @param {String} tyoe         Type for which the devices are requested.
 * @param {String} service      Service for which the devices are requested.
 * @param {String} subservice   Subservice inside the service for which the devices are requested.
 * @param {Number} limit        Maximum number of entries to return.
 * @param {Number} offset       Number of entries to skip for pagination.
 */
function listDevices(type, service, subservice, limit, offset, callback) {
    const condition = {};

    if (type) {
        condition.type = type;
    }

    if (service) {
        condition.service = service;
    }

    if (subservice) {
        condition.subservice = subservice;
    }

    const query = Device.model.find(condition).sort();

    if (limit) {
        query.limit(parseInt(limit, 10));
    }

    if (offset) {
        query.skip(parseInt(offset, 10));
    }

    async.series(
        [query.exec.bind(query), Device.model.countDocuments.bind(Device.model, condition)],
        function (error, results) {
            callback(error, {
                count: results[1],
                devices: results[0]
            });
        }
    );
}

function findOneInMongoDB(queryParams, id, callback) {
    const query = Device.model.findOne(queryParams);
    query.select({ __v: 0 });

    query.lean().exec(function handleGet(error, data) {
        if (error) {
            logger.debug(context, 'Internal MongoDB Error getting device: %s', error);

            callback(new errors.InternalDbError(error));
        } else if (data) {
            context = fillService(context, data);
            logger.debug(context, 'Device data found: %j', data);
            callback(null, data);
        } else {
            logger.debug(context, 'Device [%s] not found.', id);

            callback(new errors.DeviceNotFound(id, queryParams));
        }
    });
}

/**
 * Internal function used to find a device in the DB.
 *
 * @param {String} id           ID of the Device to find.
 * @param {String} Apikey       Apikey of the Device to find.
 * @param {String} service      Service the device belongs to (optional).
 * @param {String} subservice   Division inside the service (optional).
 */
function getDeviceById(id, apikey, service, subservice, callback) {
    const queryParams = {
        id,
        service,
        subservice
    };
    if (apikey) {
        queryParams.apikey = apikey;
    }
    context = fillService(context, queryParams);
    logger.debug(context, 'Looking for device with id [%s] and queryParams [%j].', id, queryParams);
    findOneInMongoDB(queryParams, id, callback);
}

/**
 * Retrieves a device using it ID, converting it to a plain Object before calling the callback.
 *
 * @param {String} id           ID of the Device to find.
 * @param {String} service      Service the device belongs to.
 * @param {String} subservice   Division inside the service.
 */
function getDevice(id, apikey, service, subservice, callback) {
    getDeviceById(id, apikey, service, subservice, function (error, data) {
        if (error) {
            callback(error);
        } else {
            callback(null, data);
        }
    });
}

function getByNameAndType(name, type, service, servicepath, callback) {
    context = fillService(context, { service, subservice: servicepath });
    const optionsQuery = {
        name,
        service,
        subservice: servicepath
    };
    if (type) {
        optionsQuery.type = type;
    }
    logger.debug(context, 'Looking for device with [%j].', optionsQuery);
    const query = Device.model.findOne(optionsQuery);

    query.select({ __v: 0 });

    query.lean().exec(function handleGet(error, data) {
        if (error) {
            logger.debug(context, 'Internal MongoDB Error getting device: %s', error);

            callback(new errors.InternalDbError(error));
        } else if (data) {
            callback(null, data);
        } else {
            logger.debug(context, 'Device [%s] not found.', name);

            callback(new errors.DeviceNotFound(name, optionsQuery));
        }
    });
}

function getByName(name, service, servicepath, callback) {
    getByNameAndType(name, null, service, servicepath, callback);
}

/**
 * Updates the given device into the database.
 * updated.
 *
 * @param {Object} device       Device object with the new values to write.
 */
function update(previousDevice, device, callback) {
    logger.debug(context, 'Storing updated values for device [%s]:\n%s', device.id, JSON.stringify(device, null, 4));
    getDevice(device.id, previousDevice.apikey, device.service, device.subservice, function (error, data) {
        if (error) {
            callback(error);
        } else {
            data.lazy = device.lazy;
            data.active = device.active;
            data.internalId = device.internalId;
            data.staticAttributes = device.staticAttributes;
            data.internalAttributes = device.internalAttributes;
            data.commands = device.commands;
            data.endpoint = device.endpoint;
            data.transport = device.transport;
            data.polling = device.polling;
            data.name = device.name;
            data.type = device.type;
            data.apikey = device.apikey;
            data.registrationId = device.registrationId;
            data.explicitAttrs = device.explicitAttrs;
            data.ngsiVersion = device.ngsiVersion;
            data.timestamp = device.timestamp;
            data.subscriptions = device.subscriptions;
            data.payloadType = device.payloadType;

            /* eslint-disable-next-line  new-cap */
            const deviceObj = new Device.model(data);
            deviceObj.isNew = false;
            deviceObj.save(saveDeviceHandler(callback));
        }
    });
}

/**
 * Cleans all the information in the database, leaving it in a clean state.
 */
function clear(callback) {
    dbService.db.db.dropDatabase(callback);
}

function itemToObject(i) {
    if (i.toObject) {
        return i.toObject();
    } else {
        return i;
    }
}

function getDevicesByAttribute(name, value, service, subservice, callback) {
    const filter = {};

    if (service) {
        filter.service = service;
    }

    if (subservice) {
        filter.subservice = subservice;
    }

    filter[name] = value;
    context = fillService(context, filter);
    logger.debug(context, 'Looking for device with filter [%j].', filter);

    const query = Device.model.find(filter);
    query.select({ __v: 0 });

    query.exec(function handleGet(error, devices) {
        if (error) {
            logger.debug(context, 'Internal MongoDB Error getting device: %s', error);

            callback(new errors.InternalDbError(error));
        } else if (devices) {
            callback(null, devices.map(itemToObject));
        } else {
            logger.debug(context, 'Device [%s] not found.', name);

            callback(new errors.DeviceNotFound(name, filter));
        }
    });
}

function storeLastMeasure(measure, typeInformation, callback) {
    if (
        typeInformation &&
        typeInformation.id &&
        typeInformation.apikey &&
        typeInformation.service &&
        typeInformation.subservice
    ) {
        getDevice(
            typeInformation.id,
            typeInformation.apikey,
            typeInformation.service,
            typeInformation.subservice,
            function (error, data) {
                if (error) {
                    callback(error);
                } else {
                    data.lastMeasure = { timestamp: new Date().toISOString(), measure };
                    /* eslint-disable-next-line  new-cap */
                    const deviceObj = new Device.model(data);
                    deviceObj.isNew = false;
                    deviceObj.save(saveDeviceHandler(callback));
                }
            }
        );
    } else {
        callback(null, null);
    }
}

exports.getDevicesByAttribute = alarmsInt(constants.MONGO_ALARM, getDevicesByAttribute);
exports.store = alarmsInt(constants.MONGO_ALARM, storeDevice);
exports.storeLastMeasure = alarmsInt(constants.MONGO_ALARM, storeLastMeasure);
exports.update = alarmsInt(constants.MONGO_ALARM, update);
exports.remove = alarmsInt(constants.MONGO_ALARM, removeDevice);
exports.list = alarmsInt(constants.MONGO_ALARM, listDevices);
exports.get = alarmsInt(constants.MONGO_ALARM, getDevice);
exports.getSilently = getDevice;
exports.getByName = alarmsInt(constants.MONGO_ALARM, getByName);
exports.getByNameAndType = alarmsInt(constants.MONGO_ALARM, getByNameAndType);
exports.clear = alarmsInt(constants.MONGO_ALARM, clear);

1	/*
2	* Copyright 2014 Telefonica Investigación y Desarrollo, S.A.U
3	*
4	* This file is part of fiware-iotagent-lib
5	*
6	* fiware-iotagent-lib 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	* fiware-iotagent-lib 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 fiware-iotagent-lib.
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::daniel.moranjimenez@telefonica.com
22	*/
23
24	const logger = require('logops');	1✔
25	const dbService = require('../../model/dbConn');	1✔
26	const config = require('../../commonConfig');	1✔
27	const fillService = require('./../common/domain').fillService;	1✔
28	const alarmsInt = require('../common/alarmManagement').intercept;	1✔
29	const errors = require('../../errors');	1✔
30	const constants = require('../../constants');	1✔
31	const Device = require('../../model/Device');	1✔
32	const async = require('async');	1✔
33	let context = {	1✔
34	op: 'IoTAgentNGSI.MongoDBDeviceRegister'
35	};
36
37	const attributeList = [	1✔
38	'id',
39	'type',
40	'name',
41	'service',
42	'subservice',
43	'lazy',
44	'commands',
45	'staticAttributes',
46	'active',
47	'registrationId',
48	'internalId',
49	'internalAttributes',
50	'resource',
51	'apikey',
52	'protocol',
53	'endpoint',
54	'transport',
55	'polling',
56	'timestamp',
57	'explicitAttrs',
58	'ngsiVersion',
59	'subscriptions',
60	'payloadType'
61	];
62
63	/**
64	* Generates a handler for the save device operations. The handler will take the customary error and the saved device
65	* as the parameters (and pass the serialized DAO as the callback value).
66	*
67	* @return {Function} The generated handler.
68	*/
69	function saveDeviceHandler(callback) {
70	return function saveHandler(error, deviceDAO) {	×
71	if (error) {	×
72	logger.debug(fillService(context, deviceDAO), 'Error storing device information: %s', error);	×
73
74	callback(new errors.InternalDbError(error));	×
75	} else {
76	callback(null, deviceDAO.toObject());	×
77	}
78	};
79	}
80
81	/**
82	* Create a new register for a device. The device object should contain the id, type and registrationId
83	*
84	* @param {Object} newDevice Device object to be stored
85	*/
86	function storeDevice(newDevice, callback) {
87	/* eslint-disable-next-line new-cap */
88	const deviceObj = new Device.model();	59✔
89	attributeList.forEach((key) => {	59✔
90	deviceObj[key] = newDevice[key];	1,357✔
91	});
92
93	// Ensure protocol is in newDevice
94	if (!newDevice.protocol && config.getConfig().iotManager && config.getConfig().iotManager.protocol) {	59!
95	deviceObj.protocol = config.getConfig().iotManager.protocol;	×
96	}
97
98	logger.debug(context, 'Storing device with id [%s] and type [%s]', newDevice.id, newDevice.type);	59✔
99
100	deviceObj.save(function saveHandler(error, deviceDAO) {	59✔
101	if (error) {	59!
102	if (error.code === 11000) {	×
103	logger.debug(context, 'Tried to insert a device with duplicate ID in the database: %s', error);	×
104
105	callback(new errors.DuplicateDeviceId(newDevice));	×
106	} else {
107	logger.debug(context, 'Error storing device information: %s', error);	×
108
109	callback(new errors.InternalDbError(error));	×
110	}
111	} else {
112	callback(null, deviceDAO.toObject());	59✔
113	}
114	});
115	}
116
117	/**
118	* Remove the device identified by its id and service.
119	*
120	* @param {String} id Device ID of the device to remove.
121	* @param {String} service Service of the device to remove.
122	* @param {String} subservice Subservice inside the service for the removed device.
123	*/
124	function removeDevice(id, apikey, service, subservice, callback) {
125	const condition = {	1✔
126	id,
127	service,
128	subservice
129	};
130	if (apikey) {	1!
131	condition.apikey = apikey;	×
132	}
133	logger.debug(context, 'Removing device with id [%s]', id);	1✔
134
135	Device.model.deleteOne(condition, function (error) {	1✔
136	if (error) {	1!
137	logger.debug(context, 'Internal MongoDB Error getting device: %s', error);	×
138
139	callback(new errors.InternalDbError(error));	×
140	} else {
141	logger.debug(context, 'Device [%s] successfully removed.', id);	1✔
142
143	callback(null);	1✔
144	}
145	});
146	}
147
148	/**
149	* Return the list of currently registered devices (via callback).
150	*
151	* @param {String} tyoe Type for which the devices are requested.
152	* @param {String} service Service for which the devices are requested.
153	* @param {String} subservice Subservice inside the service for which the devices are requested.
154	* @param {Number} limit Maximum number of entries to return.
155	* @param {Number} offset Number of entries to skip for pagination.
156	*/
157	function listDevices(type, service, subservice, limit, offset, callback) {
158	const condition = {};	2✔
159
160	if (type) {	2!
161	condition.type = type;	×
162	}
163
164	if (service) {	2!
165	condition.service = service;	2✔
166	}
167
168	if (subservice) {	2!
169	condition.subservice = subservice;	2✔
170	}
171
172	const query = Device.model.find(condition).sort();	2✔
173
174	if (limit) {	2!
175	query.limit(parseInt(limit, 10));	2✔
176	}
177
178	if (offset) {	2!
179	query.skip(parseInt(offset, 10));	2✔
180	}
181
182	async.series(	2✔
183	[query.exec.bind(query), Device.model.countDocuments.bind(Device.model, condition)],
184	function (error, results) {
185	callback(error, {	2✔
186	count: results[1],
187	devices: results[0]
188	});
189	}
190	);
191	}
192
193	function findOneInMongoDB(queryParams, id, callback) {
194	const query = Device.model.findOne(queryParams);	64✔
195	query.select({ __v: 0 });	64✔
196
197	query.lean().exec(function handleGet(error, data) {	64✔
198	if (error) {	64!
199	logger.debug(context, 'Internal MongoDB Error getting device: %s', error);	×
200
201	callback(new errors.InternalDbError(error));	×
202	} else if (data) {	64✔
203	context = fillService(context, data);	4✔
204	logger.debug(context, 'Device data found: %j', data);	4✔
205	callback(null, data);	4✔
206	} else {
207	logger.debug(context, 'Device [%s] not found.', id);	60✔
208
209	callback(new errors.DeviceNotFound(id, queryParams));	60✔
210	}
211	});
212	}
213
214	/**
215	* Internal function used to find a device in the DB.
216	*
217	* @param {String} id ID of the Device to find.
218	* @param {String} Apikey Apikey of the Device to find.
219	* @param {String} service Service the device belongs to (optional).
220	* @param {String} subservice Division inside the service (optional).
221	*/
222	function getDeviceById(id, apikey, service, subservice, callback) {
223	const queryParams = {	64✔
224	id,
225	service,
226	subservice
227	};
228	if (apikey) {	64✔
229	queryParams.apikey = apikey;	7✔
230	}
231	context = fillService(context, queryParams);	64✔
232	logger.debug(context, 'Looking for device with id [%s] and queryParams [%j].', id, queryParams);	64✔
233	findOneInMongoDB(queryParams, id, callback);	64✔
234	}
235
236	/**
237	* Retrieves a device using it ID, converting it to a plain Object before calling the callback.
238	*
239	* @param {String} id ID of the Device to find.
240	* @param {String} service Service the device belongs to.
241	* @param {String} subservice Division inside the service.
242	*/
243	function getDevice(id, apikey, service, subservice, callback) {
244	getDeviceById(id, apikey, service, subservice, function (error, data) {	64✔
245	if (error) {	64✔
246	callback(error);	60✔
247	} else {
248	callback(null, data);	4✔
249	}
250	});
251	}
252
253	function getByNameAndType(name, type, service, servicepath, callback) {
254	context = fillService(context, { service, subservice: servicepath });	13✔
255	const optionsQuery = {	13✔
256	name,
257	service,
258	subservice: servicepath
259	};
260	if (type) {	13✔
261	optionsQuery.type = type;	10✔
262	}
263	logger.debug(context, 'Looking for device with [%j].', optionsQuery);	13✔
264	const query = Device.model.findOne(optionsQuery);	13✔
265
266	query.select({ __v: 0 });	13✔
267
268	query.lean().exec(function handleGet(error, data) {	13✔
269	if (error) {	13!
270	logger.debug(context, 'Internal MongoDB Error getting device: %s', error);	×
271
272	callback(new errors.InternalDbError(error));	×
273	} else if (data) {	13!
274	callback(null, data);	13✔
275	} else {
276	logger.debug(context, 'Device [%s] not found.', name);	×
277
278	callback(new errors.DeviceNotFound(name, optionsQuery));	×
279	}
280	});
281	}
282
283	function getByName(name, service, servicepath, callback) {
284	getByNameAndType(name, null, service, servicepath, callback);	3✔
285	}
286
287	/**
288	* Updates the given device into the database.
289	* updated.
290	*
291	* @param {Object} device Device object with the new values to write.
292	*/
293	function update(previousDevice, device, callback) {
294	logger.debug(context, 'Storing updated values for device [%s]:\n%s', device.id, JSON.stringify(device, null, 4));	×
295	getDevice(device.id, previousDevice.apikey, device.service, device.subservice, function (error, data) {	×
296	if (error) {	×
297	callback(error);	×
298	} else {
299	data.lazy = device.lazy;	×
300	data.active = device.active;	×
301	data.internalId = device.internalId;	×
302	data.staticAttributes = device.staticAttributes;	×
303	data.internalAttributes = device.internalAttributes;	×
304	data.commands = device.commands;	×
305	data.endpoint = device.endpoint;	×
306	data.transport = device.transport;	×
307	data.polling = device.polling;	×
308	data.name = device.name;	×
309	data.type = device.type;	×
310	data.apikey = device.apikey;	×
311	data.registrationId = device.registrationId;	×
312	data.explicitAttrs = device.explicitAttrs;	×
313	data.ngsiVersion = device.ngsiVersion;	×
314	data.timestamp = device.timestamp;	×
315	data.subscriptions = device.subscriptions;	×
316	data.payloadType = device.payloadType;	×
317
318	/* eslint-disable-next-line new-cap */
319	const deviceObj = new Device.model(data);	×
320	deviceObj.isNew = false;	×
321	deviceObj.save(saveDeviceHandler(callback));	×
322	}
323	});
324	}
325
326	/**
327	* Cleans all the information in the database, leaving it in a clean state.
328	*/
329	function clear(callback) {
330	dbService.db.db.dropDatabase(callback);	27✔
331	}
332
333	function itemToObject(i) {
334	if (i.toObject) {	1!
335	return i.toObject();	1✔
336	} else {
337	return i;	×
338	}
339	}
340
341	function getDevicesByAttribute(name, value, service, subservice, callback) {
342	const filter = {};	1✔
343
344	if (service) {	1!
345	filter.service = service;	1✔
346	}
347
348	if (subservice) {	1!
349	filter.subservice = subservice;	1✔
350	}
351
352	filter[name] = value;	1✔
353	context = fillService(context, filter);	1✔
354	logger.debug(context, 'Looking for device with filter [%j].', filter);	1✔
355
356	const query = Device.model.find(filter);	1✔
357	query.select({ __v: 0 });	1✔
358
359	query.exec(function handleGet(error, devices) {	1✔
360	if (error) {	1!
361	logger.debug(context, 'Internal MongoDB Error getting device: %s', error);	×
362
363	callback(new errors.InternalDbError(error));	×
364	} else if (devices) {	1!
365	callback(null, devices.map(itemToObject));	1✔
366	} else {
367	logger.debug(context, 'Device [%s] not found.', name);	×
368
369	callback(new errors.DeviceNotFound(name, filter));	×
370	}
371	});
372	}
373
374	function storeLastMeasure(measure, typeInformation, callback) {
NEW UNCOV 375	if (	×
376	typeInformation &&	×
377	typeInformation.id &&
378	typeInformation.apikey &&
379	typeInformation.service &&
380	typeInformation.subservice
381	) {
NEW UNCOV 382	getDevice(	×
383	typeInformation.id,
384	typeInformation.apikey,
385	typeInformation.service,
386	typeInformation.subservice,
387	function (error, data) {
NEW UNCOV 388	if (error) {	×
NEW UNCOV 389	callback(error);	×
390	} else {
NEW UNCOV 391	data.lastMeasure = { timestamp: new Date().toISOString(), measure };	×
392	/* eslint-disable-next-line new-cap */
NEW UNCOV 393	const deviceObj = new Device.model(data);	×
NEW UNCOV 394	deviceObj.isNew = false;	×
NEW 395	deviceObj.save(saveDeviceHandler(callback));	×
396	}
397	}
398	);
399	} else {
NEW 400	callback(null, null);	×
401	}
402	}
403
404	exports.getDevicesByAttribute = alarmsInt(constants.MONGO_ALARM, getDevicesByAttribute);	1✔
405	exports.store = alarmsInt(constants.MONGO_ALARM, storeDevice);	1✔
406	exports.storeLastMeasure = alarmsInt(constants.MONGO_ALARM, storeLastMeasure);	1✔
407	exports.update = alarmsInt(constants.MONGO_ALARM, update);	1✔
408	exports.remove = alarmsInt(constants.MONGO_ALARM, removeDevice);	1✔
409	exports.list = alarmsInt(constants.MONGO_ALARM, listDevices);	1✔
410	exports.get = alarmsInt(constants.MONGO_ALARM, getDevice);	1✔
411	exports.getSilently = getDevice;	1✔
412	exports.getByName = alarmsInt(constants.MONGO_ALARM, getByName);	1✔
413	exports.getByNameAndType = alarmsInt(constants.MONGO_ALARM, getByNameAndType);	1✔
414	exports.clear = alarmsInt(constants.MONGO_ALARM, clear);	1✔

telefonicaid / iotagent-node-lib / 11957182454

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