11917675559

Committed 19 Nov 2024 04:43PM UTC coverage: 80.108% (-0.1%) from 80.208%

Build # 11917675559

Build Type

Pull #1670

github

Committed by

web-flow

Commit Message

Merge ba0ccab6d into 518d322ef

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

Run Details

1946 of 2594 branches covered (75.02%)

Branch coverage included in aggregate %.

15 of 23 new or added lines in 4 files covered. (65.22%)

27 existing lines in 2 files now uncovered.

3716 of 4474 relevant lines covered (83.06%)

283.25 hits per line

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

87.33

/lib/services/devices/deviceRegistryMemory.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
 */

/* eslint-disable no-prototype-builtins */

let registeredDevices = {};
const logger = require('logops');
const errors = require('../../errors');
const _ = require('underscore');
const context = {
    op: 'IoTAgentNGSI.InMemoryDeviceRegister'
};

function deepClone(device) {
    const initialClone = _.clone(device);

    for (const i in device) {
        if (device.hasOwnProperty(i) && Array.isArray(device[i])) {
            initialClone[i] = device[i].map(_.clone);
        }
    }

    return initialClone;
}

/**
 * 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) {
    if (!registeredDevices[newDevice.service]) {
        registeredDevices[newDevice.service] = {};
    }

    if (registeredDevices[newDevice.service][newDevice.id]) {
        callback(new errors.DuplicateDeviceId(newDevice));
    } else {
        registeredDevices[newDevice.service][newDevice.id] = deepClone(newDevice);
        registeredDevices[newDevice.service][newDevice.id].creationDate = Date.now();

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

/**
 * 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 services = Object.keys(registeredDevices);

    for (let i = 0; i < services.length; i++) {
        if (registeredDevices[services[i]][id]) {
            logger.debug(context, 'Removing device with id [%s] from service [%s].', id, services[i]);
            delete registeredDevices[services[i]][id];
        }
    }

    callback(null);
}

/**
 * Function to filter all the devices belonging to a service and subservice.
 *
 * @param {String} service      Service name to use in the filtering.
 * @param {String} subservice   Subservice name to use in the filtering.
 * @return {Function}           List of all the devices belonging to the given service and subservice.
 */
function getDevicesByService(service, subservice) {
    if (registeredDevices[service]) {
        return Object.keys(registeredDevices[service]).filter(function filterByService(item) {
            if (subservice) {
                return registeredDevices[service][item].subservice === subservice;
            }
            return true;
        });
    }
    return [];
}

/**
 * Return the list of currently registered devices (via callback).
 *
 * @param {String} service      Service for which the entries will be returned.
 * @param {String} subservice   Subservice for which the entries will be listed.
 * @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 result = [];
    let skipped = 0;
    const deviceList = getDevicesByService(service, subservice);

    let countNumber = deviceList.length;
    for (const i in deviceList) {
        if (registeredDevices[service].hasOwnProperty(deviceList[i])) {
            if (offset && skipped < parseInt(offset, 10)) {
                skipped++;
            } else if (type && registeredDevices[service][deviceList[i]].type === type) {
                result.push(registeredDevices[service][deviceList[i]]);
            } else if (type) {
                countNumber--;
            } else {
                result.push(registeredDevices[service][deviceList[i]]);
            }

            if (limit && result.length === parseInt(limit, 10)) {
                break;
            }
        }
    }

    callback(null, {
        count: countNumber,
        devices: result
    });
}

function getDevice(id, apikey, service, subservice, callback) {
    if (registeredDevices[service] && registeredDevices[service][id]) {
        callback(null, registeredDevices[service][id]);
    } else {
        callback(new errors.DeviceNotFound(id));
    }
}

function getByNameAndType(name, type, service, subservice, callback) {
    const devices = _.values(registeredDevices[service]);
    let device;

    for (let i = 0; i < devices.length; i++) {
        if (devices[i].name === name) {
            if (type) {
                if (devices[i].type === type) {
                    device = devices[i];
                }
            } else {
                device = devices[i];
            }
        }
    }

    if (device) {
        callback(null, device);
    } else {
        callback(new errors.DeviceNotFound(name));
    }
}

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

function update(previousDevice, device, callback) {
    registeredDevices[device.service][device.id] = deepClone(device);
    callback(null, device);
}

function clear(callback) {
    registeredDevices = {};

    callback();
}

function getDevicesByAttribute(name, value, service, subservice, callback) {
    let devices;
    const resultDevices = [];

    if (service) {
        devices = _.values(registeredDevices[service]);
    } else {
        devices = _.flatten(_.values(registeredDevices).map(_.values));
    }

    for (let i = 0; i < devices.length; i++) {
        if (devices[i][name] === value) {
            resultDevices.push(devices[i]);
        }
    }

    if (resultDevices.length > 0) {
        callback(null, resultDevices);
    } else {
        callback(new errors.DeviceNotFound(''));
    }
}

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 (data) {
                    data.lastMeasure = measure;
                }
                if (callback) {
                    callback(null, data);
                }
            }
        );
    }
}

exports.getDevicesByAttribute = getDevicesByAttribute;
exports.store = storeDevice;
exports.storeLastMeasure = storeLastMeasure;
exports.update = update;
exports.remove = removeDevice;
exports.list = listDevices;
exports.get = getDevice;
exports.getSilently = getDevice;
exports.getByName = getByName;
exports.getByNameAndType = getByNameAndType;
exports.clear = 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	/* eslint-disable no-prototype-builtins */
25
26	let registeredDevices = {};	1✔
27	const logger = require('logops');	1✔
28	const errors = require('../../errors');	1✔
29	const _ = require('underscore');	1✔
30	const context = {	1✔
31	op: 'IoTAgentNGSI.InMemoryDeviceRegister'
32	};
33
34	function deepClone(device) {
35	const initialClone = _.clone(device);	530✔
36
37	for (const i in device) {	530✔
38	if (device.hasOwnProperty(i) && Array.isArray(device[i])) {	9,920✔
39	initialClone[i] = device[i].map(_.clone);	2,264✔
40	}
41	}
42
43	return initialClone;	530✔
44	}
45
46	/**
47	* Create a new register for a device. The device object should contain the id, type and registrationId
48	*
49	* @param {Object} newDevice Device object to be stored
50	*/
51	function storeDevice(newDevice, callback) {
52	if (!registeredDevices[newDevice.service]) {	473✔
53	registeredDevices[newDevice.service] = {};	296✔
54	}
55
56	if (registeredDevices[newDevice.service][newDevice.id]) {	473!
57	callback(new errors.DuplicateDeviceId(newDevice));	×
58	} else {
59	registeredDevices[newDevice.service][newDevice.id] = deepClone(newDevice);	473✔
60	registeredDevices[newDevice.service][newDevice.id].creationDate = Date.now();	473✔
61
62	logger.debug(context, 'Storing device with id [%s] and type [%s]', newDevice.id, newDevice.type);	473✔
63	callback(null, newDevice);	473✔
64	}
65	}
66
67	/**
68	* Remove the device identified by its id and service.
69	*
70	* @param {String} id Device ID of the device to remove.
71	* @param {String} service Service of the device to remove.
72	* @param {String} subservice Subservice inside the service for the removed device.
73	*/
74	function removeDevice(id, apikey, service, subservice, callback) {
75	const services = Object.keys(registeredDevices);	16✔
76
77	for (let i = 0; i < services.length; i++) {	16✔
78	if (registeredDevices[services[i]][id]) {	16!
79	logger.debug(context, 'Removing device with id [%s] from service [%s].', id, services[i]);	16✔
80	delete registeredDevices[services[i]][id];	16✔
81	}
82	}
83
84	callback(null);	16✔
85	}
86
87	/**
88	* Function to filter all the devices belonging to a service and subservice.
89	*
90	* @param {String} service Service name to use in the filtering.
91	* @param {String} subservice Subservice name to use in the filtering.
92	* @return {Function} List of all the devices belonging to the given service and subservice.
93	*/
94	function getDevicesByService(service, subservice) {
95	if (registeredDevices[service]) {	68✔
96	return Object.keys(registeredDevices[service]).filter(function filterByService(item) {	66✔
97	if (subservice) {	138!
98	return registeredDevices[service][item].subservice === subservice;	138✔
99	}
100	return true;	×
101	});
102	}
103	return [];	2✔
104	}
105
106	/**
107	* Return the list of currently registered devices (via callback).
108	*
109	* @param {String} service Service for which the entries will be returned.
110	* @param {String} subservice Subservice for which the entries will be listed.
111	* @param {Number} limit Maximum number of entries to return.
112	* @param {Number} offset Number of entries to skip for pagination.
113	*/
114	function listDevices(type, service, subservice, limit, offset, callback) {
115	const result = [];	68✔
116	let skipped = 0;	68✔
117	const deviceList = getDevicesByService(service, subservice);	68✔
118
119	let countNumber = deviceList.length;	68✔
120	for (const i in deviceList) {	68✔
121	if (registeredDevices[service].hasOwnProperty(deviceList[i])) {	110!
122	if (offset && skipped < parseInt(offset, 10)) {	110✔
123	skipped++;	6✔
124	} else if (type && registeredDevices[service][deviceList[i]].type === type) {	104!
125	result.push(registeredDevices[service][deviceList[i]]);	×
126	} else if (type) {	104!
127	countNumber--;	×
128	} else {
129	result.push(registeredDevices[service][deviceList[i]]);	104✔
130	}
131
132	if (limit && result.length === parseInt(limit, 10)) {	110✔
133	break;	4✔
134	}
135	}
136	}
137
138	callback(null, {	68✔
139	count: countNumber,
140	devices: result
141	});
142	}
143
144	function getDevice(id, apikey, service, subservice, callback) {
145	if (registeredDevices[service] && registeredDevices[service][id]) {	708✔
146	callback(null, registeredDevices[service][id]);	128✔
147	} else {
148	callback(new errors.DeviceNotFound(id));	580✔
149	}
150	}
151
152	function getByNameAndType(name, type, service, subservice, callback) {
153	const devices = _.values(registeredDevices[service]);	67✔
154	let device;
155
156	for (let i = 0; i < devices.length; i++) {	67✔
157	if (devices[i].name === name) {	76✔
158	if (type) {	67✔
159	if (devices[i].type === type) {	17!
160	device = devices[i];	17✔
161	}
162	} else {
163	device = devices[i];	50✔
164	}
165	}
166	}
167
168	if (device) {	67!
169	callback(null, device);	67✔
170	} else {
171	callback(new errors.DeviceNotFound(name));	×
172	}
173	}
174
175	function getByName(name, service, subservice, callback) {
176	getByNameAndType(name, null, service, subservice, callback);	45✔
177	}
178
179	function update(previousDevice, device, callback) {
180	registeredDevices[device.service][device.id] = deepClone(device);	57✔
181	callback(null, device);	57✔
182	}
183
184	function clear(callback) {
185	registeredDevices = {};	731✔
186
187	callback();	731✔
188	}
189
190	function getDevicesByAttribute(name, value, service, subservice, callback) {
191	let devices;
192	const resultDevices = [];	3✔
193
194	if (service) {	3✔
195	devices = _.values(registeredDevices[service]);	2✔
196	} else {
197	devices = _.flatten(_.values(registeredDevices).map(_.values));	1✔
198	}
199
200	for (let i = 0; i < devices.length; i++) {	3✔
201	if (devices[i][name] === value) {	24✔
202	resultDevices.push(devices[i]);	10✔
203	}
204	}
205
206	if (resultDevices.length > 0) {	3!
207	callback(null, resultDevices);	3✔
208	} else {
209	callback(new errors.DeviceNotFound(''));	×
210	}
211	}
212
213	function storeLastMeasure(measure, typeInformation, callback) {
214	if (	289✔
215	typeInformation &&	825✔
216	typeInformation.id &&
217	typeInformation.apikey &&
218	typeInformation.service &&
219	typeInformation.subservice
220	) {
221	getDevice(	80✔
222	typeInformation.id,
223	typeInformation.apikey,
224	typeInformation.service,
225	typeInformation.subservice,
226	function (error, data) {
227	if (data) {	80!
NEW 228	data.lastMeasure = measure;	×
229	}
230	if (callback) {	80!
231	callback(null, data);	80✔
232	}
233	}
234	);
235	}
236	}
237
238	exports.getDevicesByAttribute = getDevicesByAttribute;	1✔
239	exports.store = storeDevice;	1✔
240	exports.storeLastMeasure = storeLastMeasure;	1✔
241	exports.update = update;	1✔
242	exports.remove = removeDevice;	1✔
243	exports.list = listDevices;	1✔
244	exports.get = getDevice;	1✔
245	exports.getSilently = getDevice;	1✔
246	exports.getByName = getByName;	1✔
247	exports.getByNameAndType = getByNameAndType;	1✔
248	exports.clear = clear;	1✔

telefonicaid / iotagent-node-lib / 11917675559

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