iotagent-node-lib 2.18.0 → 2.21.0

package/lib/services/devices/deviceService.js

@@ -214,7 +214,13 @@ function findConfigurationGroup(deviceObj, callback) {
     } else {
         config
             .getGroupRegistry()
-            .findTypeSilently(deviceObj.service, deviceObj.subservice, deviceObj.type, deviceObj.apikey, handlerGroupFindByType);
+            .findTypeSilently(
+                deviceObj.service,
+                deviceObj.subservice,
+                deviceObj.type,
+                deviceObj.apikey,
+                handlerGroupFindByType
+            );
     }
 }
 
@@ -513,6 +519,18 @@ function getDeviceByName(deviceName, service, subservice, callback) {
     config.getRegistry().getByName(deviceName, service, subservice, callback);
 }
 
+/**
+ * Retrieve a device from the registry based on its entity name and type
+ *
+ * @param {String} deviceName       Name of the entity associated to a device.
+ * @param {String} deviceType       Type of the entity associated to a device.
+ * @param {String} service          Service the device belongs to.
+ * @param {String} subservice       Division inside the service.
+ */
+function getDeviceByNameAndType(deviceName, deviceType, service, subservice, callback) {
+    config.getRegistry().getByNameAndType(deviceName, deviceType, service, subservice, callback);
+}
+
 /**
  * Retrieve a device from the registry based on the value of a given attribute.
  *
@@ -581,7 +599,12 @@ function findOrCreate(deviceId, group, callback) {
                     callback(error, device, group);
                 });
             } else {
-                logger.info(context, 'Device %j not provisioned due autoprovision is disabled by its conf %j', newDevice, group);
+                logger.info(
+                    context,
+                    'Device %j not provisioned due autoprovision is disabled by its conf %j',
+                    newDevice,
+                    group
+                );
                 callback(new errors.DeviceNotFound(deviceId));
             }
         } else {
@@ -632,6 +655,7 @@ exports.getDevice = intoTrans(context, checkRegistry)(getDevice);
 exports.getDeviceSilently = intoTrans(context, checkRegistry)(getDeviceSilently);
 exports.getDevicesByAttribute = intoTrans(context, checkRegistry)(getDevicesByAttribute);
 exports.getDeviceByName = intoTrans(context, checkRegistry)(getDeviceByName);
+exports.getDeviceByNameAndType = intoTrans(context, checkRegistry)(getDeviceByNameAndType);
 exports.register = intoTrans(context, registerDevice);
 exports.updateRegister = intoTrans(context, updateRegisterDevice);
 exports.unregister = intoTrans(context, unregisterDevice);

package/lib/services/devices/devices-NGSI-LD.js

@@ -23,7 +23,7 @@
  * Modified by: Jason Fox - FIWARE Foundation
  */
 
-const request = require('request');
+const request = require('../../request-shim');
 const async = require('async');
 const apply = async.apply;
 const constants = require('../../constants');

package/lib/services/devices/devices-NGSI-v2.js

@@ -27,7 +27,7 @@
 
 /* eslint-disable consistent-return */
 
-const request = require('request');
+const request = require('../../request-shim');
 const async = require('async');
 const apply = async.apply;
 const uuid = require('uuid');
@@ -112,11 +112,7 @@ function createInitialEntityHandlerNgsi2(deviceData, newDevice, callback) {
 function updateEntityHandlerNgsi2(deviceData, updatedDevice, callback) {
     return function handleEntityResponse(error, response, body) {
         if (error) {
-            logger.error(
-                context,
-                'ORION-001: Connection error updating entity in the Context Broker: %s',
-                error
-            );
+            logger.error(context, 'ORION-001: Connection error updating entity in the Context Broker: %s', error);
 
             alarms.raise(constants.ORION_ALARM, error);
 

package/lib/services/devices/registrationUtils.js

@@ -136,7 +136,6 @@ function sendUnregistrationsNgsi2(deviceData, callback) {
     const options = {
         url: cbHost + '/v2/registrations/' + deviceData.registrationId,
         method: 'DELETE',
-        json: true,
         headers: {
             'fiware-service': deviceData.service,
             'fiware-servicepath': deviceData.subservice
@@ -177,7 +176,6 @@ function sendUnregistrationsNgsiLD(deviceData, callback) {
     const options = {
         url: cbHost + '/ngsi-ld/v1/csourceRegistrations/' + deviceData.registrationId,
         method: 'DELETE',
-        json: true,
         headers: {
             'fiware-service': deviceData.service,
             'fiware-servicepath': deviceData.subservice,

package/lib/services/ngsi/entities-NGSI-LD.js

@@ -25,7 +25,7 @@
 
 /* eslint-disable consistent-return */
 
-const request = require('request');
+const request = require('../../request-shim');
 const statsService = require('./../stats/statsRegistry');
 const async = require('async');
 const apply = async.apply;
@@ -34,6 +34,7 @@ const errors = require('../../errors');
 const utils = require('../northBound/restUtils');
 const config = require('../../commonConfig');
 const constants = require('../../constants');
+const jexlParser = require('../../plugins/jexlParser');
 const moment = require('moment-timezone');
 const logger = require('logops');
 const _ = require('underscore');
@@ -55,8 +56,9 @@ const NGSI_LD_URN = 'urn:ngsi-ld:';
  *                                   format
  */
 
-function convertNGSIv2ToLD(attr) {
-    if (attr.value === null) {
+function convertAttrNGSILD(attr) {
+    // eslint eqeqeq - deliberate double equals to include undefined.
+    if (attr.value == null || Number.isNaN(attr.value)) {
         return undefined;
     }
     let obj = { type: 'Property', value: attr.value };
@@ -178,7 +180,7 @@ function convertNGSIv2ToLD(attr) {
                     obj.unitCode = attr.metadata[key].value;
                     break;
                 default:
-                    obj[key] = convertNGSIv2ToLD(attr.metadata[key]);
+                    obj[key] = convertAttrNGSILD(attr.metadata[key]);
             }
         });
         delete obj.TimeInstant;
@@ -214,7 +216,7 @@ function formatAsNGSILD(json) {
                 // element for NSGI-LD.
                 break;
             default:
-                obj[key] = convertNGSIv2ToLD(json[key]);
+                obj[key] = convertAttrNGSILD(json[key]);
         }
     });
 
@@ -329,7 +331,6 @@ function sendQueryValueNgsiLD(entityName, attributes, typeInformation, token, ca
 
     const options = NGSIUtils.createRequestObject(url, typeInformation, token);
     options.method = 'GET';
-    options.json = true;
 
     if (!typeInformation || !typeInformation.type) {
         callback(new errors.TypeNotFound(null, entityName));
@@ -402,6 +403,92 @@ function addLinkedEntities(typeInformation, json) {
     });
 }
 
+/**
+ * Remove id, type and any hidden attrs after processing
+ *
+ * @param {Object} enities           Unprocessed entities
+ * @param {Object} typeInformation  Configuration information for the device.
+ */
+function removeHiddenAttrsFromMultiEntity(entities, typeInformation) {
+    let explicitAttrsList;
+    if (typeInformation.explicitAttrs) {
+        explicitAttrsList = [];
+        explicitAttrsList.push('type');
+        explicitAttrsList.push('id');
+        if (typeof typeInformation.explicitAttrs === 'boolean') {
+            if (typeInformation.timestamp) {
+                explicitAttrsList.push(constants.TIMESTAMP_ATTRIBUTE);
+            }
+            if (typeInformation.active) {
+                typeInformation.active.forEach((attr) => {
+                    explicitAttrsList.push(attr.name);
+                });
+            }
+            if (typeInformation.staticAttributes) {
+                typeInformation.staticAttributes.forEach((attr) => {
+                    explicitAttrsList.push(attr.name);
+                });
+            }
+        } else if (typeof typeInformation.explicitAttrs === 'string') {
+            entities.forEach((entity) => {
+                const attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
+                const ctx = jexlParser.extractContext(attsArray);
+                const res = jexlParser.parse(typeInformation.explicitAttrs, ctx);
+                explicitAttrsList = explicitAttrsList.concat(res);
+            });
+        }
+    }
+    if (explicitAttrsList && explicitAttrsList.length >= 0) {
+        entities.forEach((entity) => {
+            const hidden = _.difference(_.keys(entity), explicitAttrsList);
+            hidden.forEach((attr) => {
+                delete entity[attr];
+            });
+        });
+    }
+    return entities;
+}
+
+/**
+ * Remove id, type and any hidden attrs after processing
+ *
+ * @param {Object} result           Unprocessed entity
+ * @param {Object} typeInformation  Configuration information for the device.
+ */
+function removeHiddenAttrs(result, typeInformation) {
+    delete result.id;
+    delete result.type;
+    let explicitAttrsList;
+    if (typeInformation.explicitAttrs && typeof typeInformation.explicitAttrs === 'boolean') {
+        explicitAttrsList = [];
+        if (typeInformation.timestamp) {
+            explicitAttrsList.push(constants.TIMESTAMP_ATTRIBUTE);
+        }
+        if (typeInformation.active) {
+            typeInformation.active.forEach((attr) => {
+                explicitAttrsList.push(attr.name);
+            });
+        }
+        if (typeInformation.staticAttributes) {
+            typeInformation.staticAttributes.forEach((attr) => {
+                explicitAttrsList.push(attr.name);
+            });
+        }
+    } else if (typeInformation.explicitAttrs && typeof typeInformation.explicitAttrs === 'string') {
+        const attsArray = utils.extractAttributesArrayFromNgsi2Entity(result);
+        const ctx = jexlParser.extractContext(attsArray);
+        const res = jexlParser.parse(typeInformation.explicitAttrs, ctx);
+        explicitAttrsList = res;
+    }
+    if (explicitAttrsList && explicitAttrsList.length >= 0) {
+        const hidden = _.difference(_.keys(result), explicitAttrsList);
+        hidden.forEach((attr) => {
+            delete result[attr];
+        });
+    }
+    return result;
+}
+
 /**
  * Makes an update in the Device's entity in the context broker, with the values given in the 'attributes' array.
  * This array should comply to the NGSI-LD's attribute format.
@@ -413,7 +500,6 @@ function addLinkedEntities(typeInformation, json) {
  */
 function sendUpdateValueNgsiLD(entityName, attributes, typeInformation, token, callback) {
     let payload = {};
-
     const url = '/ngsi-ld/v1/entityOperations/upsert/?options=update';
 
     const options = NGSIUtils.createRequestObject(url, typeInformation, token);
@@ -474,11 +560,10 @@ function sendUpdateValueNgsiLD(entityName, attributes, typeInformation, token, c
                             }
                         }
 
-                        options.json = result;
+                        options.json = removeHiddenAttrsFromMultiEntity(result, typeInformation);
                     } else {
-                        delete result.id;
-                        delete result.type;
-                        options.json = result;
+                        // Remove id, type and any hidden attrs after processing
+                        options.json = removeHiddenAttrs(result, typeInformation);
                         logger.debug(context, 'typeInformation: %j', typeInformation);
                         if (
                             'timestamp' in typeInformation && typeInformation.timestamp !== undefined
@@ -567,6 +652,7 @@ function sendUpdateValueNgsiLD(entityName, attributes, typeInformation, token, c
     );
 }
 
+exports.convertAttrNGSILD = convertAttrNGSILD;
 exports.formatAsNGSILD = formatAsNGSILD;
 exports.sendUpdateValue = sendUpdateValueNgsiLD;
 exports.sendQueryValue = sendQueryValueNgsiLD;

package/lib/services/ngsi/entities-NGSI-v2.js

@@ -27,21 +27,24 @@
 
 /* eslint-disable consistent-return */
 
-const request = require('request');
+const request = require('../../request-shim');
 const statsService = require('./../stats/statsRegistry');
 const async = require('async');
 const apply = async.apply;
 const alarms = require('../common/alarmManagement');
 const errors = require('../../errors');
 const utils = require('../northBound/restUtils');
+const pluginUtils = require('../../plugins/pluginUtils');
 const config = require('../../commonConfig');
 const constants = require('../../constants');
+const jexlParser = require('../../plugins/jexlParser');
 const moment = require('moment-timezone');
 const NGSIUtils = require('./ngsiUtils');
 const logger = require('logops');
 const context = {
     op: 'IoTAgentNGSI.Entities-v2'
 };
+const _ = require('underscore');
 
 /**
  * Amends an NGSIv2 Geoattribute from String to GeoJSON format
@@ -290,7 +293,6 @@ function sendQueryValueNgsi2(entityName, attributes, typeInformation, token, cal
 
     const options = NGSIUtils.createRequestObject(url, typeInformation, token);
     options.method = 'GET';
-    options.json = true;
 
     if (!typeInformation || !typeInformation.type) {
         callback(new errors.TypeNotFound(null, entityName));
@@ -312,6 +314,94 @@ function sendQueryValueNgsi2(entityName, attributes, typeInformation, token, cal
     );
 }
 
+/**
+ * Remove id, type and any hidden attrs after processing
+ *
+ * @param {Object} enities           Unprocessed entities
+ * @param {Object} typeInformation  Configuration information for the device.
+ */
+function removeHiddenAttrsFromMultiEntity(entities, typeInformation) {
+    let explicitAttrsList;
+    if (typeInformation.explicitAttrs) {
+        explicitAttrsList = [];
+        explicitAttrsList.push('type');
+        explicitAttrsList.push('id');
+        if (typeof typeInformation.explicitAttrs === 'boolean') {
+            if (typeInformation.timestamp) {
+                explicitAttrsList.push(constants.TIMESTAMP_ATTRIBUTE);
+            }
+
+            if (typeInformation.active) {
+                typeInformation.active.forEach((attr) => {
+                    explicitAttrsList.push(attr.name);
+                });
+            }
+            if (typeInformation.staticAttributes) {
+                typeInformation.staticAttributes.forEach((attr) => {
+                    explicitAttrsList.push(attr.name);
+                });
+            }
+        } else if (typeof typeInformation.explicitAttrs === 'string') {
+            entities.forEach((entity) => {
+                const attsArray = pluginUtils.extractAttributesArrayFromNgsi2Entity(entity);
+                const ctx = jexlParser.extractContext(attsArray);
+                const res = jexlParser.applyExpression(typeInformation.explicitAttrs, ctx, typeInformation);
+                explicitAttrsList = explicitAttrsList.concat(res);
+            });
+        }
+    }
+    if (explicitAttrsList && explicitAttrsList.length >= 0) {
+        entities.forEach((entity) => {
+            const hidden = _.difference(_.keys(entity), explicitAttrsList);
+            logger.debug(context, 'removeHiddenAttrsFromMultiEntity %s from entity %s', hidden, entity);
+            hidden.forEach((attr) => {
+                delete entity[attr];
+            });
+        });
+    }
+    return entities;
+}
+/**
+ * Remove id, type and any hidden attrs after processing
+ *
+ * @param {Object} result           An Unprocessed entity
+ * @param {Object} typeInformation  Configuration information for the device.
+ */
+function removeHiddenAttrs(result, typeInformation) {
+    delete result.id;
+    delete result.type;
+    let explicitAttrsList;
+    if (typeInformation.explicitAttrs && typeof typeInformation.explicitAttrs === 'boolean') {
+        explicitAttrsList = [];
+        if (typeInformation.timestamp) {
+            explicitAttrsList.push(constants.TIMESTAMP_ATTRIBUTE);
+        }
+        if (typeInformation.active) {
+            typeInformation.active.forEach((attr) => {
+                explicitAttrsList.push(attr.name);
+            });
+        }
+        if (typeInformation.staticAttributes) {
+            typeInformation.staticAttributes.forEach((attr) => {
+                explicitAttrsList.push(attr.name);
+            });
+        }
+    } else if (typeInformation.explicitAttrs && typeof typeInformation.explicitAttrs === 'string') {
+        const attsArray = pluginUtils.extractAttributesArrayFromNgsi2Entity(result);
+        const ctx = jexlParser.extractContext(attsArray);
+        const res = jexlParser.applyExpression(typeInformation.explicitAttrs, ctx, typeInformation);
+        explicitAttrsList = res;
+    }
+    if (explicitAttrsList && explicitAttrsList.length >= 0) {
+        const hidden = _.difference(_.keys(result), explicitAttrsList);
+        logger.debug(context, 'removeHiddenAttrs %s', hidden);
+        hidden.forEach((attr) => {
+            delete result[attr];
+        });
+    }
+    return result;
+}
+
 /**
  * Makes an update in the Device's entity in the context broker, with the values given in the 'attributes' array. This
  * array should comply to the NGSIv2's attribute format.
@@ -326,7 +416,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
 
     let url = '/v2/entities/' + entityName + '/attrs';
 
-    if (typeInformation.type) {
+    if (typeInformation && typeInformation.type) {
         url += '?type=' + typeInformation.type;
     }
 
@@ -359,7 +449,6 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
     //overwritte if id or type missnamed atributes reach this point
     payload.id = entityName;
     payload.type = typeInformation.type;
-
     payload = NGSIUtils.castJsonNativeAttributes(payload);
     async.waterfall(
         [
@@ -392,7 +481,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                         }
                         options.json = {
                             actionType: 'append',
-                            entities: result
+                            entities: removeHiddenAttrsFromMultiEntity(result, typeInformation)
                         };
                         if (config.getConfig().appendMode === true) {
                             options.json.actionType = 'append';
@@ -400,9 +489,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                             options.json.actionType = 'update';
                         }
                     } else {
-                        delete result.id;
-                        delete result.type;
-                        options.json = result;
+                        options.json = removeHiddenAttrs(result, typeInformation);
                         logger.debug(context, 'typeInformation: %j', typeInformation);
                         if (
                             'timestamp' in typeInformation && typeInformation.timestamp !== undefined

package/lib/services/ngsi/ngsiService.js

@@ -132,9 +132,10 @@ function executeWithDeviceInformation(operationFunction) {
             attributes,
             deviceInformation
         );
-        config.getGroupRegistry().getType(type, function (error, deviceGroup) {
+        const currentType = type ? type : deviceInformation.type;
+        config.getGroupRegistry().getType(currentType, function (error, deviceGroup) {
             let typeInformation;
-            const configDeviceInfo = config.getConfig().types[type];
+            const configDeviceInfo = config.getConfig().types[currentType];
             if (error) {
                 logger.debug(context, 'error %j in get group device', error);
             }
@@ -176,7 +177,7 @@ function executeWithDeviceInformation(operationFunction) {
 
 /**
  * Update the result of a command in the Context Broker. The result of the command has two components: the result
- * of the command itself will be represented with the sufix '_result' in the entity while the status is updated in the
+ * of the command itself will be represented with the sufix '_info' in the entity while the status is updated in the
  * attribute with the '_status' sufix.
  *
  * @param {String} entityName           Name of the entity holding the command.
@@ -233,7 +234,7 @@ function setCommandResult(
         }
 
         if (commandInfo.length === 1) {
-            exports.update(entityName, resource, apikey, attributes, typeInformation, callback);
+            exports.update(entityName, typeInformation.type, apikey, attributes, typeInformation, callback);
         } else {
             callback(new errors.CommandNotFound(commandName));
         }

package/lib/services/northBound/contextServer-NGSI-LD.js

@@ -40,6 +40,7 @@ const context = {
 const updateContextTemplateNgsiLD = require('../../templates/updateContextNgsiLD.json');
 const notificationTemplateNgsiLD = require('../../templates/notificationTemplateNgsiLD.json');
 const contextServerUtils = require('./contextServerUtils');
+const ngsiLD = require('../ngsi/entities-NGSI-LD');
 
 const updatePaths = ['/ngsi-ld/v1/entities/:entity/attrs/:attr'];
 const queryPaths = ['/ngsi-ld/v1/entities/:entity'];
@@ -250,10 +251,10 @@ function defaultQueryHandlerNgsiLD(id, type, service, subservice, attributes, ca
                     attributeType = lazyAttribute.type;
                 }
 
-                contextElement[attributes[i]] = {
+                contextElement[attributes[i]] = ngsiLD.convertAttrNGSILD({
                     type: attributeType,
                     value: ''
-                };
+                });
             }
 
             callback(null, contextElement);

package/lib/services/northBound/contextServer-NGSI-v2.js

@@ -159,29 +159,32 @@ function generateUpdateActionsNgsi2(req, contextElement, callback) {
         callback(null, updateActions);
     }
 
-    deviceService.getDeviceByName(entityId, req.headers['fiware-service'], req.headers['fiware-servicepath'], function (
-        error,
-        deviceObj
-    ) {
-        if (error) {
-            callback(error);
-        } else {
-            async.waterfall(
-                [
-                    apply(deviceService.findConfigurationGroup, deviceObj),
-                    apply(
-                        deviceService.mergeDeviceWithConfiguration,
-                        ['lazy', 'internalAttributes', 'active', 'staticAttributes', 'commands', 'subscriptions'],
-                        [null, null, [], [], [], [], []],
-                        deviceObj
-                    ),
-                    splitUpdates,
-                    createActionsArray
-                ],
-                callback
-            );
+    deviceService.getDeviceByNameAndType(
+        entityId,
+        entityType,
+        req.headers['fiware-service'],
+        req.headers['fiware-servicepath'],
+        function (error, deviceObj) {
+            if (error) {
+                callback(error);
+            } else {
+                async.waterfall(
+                    [
+                        apply(deviceService.findConfigurationGroup, deviceObj),
+                        apply(
+                            deviceService.mergeDeviceWithConfiguration,
+                            ['lazy', 'internalAttributes', 'active', 'staticAttributes', 'commands', 'subscriptions'],
+                            [null, null, [], [], [], [], []],
+                            deviceObj
+                        ),
+                        splitUpdates,
+                        createActionsArray
+                    ],
+                    callback
+                );
+            }
         }
-    });
+    );
 }
 
 /** Express middleware to manage incoming update requests using NGSIv2.
@@ -238,8 +241,7 @@ function defaultQueryHandlerNgsi2(id, type, service, subservice, attributes, cal
         type,
         id
     };
-
-    deviceService.getDeviceByName(id, service, subservice, function (error, ngsiDevice) {
+    deviceService.getDeviceByNameAndType(id, type, service, subservice, function (error, ngsiDevice) {
         if (error) {
             callback(error);
         } else {
@@ -285,8 +287,9 @@ function handleNotificationNgsi2(req, res, next) {
                 }
             }
         }
-        deviceService.getDeviceByName(
+        deviceService.getDeviceByNameAndType(
             dataElement.id,
+            dataElement.type,
             req.headers['fiware-service'],
             req.headers['fiware-servicepath'],
             function (error, device) {
@@ -448,6 +451,7 @@ function handleQueryNgsi2(req, res, next) {
         }
 
         deviceService.findConfigurationGroup(device, function (error, group) {
+            logger.debug(context, 'finishQueryForDevice %j', group);
             const executeCompleteAttributes = apply(completeAttributes, attributes, group);
             const executeQueryHandler = apply(
                 actualHandler,
@@ -474,8 +478,9 @@ function handleQueryNgsi2(req, res, next) {
 
         if (contextEntity.id) {
             getFunction = apply(
-                deviceService.getDeviceByName,
+                deviceService.getDeviceByNameAndType,
                 contextEntity.id,
+                contextEntity.type,
                 req.headers['fiware-service'],
                 req.headers['fiware-servicepath']
             );
@@ -504,7 +509,7 @@ function handleQueryNgsi2(req, res, next) {
             } else {
                 deviceList = [innerDevice];
             }
-
+            logger.debug(context, 'handleFindDevice from %j', deviceList);
             async.map(
                 deviceList,
                 async.apply(finishQueryForDevice, attributes, contextEntity, actualHandler),

package/lib/services/northBound/contextServerUtils.js

@@ -91,7 +91,7 @@ function executeUpdateSideEffects(device, id, type, service, subservice, attribu
                     ];
 
                     sideEffects.push(
-                        apply(ngsi.update, device.name, device.resource, device.apikey, newAttributes, device)
+                        apply(ngsi.update, device.name, device.type, device.apikey, newAttributes, device)
                     );
                 }
             }