iotagent-node-lib 2.23.0 → 2.25.0

package/lib/jexlTranformsMap.js

@@ -49,6 +49,8 @@ const map = {
     replaceallstr: (str, from, to) => str.replaceAll(from, to),
     replaceallregexp: (str, reg, to) => str.replaceAll(new RegExp(reg, 'g'), to),
     split: (str, ch) => str.split(ch),
+    joinarrtostr: (arr, ch) => arr.join(ch),
+    concatarr: (arr, arr2) => arr.concat(arr2),
     mapper: (val, values, choices) => choices[values.findIndex((target) => target === val)],
     thmapper: (val, values, choices) =>
         choices[
@@ -67,7 +69,16 @@ const map = {
         return Array.from(s);
     },
     touppercase: (val) => String(val).toUpperCase(),
-    tolowercase: (val) => String(val).toLowerCase()
+    tolowercase: (val) => String(val).toLowerCase(),
+    floor: (val) => Math.floor(val),
+    ceil: (val) => Math.ceil(val),
+    round: (val) => Math.round(val),
+    tofixed: (val, decimals) => Number.parseFloat(val).toFixed(decimals),
+    gettime: (d) => new Date(d).getTime(),
+    toisostring: (d) => new Date(d).toISOString(),
+    // https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
+    localestring: (d, timezone, options) => new Date(d).toLocaleString(timezone, options),
+    now: () => Date.now()
 };
 
 exports.map = map;

package/lib/plugins/bidirectionalData.js

@@ -26,8 +26,9 @@
 const async = require('async');
 const apply = async.apply;
 const _ = require('underscore');
-const parser = require('./expressionParser');
+const parser = require('./expressionPlugin');
 const logger = require('logops');
+const config = require('../commonConfig');
 const subscriptions = require('../services/ngsi/subscriptionService');
 const deviceService = require('../services/devices/deviceService');
 const context = {
@@ -180,14 +181,17 @@ function getReverseTransformations(list, values, callback) {
 }
 
 /**
- * Apply a list of transformations to the reported values, generating a new array of values with the additional data.
+ * Apply a list of transformations to the reported values,
+ * generating a new array of values with the additional data.
+ * For NGSI-v2 this consists of value transformations only
  *
  * @param {Array} values                List of reported attributes (with their name, type and value).
+ * @param {Object} typeInformation      Provisioning information about the device represented by the entity.
  * @param {Array} transformations       List of transformations to apply (with their name, type and expression).
  */
-function processTransformations(values, transformations, callback) {
+function processTransformationsNGSIv2(values, typeInformation, transformations, callback) {
     let cleanedExpression;
-    const ctx = parser.extractContext(values);
+    const ctx = parser.extractContext(values, typeInformation);
     let resultTransformations = [];
 
     for (let j = 0; j < 2; j++) {
@@ -205,13 +209,107 @@ function processTransformations(values, transformations, callback) {
         values.push({
             name: resultTransformations[i].object_id,
             type: resultTransformations[i].type,
-            value: parser.parse(cleanedExpression, ctx, 'String')
+            value: parser.parse(cleanedExpression, ctx, 'String', typeInformation)
         });
     }
 
     callback(null, values);
 }
 
+/**
+ * Apply a list of transformations to the reported values,
+ * generating a new array of values with the additional data.
+ * For NGSI-LD the output includes value, metadata and datasetId
+ *
+ * @param {Array} values                List of reported attributes (with their name, type and value).
+ * @param {Object} typeInformation      Provisioning information about the device represented by the entity.
+ * @param {Array} transformations       List of transformations to apply (with their name, type and expression).
+ */
+function processTransformationsNGSILD(values, typeInformation, transformations, callback) {
+    let cleanedExpression;
+    const defaultValues = [];
+    const datasetIds = {};
+
+    // Split incoming values into those with and without datasetId
+    values.forEach((value) => {
+        if (value.datasetId) {
+            datasetIds[value.datasetId] = datasetIds[value.datasetId] || [];
+            datasetIds[value.datasetId].push(value);
+        } else {
+            defaultValues.push(value);
+        }
+    });
+
+    let resultTransformations = [];
+
+    for (let j = 0; j < 2; j++) {
+        if (transformations[j]) {
+            resultTransformations = resultTransformations.concat(transformations[j]);
+        }
+    }
+
+    // Process Transformations using the default datasetId
+    // This is the direct equivalent of the NGSI-v2 function
+    if (!_.isEmpty(defaultValues)) {
+        for (let i = 0; i < resultTransformations.length; i++) {
+            cleanedExpression = resultTransformations[i].expression.substr(
+                2,
+                resultTransformations[i].expression.length - 3
+            );
+            values.push({
+                name: resultTransformations[i].object_id,
+                type: resultTransformations[i].type,
+                metadata: {},
+                value: parser.parse(
+                    cleanedExpression,
+                    parser.extractContext(defaultValues, typeInformation),
+                    'String',
+                    typeInformation
+                )
+            });
+        }
+    }
+
+    // Process Transformations using an explicit datasetId
+    // There is no equivalent with NGSI-v2
+    _.keys(datasetIds).forEach((datasetId) => {
+        for (let i = 0; i < resultTransformations.length; i++) {
+            cleanedExpression = resultTransformations[i].expression.substr(
+                2,
+                resultTransformations[i].expression.length - 3
+            );
+            values.push({
+                name: resultTransformations[i].object_id,
+                type: resultTransformations[i].type,
+                datasetId,
+                metadata: {},
+                value: parser.parse(
+                    cleanedExpression,
+                    parser.extractContext(datasetIds[datasetId], typeInformation),
+                    'String',
+                    typeInformation
+                )
+            });
+        }
+    });
+    callback(null, values);
+}
+
+/**
+ * Apply a list of transformations to the reported values, generating a new array of values with the additional data.
+ *
+ * @param {Array} values                List of reported attributes (with their name, type and value).
+ * @param {Object} typeInformation      Provisioning information about the device represented by the entity.
+ * @param {Array} transformations       List of transformations to apply (with their name, type and expression).
+ */
+function processTransformations(values, typeInformation, transformations, callback) {
+    if (config.checkNgsiLD({})) {
+        processTransformationsNGSILD(values, typeInformation, transformations, callback);
+    } else {
+        processTransformationsNGSIv2(values, typeInformation, transformations, callback);
+    }
+}
+
 /**
  * Middleware to handle incoming Configuration group provisions. Should check for the existence of reverse active
  * attributes and create subscriptions for the modifciation of those values.
@@ -259,7 +357,7 @@ function handleNotification(device, values, callback) {
                         apply(getReverseTransformations, deviceAttributes, values),
                         apply(getReverseTransformations, groupAttributes, values)
                     ]),
-                    apply(processTransformations, values)
+                    apply(processTransformations, values, device)
                 ],
                 function (error, results) {
                     callback(error, device, results);

package/lib/plugins/expressionPlugin.js

@@ -60,6 +60,13 @@ function extractContext(attributeList, typeInformation) {
     return parser.extractContext(attributeList);
 }
 
+function parse(expression, context, type, typeInformation) {
+    if (!checkJexl(typeInformation)) {
+        return legacyParser.parse(expression, context, type);
+    }
+    return jexlParser.parse(expression, context);
+}
+
 function mergeAttributes(attrList1, attrList2) {
     const finalCollection = _.clone(attrList1);
     const additionalItems = [];
@@ -120,6 +127,8 @@ function update(entity, typeInformation, callback) {
                 attributesCtxt.push(att);
             });
         }
+        let idTypeSSSList = utils.getIdTypeServSubServiceFromDevice(typeInformation);
+        attributesCtxt = attributesCtxt.concat(idTypeSSSList);
         const ctx = parser.extractContext(attributesCtxt);
 
         if (typeInformation.active) {
@@ -156,6 +165,7 @@ function update(entity, typeInformation, callback) {
     }
 }
 
+exports.parse = parse;
 exports.update = update;
 exports.setJEXLTransforms = setJEXLTransforms;
 exports.applyExpression = applyExpression;

package/lib/plugins/jexlParser.js

@@ -141,8 +141,8 @@ function contextAvailable(expression, context) {
         jexl.evalSync(expression, context);
         return true;
     } catch (e) {
-        error = new errors.InvalidExpression(expression);
-        throw error;
+        logger.warn(logContext, 'Wrong expression found "[%j]" over "[%j]", it will be ignored', expression, context);
+        return false;
     }
 }
 

package/lib/plugins/pluginUtils.js

@@ -177,7 +177,8 @@ function getIdTypeServSubServiceFromDevice(typeInformation) {
         { name: 'id', type: 'String', value: typeInformation.id },
         { name: 'type', type: 'String', value: typeInformation.type },
         { name: 'service', type: 'String', value: typeInformation.service },
-        { name: 'subservice', type: 'String', value: typeInformation.subservice }
+        { name: 'subservice', type: 'String', value: typeInformation.subservice },
+        { name: 'entity_name', type: 'String', value: typeInformation.name }
     ];
     return attrList;
 }

package/lib/request-shim.js

@@ -26,6 +26,7 @@ const logger = require('logops');
 const context = {
     op: 'IoTAgentNGSI.Request'
 };
+const util = require('util');
 
 /**
  *  Transform the "request" options into "got" options and add additional "got" defaults
@@ -103,7 +104,7 @@ function request(options, callback) {
             return callback(null, response, response.body);
         })
         .catch((error) => {
-            logger.debug(context, 'Error: %s', JSON.stringify(error, null, 4));
+            logger.debug(context, 'Error: %s', JSON.stringify(util.inspect(error), null, 4));
             return callback(error);
         });
 }

package/lib/services/devices/deviceService.js

@@ -132,7 +132,14 @@ function mergeArrays(original, newArray) {
  * @param {Object} configuration        Configuration data.
  */
 function mergeDeviceWithConfiguration(fields, defaults, deviceData, configuration, callback) {
-    logger.debug(context, 'deviceData before merge with conf: %j', deviceData);
+    logger.debug(
+        context,
+        'deviceData before merge with conf: %j defaults: %j fields: %j configuration %j',
+        deviceData,
+        defaults,
+        fields,
+        configuration
+    );
     for (let i = 0; i < fields.length; i++) {
         const confField = fields[i] === 'active' ? 'attributes' : fields[i];
         if (deviceData && deviceData[fields[i]] && ['active', 'lazy', 'commands'].indexOf(fields[i]) >= 0) {
@@ -282,32 +289,24 @@ function registerDevice(deviceObj, callback) {
         }
 
         if (!deviceData.name) {
-            if (configuration && configuration.entityNameExp !== undefined) {
+            let entityName = null;
+            if (configuration && configuration.entityNameExp !== undefined && configuration.entityNameExp !== '') {
                 // Add device ID, TYPE, S, SS to the context for the JEXL expression
                 let attrList = pluginUtils.getIdTypeServSubServiceFromDevice(deviceData);
                 attrList = deviceData.staticAttributes ? attrList.concat(deviceData.staticAttributes) : attrList;
                 let ctxt = expressionPlugin.extractContext(attrList, deviceData);
-                let entityName = expressionPlugin.applyExpression(configuration.entityNameExp, ctxt, deviceData);
-                deviceData.name = entityName ? entityName : configuration.entityNameExp;
-            } else {
-                let conjunction;
-                if (configuration && configuration.defaultEntityNameConjunction !== undefined) {
-                    conjunction = configuration.defaultEntityNameConjunction;
-                } else {
-                    conjunction = config.getConfig().defaultEntityNameConjunction;
-                }
-                deviceData.name = deviceData.type + conjunction + deviceData.id;
-
-                if (config.checkNgsiLD(configuration)) {
-                    deviceData.name = 'urn:ngsi-ld:' + deviceData.type + conjunction + deviceData.id;
+                try {
+                    entityName = expressionPlugin.applyExpression(configuration.entityNameExp, ctxt, deviceData);
+                } catch (e) {
+                    logger.debug(
+                        context,
+                        'Error evaluating expression for entityName: %s with context: %s',
+                        configuration.entityNameExp,
+                        ctxt
+                    );
                 }
-                logger.debug(
-                    context,
-                    'Device name not found, falling back to deviceType%sdeviceId [%s]',
-                    conjunction,
-                    deviceData.name
-                );
             }
+            deviceData.name = entityName ? entityName : defaultName();
         }
 
         if (!configuration && config.getConfig().types[deviceData.type]) {
@@ -316,6 +315,28 @@ function registerDevice(deviceObj, callback) {
             selectedConfiguration = configuration;
         }
         callback(null, deviceData, selectedConfiguration);
+
+        function defaultName() {
+            let conjunction;
+            let name;
+            if (configuration && configuration.defaultEntityNameConjunction !== undefined) {
+                conjunction = configuration.defaultEntityNameConjunction;
+            } else {
+                conjunction = config.getConfig().defaultEntityNameConjunction;
+            }
+            name = deviceData.type + conjunction + deviceData.id;
+
+            if (config.checkNgsiLD(configuration)) {
+                name = 'urn:ngsi-ld:' + deviceData.type + conjunction + deviceData.id;
+            }
+            logger.debug(
+                context,
+                'Device name not found, falling back to deviceType%sdeviceId [%s]',
+                conjunction,
+                deviceData.name
+            );
+            return name;
+        }
     }
 
     function completeRegistrations(error, deviceData) {
@@ -348,6 +369,9 @@ function registerDevice(deviceObj, callback) {
                     if ('explicitAttrs' in deviceData && deviceData.explicitAttrs !== undefined) {
                         deviceObj.explicitAttrs = deviceData.explicitAttrs;
                     }
+                    if ('apikey' in deviceData && deviceData.apikey !== undefined) {
+                        deviceObj.apikey = deviceData.apikey;
+                    }
                     config.getRegistry().store(deviceObj, callback);
                 }
             }
@@ -605,8 +629,16 @@ function findOrCreate(deviceId, group, callback) {
             if ('expressionLanguage' in group && group.expressionLanguage !== undefined) {
                 newDevice.expressionLanguage = group.expressionLanguage;
             }
+            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) {
+                logger.debug(context, 'Registering autoprovision of Device %j for its conf %j', newDevice, group);
                 registerDevice(newDevice, function (error, device) {
                     callback(error, device, group);
                 });

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

@@ -359,7 +359,9 @@ function updateRegisterDeviceNgsi2(deviceObj, entityInfoUpdated, callback) {
             if ('expressionLanguage' in newDevice && newDevice.expressionLanguage !== undefined) {
                 oldDevice.expressionLanguage = newDevice.expressionLanguage;
             }
-
+            if ('apikey' in newDevice && newDevice.apikey !== undefined) {
+                oldDevice.explicitAttrs = newDevice.apikey;
+            }
             oldDevice.endpoint = newDevice.endpoint || oldDevice.endpoint;
 
             callback(null, oldDevice);

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

@@ -387,8 +387,13 @@ function removeHiddenAttrsFromMultiEntity(entities, typeInformation, payload) {
                     ...jexlParser.extractContext(attsArray),
                     ...extractContextFromPayload(payload)
                 }; //maybe overlapping between this two objects.
-                const res = jexlParser.applyExpression(typeInformation.explicitAttrs, ctx, typeInformation);
-                explicitAttrsList = explicitAttrsList.concat(res);
+                let res = null;
+                try {
+                    res = jexlParser.applyExpression(typeInformation.explicitAttrs, ctx, typeInformation);
+                } catch (e) {
+                    // nothing to do: exception is already logged at info level
+                }
+                explicitAttrsList = res ? explicitAttrsList.concat(res) : explicitAttrsList;
             });
         }
     }
@@ -438,8 +443,13 @@ function removeHiddenAttrs(result, typeInformation, payload) {
             ...jexlParser.extractContext(attsArray),
             ...extractContextFromPayload(payload)
         }; //maybe overlapping between this two objects. Measures not in active attrs.
-        const res = jexlParser.applyExpression(typeInformation.explicitAttrs, ctx, typeInformation);
-        explicitAttrsList = res;
+        let res = null;
+        try {
+            res = jexlParser.applyExpression(typeInformation.explicitAttrs, ctx, typeInformation);
+        } catch (e) {
+            // nothing to do: exception is already logged at info level
+        }
+        explicitAttrsList = res ? res : [];
     }
     if (explicitAttrsList && explicitAttrsList.length >= 0) {
         const hidden = _.difference(_.keys(result), explicitAttrsList);

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

@@ -46,6 +46,21 @@ const overwritePaths = ['/ngsi-ld/v1/entities/:entity/attrs', '/ngsi-ld/v1/entit
 const updatePaths = ['/ngsi-ld/v1/entities/:entity/attrs', '/ngsi-ld/v1/entities/:entity/attrs/:attr'];
 const queryPaths = ['/ngsi-ld/v1/entities/:entity'];
 
+/**
+ * Extract metadata attributes from input.
+ *
+ * @param {Object} obj                  input object
+ */
+function getMetaData(obj) {
+    const excludedKeys = ['datasetId', 'value', 'type'];
+    const metaData = {};
+    _.keys(obj).forEach((key) => {
+        if (!excludedKeys.includes(key)) {
+            metaData[key] = obj[key];
+        }
+    });
+    return !_.isEmpty(metaData) ? metaData : {};
+}
 /**
  * Generate all the update actions corresponding to a update context request using Ngsi2.
  * Update actions include updates in attributes and execution of commands.
@@ -59,6 +74,7 @@ function generateUpdateActionsNgsiLD(req, contextElement, callback) {
 
     const attribute = req.params.attr;
     const value = req.body.value;
+    const datasetId = req.body.datasetId;
     const incomingAttrs = !req.params.attr ? _.keys(req.body) : [];
 
     if (contextElement.id && contextElement.type) {
@@ -75,19 +91,49 @@ function generateUpdateActionsNgsiLD(req, contextElement, callback) {
 
         if (device.commands) {
             for (const j in device.commands) {
-                if (attribute === device.commands[j].name) {
-                    commands.push({
-                        type: device.commands[j].type,
-                        value,
-                        name: attribute
-                    });
+                const name = device.commands[j].name;
+                if (attribute === name) {
+                    if (_.isArray(req.body)) {
+                        req.body[name].forEach((obj) => {
+                            commands.push({
+                                type: device.commands[j].type,
+                                value: obj.value,
+                                name: name,
+                                datasetId: obj.datasetId,
+                                metadata: getMetaData(obj)
+                            });
+                        });
+                    } else {
+                        commands.push({
+                            type: device.commands[j].type,
+                            value,
+                            name,
+                            datasetId,
+                            metadata: getMetaData(req.body)
+                        });
+                    }
                     found = true;
-                } else if (incomingAttrs.includes(device.commands[j].name)) {
-                    commands.push({
-                        type: device.commands[j].type,
-                        value: req.body[device.commands[j].name].value,
-                        name: device.commands[j].name
-                    });
+                } else if (incomingAttrs.includes(name)) {
+                    if (_.isArray(req.body[name])) {
+                        req.body[name].forEach((obj) => {
+                            commands.push({
+                                type: device.commands[j].type,
+                                value: obj.value,
+                                name: name,
+                                datasetId: obj.datasetId,
+                                metadata: getMetaData(obj)
+                            });
+                        });
+                    } else {
+                        const obj = req.body[name];
+                        commands.push({
+                            type: device.commands[j].type,
+                            value: obj.value,
+                            name: name,
+                            datasetId: obj.datasetId,
+                            metadata: getMetaData(obj)
+                        });
+                    }
                     found = true;
                 }
             }
@@ -290,7 +336,7 @@ function handleQueryNgsiLD(req, res, next) {
 
         if (device.staticAttributes) {
             let selectedAttributes = [];
-            if (attributes === undefined || attributes.length === 0) {
+            if (attributes === null || attributes === undefined || attributes.length === 0) {
                 selectedAttributes = device.staticAttributes;
             } else {
                 selectedAttributes = device.staticAttributes.filter(inAttributes);
@@ -316,8 +362,8 @@ function handleQueryNgsiLD(req, res, next) {
             const results = device.lazy.map(getName);
             callback(null, results);
         } else {
-            logger.debug(context, "Couldn't find any attributes. Handling with null reference");
-            callback(null, null);
+            logger.debug(context, "Couldn't find any attributes. Handling with empty reference");
+            callback(null, []);
         }
     }
 
@@ -472,11 +518,25 @@ function handleNotificationNgsiLD(req, res, next) {
             /* eslint-disable-next-line  no-prototype-builtins */
             if (dataElement.hasOwnProperty(key)) {
                 if (key !== 'id' && key !== 'type') {
-                    const att = {};
-                    att.type = dataElement[key].type;
-                    att.value = dataElement[key].value;
-                    att.name = key;
-                    atts.push(att);
+                    if (_.isArray(dataElement[key])) {
+                        dataElement[key].forEach((obj) => {
+                            atts.push({
+                                type: obj.type,
+                                value: obj.value,
+                                name: key,
+                                datasetId: obj.datasetId,
+                                metadata: getMetaData(obj)
+                            });
+                        });
+                    } else {
+                        atts.push({
+                            type: dataElement[key].type,
+                            value: dataElement[key].value,
+                            name: key,
+                            datasetId: dataElement[key].datasetId,
+                            metadata: getMetaData(dataElement[key])
+                        });
+                    }
                 }
             }
         }
@@ -563,6 +623,21 @@ function updateErrorHandlingNgsiLD(error, req, res, next) {
     });
 }
 
+/**
+ * Load unsupported NGSI-LD entity routes and return proper NGSI-LD not supported responses
+ *
+ * @param {Object} router      Express request router object.
+ */
+function loadUnsupportedEndpointsNGSILD(router) {
+    const unsupportedEndpoint = function (req, res) {
+        return res.status(501).send(new errors.MethodNotSupported(req.method, req.path));
+    };
+    router.get('/ngsi-ld/v1/entities', unsupportedEndpoint);
+    router.post('/ngsi-ld/v1/entities', unsupportedEndpoint);
+    router.delete('/ngsi-ld/v1/entities/:entity', unsupportedEndpoint);
+    router.delete('/ngsi-ld/v1/entities/:entity/attrs/:attr', unsupportedEndpoint);
+}
+
 /**
  * Load the routes related to context dispatching (NGSI10 calls).
  *
@@ -601,6 +676,7 @@ function loadContextRoutesNGSILD(router) {
         handleNotificationNgsiLD,
         queryErrorHandlingNgsiLD
     ]);
+    loadUnsupportedEndpointsNGSILD(router);
 }
 
 exports.loadContextRoutes = loadContextRoutesNGSILD;

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

@@ -286,6 +286,7 @@ function handleNotificationNgsi2(req, res, next) {
                     const att = {};
                     att.type = dataElement[key].type;
                     att.value = dataElement[key].value;
+                    att.metadata = dataElement[key].metadata || {};
                     att.name = key;
                     atts.push(att);
                 }

package/lib/services/northBound/restUtils.js

@@ -53,11 +53,9 @@ function checkMandatoryQueryParams(mandatoryAttributes, body, callback) {
     for (const p in mandatoryAttributes) {
         let found = false;
 
-        for (const i in body) {
-            if (body.hasOwnProperty(i)) {
-                if (i === mandatoryAttributes[p]) {
-                    found = true;
-                }
+        if (body.hasOwnProperty(mandatoryAttributes[p])) {
+            if (body[mandatoryAttributes[p]] !== '' && body[mandatoryAttributes[p]] !== null) {
+                found = true;
             }
         }
 

package/lib/templates/deviceGroup.json

@@ -24,7 +24,7 @@
             "description": "token",
             "type": "string"
           },
-          "cbroker": {
+          "cbHost": {
             "description": "uri for the context broker",
             "type": "string"
           },

package/package.json

@@ -2,7 +2,7 @@
   "name": "iotagent-node-lib",
   "license": "AGPL-3.0-only",
   "description": "IoT Agent library to interface with NGSI Context Broker",
-  "version": "2.23.0",
+  "version": "2.25.0",
   "homepage": "https://github.com/telefonicaid/iotagent-node-lib",
   "keywords": [
     "fiware",
@@ -23,7 +23,7 @@
   },
   "main": "lib/fiware-iotagent-lib",
   "engines": {
-    "node": ">=12"
+    "node": ">=14"
   },
   "scripts": {
     "clean": "rm -rf package-lock.json && rm -rf node_modules && rm -rf coverage",