7197844849

Committed 13 Dec 2023 04:02PM UTC coverage: 77.39% (-1.0%) from 78.359%

Build # 7197844849

Build Type

Pull #793

github

Committed by

web-flow

Commit Message

Merge 8edac44f5 into 8bdba961a

Pull Request Pull Request #793: use transport and endpoint from group

Run Details

411 of 599 branches covered (0.0%)

Branch coverage included in aggregate %.

8 of 11 new or added lines in 3 files covered. (72.73%)

11 existing lines in 3 files now uncovered.

876 of 1064 relevant lines covered (82.33%)

113.55 hits per line

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

72.54

/lib/iotaUtils.js

/*
 * Copyright 2016 Telefonica Investigación y Desarrollo, S.A.U
 *
 * This file is part of iotagent-json
 *
 * iotagent-json 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.
 *
 * iotagent-json 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 iotagent-json.
 * If not, seehttp://www.gnu.org/licenses/.
 *
 * For those usages not covered by the GNU Affero General Public License
 * please contact with::[contacto@tid.es]
 */

const iotAgentLib = require('iotagent-node-lib');
const errors = require('./errors');
const dateFormat = require('dateformat');
const async = require('async');
const apply = async.apply;
const constants = require('./constants');
const context = {
    op: 'IoTAgentJSON.Utils'
};
const config = require('./configService');

/**
 * Get the API Key for the selected service if there is any, or the default API Key if a specific one does not exist.
 *
 * @param {String} service          Name of the service whose API Key we are retrieving.
 * @param {String} subservice       Name of the subservice whose API Key we are retrieving.
 * @param {Json} device             Device object.
 */
function getEffectiveApiKey(service, subservice, device, callback) {
    config.getLogger().debug(context, 'Getting effective API Key');

    if (device && device.apikey) {
        config.getLogger().debug(context, 'Using device apikey: %s', device.apikey);
        callback(null, device.apikey);
    } else {
        const type = device.type ? device.type : null;
        iotAgentLib.findConfiguration(service, subservice, type, function (error, group) {
            if (group) {
                config.getLogger().debug(context, 'Using found group: %j', group);
                callback(null, group.apikey);
            } else if (config.getConfig().defaultKey) {
                config.getLogger().debug(context, 'Using default API Key: %s', config.getConfig().defaultKey);
                callback(null, config.getConfig().defaultKey);
            } else {
                config.getLogger().error(context, 'Could not find any API Key information for device.');
                callback(new errors.GroupNotFound(service, subservice));
            }
        });
    }
}

function manageConfiguration(apiKey, deviceId, device, objMessage, sendFunction, callback) {
    /* eslint-disable no-unused-vars */
    function handleSendConfigurationError(error, results) {
        if (error) {
            config.getLogger().error(
                context,

                "CONFIG-001: Couldn't get the requested values from the Context Broker: %s",

                error
            );
        } else {
            config
                .getLogger()
                .debug(context, 'Configuration attributes sent to the device successfully.', deviceId, apiKey);
        }

        callback(error);
    }

    if (objMessage.type === 'configuration') {
        async.waterfall(
            [
                apply(iotAgentLib.query, device.name, device.type, '', objMessage.fields, device),
                apply(sendFunction, apiKey, {}, deviceId)
            ],
            handleSendConfigurationError
        );
    } else if (objMessage.type === 'subscription') {
        iotAgentLib.subscribe(device, objMessage.fields, objMessage.fields, function (error) {
            if (error) {
                config
                    .getLogger()
                    .error(
                        context,
                        'CONFIG-002: There was an error subscribing device %s to attributes %j',
                        device.name,
                        objMessage.fields
                    );
            } else {
                config
                    .getLogger()
                    .debug(
                        context,
                        'Successfully subscribed device %s to attributes %j',
                        device.name,
                        objMessage.fields
                    );
            }

            callback(error);
        });
    } else {
        config.getLogger().error(context, 'CONFIG-003: Unknown command type from device %s', device.name);
        callback();
    }
}

function createConfigurationNotification(results) {
    const configurations = {};
    const now = new Date();

    // If it is the result of a subscription, results is an array
    if (Array.isArray(results)) {
        for (let i = 0; i < results.length; i++) {
            configurations[results[i].name] = results[i].value;
        }
    } else {
        for (var att in results) {
            configurations[att] = results[att].value;
        }
    }

    configurations.dt = dateFormat(now, constants.DATE_FORMAT);
    return configurations;
}

function findOrCreate(deviceId, transport, apikey, group, callback) {
    iotAgentLib.getDeviceSilently(deviceId, apikey, group.service, group.subservice, function (error, device) {
        if (!error && device) {
            if (
                (!('apikey' in device) || device.apikey === undefined) &&
                'apikey' in group &&
                group.apikey !== undefined
            ) {
                config
                    .getLogger()
                    .info(context, 'Update provisioned device %j with measure/group apikey %j', device, group.apikey);
                device.apikey = group.apikey; // group apikey is the same of current measure apikey
                iotAgentLib.updateDevice(device, function (error) {
                    callback(error, device, group);
                });
            } else {
                callback(null, device, group);
            }
        } else if (error.name === 'DEVICE_NOT_FOUND') {
            const newDevice = {
                id: deviceId,
                service: group.service,
                subservice: group.subservice,
                type: group.type
            };
            if (
                config.getConfig().iota &&
                config.getConfig().iota.iotManager &&
                config.getConfig().iota.iotManager.protocol
            ) {
                newDevice.protocol = config.getConfig().iota.iotManager.protocol;
            }
            // // Fix transport depending on binding and group
            // if (!newDevice.transport) {
            //     if ('transport' in group && group.transport !== undefined) {
            //          newDevice.transport = group.transport;
            //     } else {
            //         newDevice.transport = transport;
            //     }
            // }
            if ('ngsiVersion' in group && group.ngsiVersion !== undefined) {
                newDevice.ngsiVersion = group.ngsiVersion;
            }
            if (
                (!('apikey' in newDevice) || newDevice.apikey === undefined) &&
                'apikey' in group &&
                group.apikey !== undefined
            ) {
                newDevice.apikey = group.apikey;
            }
            // Check autoprovision flag in order to register or not device
            if (group.autoprovision === undefined || group.autoprovision === true) {
                config
                    .getLogger()
                    .debug(context, 'Registering autoprovision of Device %j for its conf %j', newDevice, group);
                iotAgentLib.register(newDevice, function (error, device) {
                    callback(error, device, group);
                });
            } else {
                config
                    .getLogger()
                    .info(
                        context,
                        'Device %j not provisioned due autoprovision is disabled by its conf %j',
                        newDevice,
                        group
                    );
                callback(new errors.DeviceNotFound(deviceId));
            }
        } else {
            callback(error);
        }
    });
}

/**
 * Retrieve a device from the device repository based on the given APIKey and DeviceID, creating one if none is
 * found for the given data.
 *
 * @param {String} deviceId         Device ID of the device that wants to be retrieved or created.
 * @param {String} apiKey           APIKey of the Device Group (or default APIKey).
 */
function retrieveDevice(deviceId, apiKey, transport, callback) {
    if (apiKey === config.getConfig().defaultKey) {
        iotAgentLib.getDevicesByAttribute('id', deviceId, null, null, function (error, devices) {
            if (error) {
                callback(error);
            } else if (devices && devices.length === 1) {
                callback(null, devices[0]);
            } else {
                config.getLogger().error(
                    context,

                    "MEASURES-001: Couldn't find device data for APIKey %s and DeviceId %s",

                    apiKey,
                    deviceId
                );

                callback(new errors.DeviceNotFound(deviceId));
            }
        });
    } else {
        async.waterfall(
            [
                apply(iotAgentLib.getConfigurationSilently, config.getConfig().iota.defaultResource || '', apiKey),
                apply(findOrCreate, deviceId, transport, apiKey), // group.apikey and apikey are the same
                apply(
                    iotAgentLib.mergeDeviceWithConfiguration,
                    ['lazy', 'active', 'staticAttributes', 'commands', 'subscriptions'],
                    [null, null, [], [], [], [], []]
                )
            ],
            callback
        );
    }
}

exports.createConfigurationNotification = createConfigurationNotification;
exports.getEffectiveApiKey = getEffectiveApiKey;
exports.manageConfiguration = manageConfiguration;
exports.retrieveDevice = retrieveDevice;

1	/*
2	* Copyright 2016 Telefonica Investigación y Desarrollo, S.A.U
3	*
4	* This file is part of iotagent-json
5	*
6	* iotagent-json 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	* iotagent-json 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 iotagent-json.
18	* If not, seehttp://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
24	const iotAgentLib = require('iotagent-node-lib');	1✔
25	const errors = require('./errors');	1✔
26	const dateFormat = require('dateformat');	1✔
27	const async = require('async');	1✔
28	const apply = async.apply;	1✔
29	const constants = require('./constants');	1✔
30	const context = {	1✔
31	op: 'IoTAgentJSON.Utils'
32	};
33	const config = require('./configService');	1✔
34
35	/**
36	* Get the API Key for the selected service if there is any, or the default API Key if a specific one does not exist.
37	*
38	* @param {String} service Name of the service whose API Key we are retrieving.
39	* @param {String} subservice Name of the subservice whose API Key we are retrieving.
40	* @param {Json} device Device object.
41	*/
42	function getEffectiveApiKey(service, subservice, device, callback) {
43	config.getLogger().debug(context, 'Getting effective API Key');	20✔
44
45	if (device && device.apikey) {	20!
46	config.getLogger().debug(context, 'Using device apikey: %s', device.apikey);	×
47	callback(null, device.apikey);	×
48	} else {
49	const type = device.type ? device.type : null;	20!
50	iotAgentLib.findConfiguration(service, subservice, type, function (error, group) {	20✔
51	if (group) {	20✔
52	config.getLogger().debug(context, 'Using found group: %j', group);	1✔
53	callback(null, group.apikey);	1✔
54	} else if (config.getConfig().defaultKey) {	19!
55	config.getLogger().debug(context, 'Using default API Key: %s', config.getConfig().defaultKey);	19✔
56	callback(null, config.getConfig().defaultKey);	19✔
57	} else {
58	config.getLogger().error(context, 'Could not find any API Key information for device.');	×
59	callback(new errors.GroupNotFound(service, subservice));	×
60	}
61	});
62	}
63	}
64
65	function manageConfiguration(apiKey, deviceId, device, objMessage, sendFunction, callback) {
66	/* eslint-disable no-unused-vars */
67	function handleSendConfigurationError(error, results) {
68	if (error) {	6!
69	config.getLogger().error(	×
70	context,
71
72	"CONFIG-001: Couldn't get the requested values from the Context Broker: %s",
73
74	error
75	);
76	} else {
77	config	6✔
78	.getLogger()
79	.debug(context, 'Configuration attributes sent to the device successfully.', deviceId, apiKey);
80	}
81
82	callback(error);	6✔
83	}
84
85	if (objMessage.type === 'configuration') {	8✔
86	async.waterfall(	6✔
87	[
88	apply(iotAgentLib.query, device.name, device.type, '', objMessage.fields, device),
89	apply(sendFunction, apiKey, {}, deviceId)
90	],
91	handleSendConfigurationError
92	);
93	} else if (objMessage.type === 'subscription') {	2!
94	iotAgentLib.subscribe(device, objMessage.fields, objMessage.fields, function (error) {	2✔
95	if (error) {	2!
96	config	×
97	.getLogger()
98	.error(
99	context,
100	'CONFIG-002: There was an error subscribing device %s to attributes %j',
101	device.name,
102	objMessage.fields
103	);
104	} else {
105	config	2✔
106	.getLogger()
107	.debug(
108	context,
109	'Successfully subscribed device %s to attributes %j',
110	device.name,
111	objMessage.fields
112	);
113	}
114
115	callback(error);	2✔
116	});
117	} else {
118	config.getLogger().error(context, 'CONFIG-003: Unknown command type from device %s', device.name);	×
119	callback();	×
120	}
121	}
122
123	function createConfigurationNotification(results) {
124	const configurations = {};	6✔
125	const now = new Date();	6✔
126
127	// If it is the result of a subscription, results is an array
128	if (Array.isArray(results)) {	6!
UNCOV 129	for (let i = 0; i < results.length; i++) {	×
UNCOV 130	configurations[results[i].name] = results[i].value;	×
131	}
132	} else {
133	for (var att in results) {	6✔
134	configurations[att] = results[att].value;	24✔
135	}
136	}
137
138	configurations.dt = dateFormat(now, constants.DATE_FORMAT);	6✔
139	return configurations;	6✔
140	}
141
142	function findOrCreate(deviceId, transport, apikey, group, callback) {
143	iotAgentLib.getDeviceSilently(deviceId, apikey, group.service, group.subservice, function (error, device) {	79✔
144	if (!error && device) {	79✔
145	if (	10!
146	(!('apikey' in device) \|\| device.apikey === undefined) &&	40✔
147	'apikey' in group &&
148	group.apikey !== undefined
149	) {
150	config	10✔
151	.getLogger()
152	.info(context, 'Update provisioned device %j with measure/group apikey %j', device, group.apikey);
153	device.apikey = group.apikey; // group apikey is the same of current measure apikey	10✔
154	iotAgentLib.updateDevice(device, function (error) {	10✔
155	callback(error, device, group);	10✔
156	});
157	} else {
158	callback(null, device, group);	×
159	}
160	} else if (error.name === 'DEVICE_NOT_FOUND') {	69!
161	const newDevice = {	69✔
162	id: deviceId,
163	service: group.service,
164	subservice: group.subservice,
165	type: group.type
166	};
167	if (	69!
168	config.getConfig().iota &&	138!
169	config.getConfig().iota.iotManager &&
170	config.getConfig().iota.iotManager.protocol
171	) {
172	newDevice.protocol = config.getConfig().iota.iotManager.protocol;	×
173	}
174	// // Fix transport depending on binding and group
175	// if (!newDevice.transport) {
176	// if ('transport' in group && group.transport !== undefined) {
177	// newDevice.transport = group.transport;
178	// } else {
179	// newDevice.transport = transport;
180	// }
181	// }
182	if ('ngsiVersion' in group && group.ngsiVersion !== undefined) {	69!
183	newDevice.ngsiVersion = group.ngsiVersion;	×
184	}
185	if (	69!
186	(!('apikey' in newDevice) \|\| newDevice.apikey === undefined) &&	207!
187	'apikey' in group &&
188	group.apikey !== undefined
189	) {
190	newDevice.apikey = group.apikey;	69✔
191	}
192	// Check autoprovision flag in order to register or not device
193	if (group.autoprovision === undefined \|\| group.autoprovision === true) {	69!
194	config	69✔
195	.getLogger()
196	.debug(context, 'Registering autoprovision of Device %j for its conf %j', newDevice, group);
197	iotAgentLib.register(newDevice, function (error, device) {	69✔
198	callback(error, device, group);	69✔
199	});
200	} else {
201	config	×
202	.getLogger()
203	.info(
204	context,
205	'Device %j not provisioned due autoprovision is disabled by its conf %j',
206	newDevice,
207	group
208	);
209	callback(new errors.DeviceNotFound(deviceId));	×
210	}
211	} else {
212	callback(error);	×
213	}
214	});
215	}
216
217	/**
218	* Retrieve a device from the device repository based on the given APIKey and DeviceID, creating one if none is
219	* found for the given data.
220	*
221	* @param {String} deviceId Device ID of the device that wants to be retrieved or created.
222	* @param {String} apiKey APIKey of the Device Group (or default APIKey).
223	*/
224	function retrieveDevice(deviceId, apiKey, transport, callback) {
225	if (apiKey === config.getConfig().defaultKey) {	165✔
226	iotAgentLib.getDevicesByAttribute('id', deviceId, null, null, function (error, devices) {	86✔
227	if (error) {	86!
228	callback(error);	×
229	} else if (devices && devices.length === 1) {	86!
230	callback(null, devices[0]);	86✔
231	} else {
232	config.getLogger().error(	×
233	context,
234
235	"MEASURES-001: Couldn't find device data for APIKey %s and DeviceId %s",
236
237	apiKey,
238	deviceId
239	);
240
241	callback(new errors.DeviceNotFound(deviceId));	×
242	}
243	});
244	} else {
245	async.waterfall(	79✔
246	[
247	apply(iotAgentLib.getConfigurationSilently, config.getConfig().iota.defaultResource \|\| '', apiKey),	79!
248	apply(findOrCreate, deviceId, transport, apiKey), // group.apikey and apikey are the same
249	apply(
250	iotAgentLib.mergeDeviceWithConfiguration,
251	['lazy', 'active', 'staticAttributes', 'commands', 'subscriptions'],
252	[null, null, [], [], [], [], []]
253	)
254	],
255	callback
256	);
257	}
258	}
259
260	exports.createConfigurationNotification = createConfigurationNotification;	1✔
261	exports.getEffectiveApiKey = getEffectiveApiKey;	1✔
262	exports.manageConfiguration = manageConfiguration;	1✔
263	exports.retrieveDevice = retrieveDevice;	1✔

telefonicaid / iotagent-json / 7197844849

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