iotagent-node-lib 2.21.0 → 2.24.0

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

@@ -45,21 +45,28 @@ function setJEXLTransforms(transformationMap) {
 }
 
 function applyExpression(expression, context, typeInformation) {
-    let parser = legacyParser;
-    if (checkJexl(typeInformation)) {
-        parser = jexlParser;
+    let parser = jexlParser;
+    if (!checkJexl(typeInformation)) {
+        parser = legacyParser;
     }
     return parser.applyExpression(expression, context, typeInformation);
 }
 
 function extractContext(attributeList, typeInformation) {
-    let parser = legacyParser;
-    if (checkJexl(typeInformation)) {
-        parser = jexlParser;
+    let parser = jexlParser;
+    if (!checkJexl(typeInformation)) {
+        parser = legacyParser;
     }
     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) {
@@ -150,11 +159,13 @@ function update(entity, typeInformation, callback) {
 
         callback(null, entity, typeInformation);
     } catch (e) {
-        logger.error(context, 'expressionPlugin error %j procesing entity %j', e, entity);
+        logger.info(context, 'expressionPlugin error %j procesing entity %j', e, entity);
         callback(e);
+        return;
     }
 }
 
+exports.parse = parse;
 exports.update = update;
 exports.setJEXLTransforms = setJEXLTransforms;
 exports.applyExpression = applyExpression;

package/lib/plugins/multiEntity.js

@@ -41,8 +41,8 @@ const utils = require('./pluginUtils');
 /* eslint-disable-next-line  no-unused-vars */
 const aliasPlugin = require('./attributeAlias');
 
-function hasEntityName(item) {
-    return item.entity_name;
+function hasEntityNameOrEntityType(item) {
+    return item.entity_name || item.entity_type;
 }
 
 /**
@@ -206,37 +206,50 @@ function propagateTimestamp(entity, entities) {
 }
 
 function updateAttribute(entity, typeInformation, callback) {
-    let parser = legacyParser;
-    if (expressionPlugin.checkJexl(typeInformation)) {
-        parser = jexlParser;
-    }
-    const attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
-    const ctx = parser.extractContext(attsArray);
-
-    let entities = [entity];
-    if (typeInformation.active) {
-        const multiEntityAttributes = typeInformation.active.filter(hasEntityName);
-        for (let i in multiEntityAttributes) {
-            if (parser.contextAvailable(multiEntityAttributes[i].entity_name, ctx)) {
-                let entityName = parser.applyExpression(multiEntityAttributes[i].entity_name, ctx, typeInformation);
-                // An entity_name could not be null, but a result or expression could be null
-                if (entityName !== null) {
-                    multiEntityAttributes[i].entity_name = entityName;
+    try {
+        logger.debug(context, 'multiEntityPlugin entity %j', entity);
+        let parser = jexlParser;
+        if (!expressionPlugin.checkJexl(typeInformation)) {
+            parser = legacyParser;
+        }
+        // The context for the JEXL expression should be the ID, TYPE, S, SS
+        let attrList = utils.getIdTypeServSubServiceFromDevice(typeInformation);
+        const attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
+        attrList = attrList.concat(attsArray);
+        const ctx = parser.extractContext(attrList);
+        let entities = [entity];
+        if (typeInformation.active) {
+            const multiEntityAttributes = typeInformation.active.filter(hasEntityNameOrEntityType);
+            for (let i in multiEntityAttributes) {
+                if (!multiEntityAttributes[i].entity_name) {
+                    // Then hasEntityType and entity_name should be device.name
+                    multiEntityAttributes[i].entity_name = typeInformation.name;
+                }
+                if (parser.contextAvailable(multiEntityAttributes[i].entity_name, ctx)) {
+                    let entityName = parser.applyExpression(multiEntityAttributes[i].entity_name, ctx, typeInformation);
+                    // An entity_name could not be null, but a result or expression could be null
+                    if (entityName !== null) {
+                        multiEntityAttributes[i].entity_name = entityName;
+                    }
                 }
             }
+            const newEntities = extractNewEntities(multiEntityAttributes, typeInformation.type);
+
+            if (multiEntityAttributes.length > 0) {
+                let resultAttributes = filterOutMultientitiesNgsi2(entity, multiEntityAttributes);
+                const newCes = generateNewCEsNgsi2(entity, newEntities, multiEntityAttributes);
+                entities = [resultAttributes].concat(newCes);
+                propagateTimestamp(entity, entities);
+            } else {
+                entities = entity;
+            }
         }
-        const newEntities = extractNewEntities(multiEntityAttributes, typeInformation.type);
-
-        if (multiEntityAttributes.length > 0) {
-            let resultAttributes = filterOutMultientitiesNgsi2(entity, multiEntityAttributes);
-            const newCes = generateNewCEsNgsi2(entity, newEntities, multiEntityAttributes);
-            entities = [resultAttributes].concat(newCes);
-            propagateTimestamp(entity, entities);
-        } else {
-            entities = entity;
-        }
+        callback(null, entities, typeInformation);
+    } catch (e) {
+        logger.info(context, 'multiEntityPlugin error %j procesing entity %j', e, entity);
+        callback(e);
+        return;
     }
-    callback(null, entities, typeInformation);
 }
 
 exports.update = updateAttribute;

package/lib/plugins/pluginUtils.js

@@ -167,9 +167,26 @@ function identityFilter(entity, typeInformation, callback) {
     callback(null, entity, typeInformation);
 }
 
+/**
+ * Creates an array of attributes from an device including id, type, service and subservice
+ * @param       {Object}             device
+ * @return      {Object}             Array of id, type, service and subservice extracted from device
+ */
+function getIdTypeServSubServiceFromDevice(typeInformation) {
+    let attrList = [
+        { 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: 'entity_name', type: 'String', value: typeInformation.name }
+    ];
+    return attrList;
+}
+
 exports.createProcessAttribute = createProcessAttribute;
 exports.createUpdateFilter = createUpdateFilter;
 exports.createQueryFilter = createQueryFilter;
 exports.identityFilter = identityFilter;
 exports.createNgsi2Entity = createNgsi2Entity;
 exports.extractAttributesArrayFromNgsi2Entity = extractAttributesArrayFromNgsi2Entity;
+exports.getIdTypeServSubServiceFromDevice = getIdTypeServSubServiceFromDevice;

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/commands/commandService.js

@@ -29,10 +29,12 @@ const config = require('../../commonConfig');
 const constants = require('../../constants');
 const ngsiService = require('../ngsi/ngsiService');
 const deviceService = require('../devices/deviceService');
+const pluginUtils = require('../../plugins/pluginUtils');
 let daemonId;
 const context = {
     op: 'IoTAgentNGSI.CommandService'
 };
+const expressionPlugin = require('../../plugins/expressionPlugin');
 
 function listCommands(service, subservice, deviceId, callback) {
     logger.debug(context, 'Listing all commands for device [%s]', deviceId);
@@ -41,11 +43,35 @@ function listCommands(service, subservice, deviceId, callback) {
 }
 
 function addCommand(service, subservice, deviceId, command, callback) {
-    logger.debug(context, 'Adding command [%s] to the queue for device [%s]', command.name, deviceId);
-
+    logger.debug(context, 'Adding command [%j] to the queue for device [%s]', command, deviceId);
     config.getCommandRegistry().add(service, subservice, deviceId, command, callback);
 }
 
+function addCommandDevice(service, subservice, device, command, callback) {
+    logger.debug(context, 'Adding command [%j] to the queue for device [%j]', command, device);
+    let deviceCmd;
+    if (device && device.commands) {
+        deviceCmd = device.commands.find((c) => c.name === command.name);
+    }
+    if (deviceCmd && deviceCmd.expression) {
+        let parser = expressionPlugin;
+        // The context for the JEXL expression should be the ID, TYPE, S, SS
+        let attrList = pluginUtils.getIdTypeServSubServiceFromDevice(device);
+        attrList = device.staticAttributes ? attrList.concat(device.staticAttributes) : attrList.concat([]);
+        let ctxt = parser.extractContext(attrList, device);
+        logger.debug(context, 'attrList [%j] for device %j', attrList, device);
+        // expression result will be the full command payload
+        let cmdValueRes = null;
+        try {
+            cmdValueRes = parser.applyExpression(deviceCmd.expression, ctxt, device);
+        } catch (e) {
+            // nothing to do
+        }
+        command.value = cmdValueRes ? cmdValueRes : deviceCmd.expression;
+    }
+    config.getCommandRegistry().add(service, subservice, device.id, command, callback);
+}
+
 function updateCommand(service, subservice, deviceId, name, value, callback) {
     logger.debug(context, 'Updating command [%s] for device [%s] with value [%s]', name, deviceId, value);
 
@@ -147,6 +173,7 @@ function stopExpirationDaemon(callback) {
 
 exports.list = intoTrans(context, listCommands);
 exports.add = addCommand;
+exports.addCmd = addCommandDevice;
 exports.update = updateCommand;
 exports.remove = removeCommand;
 exports.start = startExpirationDaemon;

package/lib/services/common/iotManagerService.js

@@ -60,7 +60,8 @@ function register(callback) {
             explicitAttrs: service.explicitAttrs,
             expressionLanguage: service.expressionLanguage,
             defaultEntityNameConjunction: service.defaultEntityNameConjunction,
-            ngsiVersion: service.ngsiVersion
+            ngsiVersion: service.ngsiVersion,
+            entityNameExp: service.entityNameExp
         };
     }
 

package/lib/services/devices/deviceService.js

@@ -38,6 +38,8 @@ const logger = require('logops');
 const config = require('../../commonConfig');
 const registrationUtils = require('./registrationUtils');
 const subscriptions = require('../ngsi/subscriptionService');
+const expressionPlugin = require('./../../plugins/expressionPlugin');
+const pluginUtils = require('./../../plugins/pluginUtils');
 const _ = require('underscore');
 const context = {
     op: 'IoTAgentNGSI.DeviceService'
@@ -280,15 +282,45 @@ function registerDevice(deviceObj, callback) {
         }
 
         if (!deviceData.name) {
+            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);
+                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
+                    );
+                }
+            }
+            deviceData.name = entityName ? entityName : defaultName();
+        }
+
+        if (!configuration && config.getConfig().types[deviceData.type]) {
+            selectedConfiguration = config.getConfig().types[deviceData.type];
+        } else {
+            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;
             }
-            deviceData.name = deviceData.type + conjunction + deviceData.id;
+            name = deviceData.type + conjunction + deviceData.id;
+
             if (config.checkNgsiLD(configuration)) {
-                deviceData.name = 'urn:ngsi-ld:' + deviceData.type + conjunction + deviceData.id;
+                name = 'urn:ngsi-ld:' + deviceData.type + conjunction + deviceData.id;
             }
             logger.debug(
                 context,
@@ -296,14 +328,8 @@ function registerDevice(deviceObj, callback) {
                 conjunction,
                 deviceData.name
             );
+            return name;
         }
-
-        if (!configuration && config.getConfig().types[deviceData.type]) {
-            selectedConfiguration = config.getConfig().types[deviceData.type];
-        } else {
-            selectedConfiguration = configuration;
-        }
-        callback(null, deviceData, selectedConfiguration);
     }
 
     function completeRegistrations(error, deviceData) {

package/lib/services/groups/groupRegistryMongoDB.js

@@ -57,7 +57,8 @@ const attributeList = [
     'explicitAttrs',
     'expressionLanguage',
     'defaultEntityNameConjunction',
-    'ngsiVersion'
+    'ngsiVersion',
+    'entityNameExp'
 ];
 
 /**
@@ -299,21 +300,21 @@ function clear(callback) {
     dbService.db.db.dropDatabase(callback);
 }
 
-exports.create = alarmsInt(constants.MONGO_ALARM, intoTrans(context, createGroup));
-exports.list = alarmsInt(constants.MONGO_ALARM, intoTrans(context, listGroups));
-exports.init = alarmsInt(constants.MONGO_ALARM, intoTrans(context, init));
-exports.find = alarmsInt(constants.MONGO_ALARM, intoTrans(context, find));
+exports.create = alarmsInt(constants.MONGO_ALARM + '_01', intoTrans(context, createGroup));
+exports.list = alarmsInt(constants.MONGO_ALARM + '_02', intoTrans(context, listGroups));
+exports.init = alarmsInt(constants.MONGO_ALARM + '_03', intoTrans(context, init));
+exports.find = alarmsInt(constants.MONGO_ALARM + '_04', intoTrans(context, find));
 exports.findType = alarmsInt(
-    constants.MONGO_ALARM,
+    constants.MONGO_ALARM + '_05',
     intoTrans(context, findBy(['service', 'subservice', 'type', 'apikey']))
 );
 exports.findTypeSilently = intoTrans(context, findBy(['service', 'subservice', 'type', 'apikey']));
 exports.findSilently = intoTrans(context, findBy(['service', 'subservice', 'apikey']));
-exports.findBy = alarmsInt(constants.MONGO_ALARM, intoTrans(context, findBy));
-exports.get = alarmsInt(constants.MONGO_ALARM, intoTrans(context, findBy(['resource', 'apikey'])));
+exports.findBy = alarmsInt(constants.MONGO_ALARM + '_06', intoTrans(context, findBy));
+exports.get = alarmsInt(constants.MONGO_ALARM + '_07', intoTrans(context, findBy(['resource', 'apikey'])));
 exports.getSilently = intoTrans(context, findBy(['resource', 'apikey']));
-exports.getType = alarmsInt(constants.MONGO_ALARM, intoTrans(context, findBy(['type'])));
+exports.getType = alarmsInt(constants.MONGO_ALARM + '_08', intoTrans(context, findBy(['type'])));
 exports.getTypeSilently = intoTrans(context, findBy(['type']));
-exports.update = alarmsInt(constants.MONGO_ALARM, intoTrans(context, update));
-exports.remove = alarmsInt(constants.MONGO_ALARM, intoTrans(context, remove));
-exports.clear = alarmsInt(constants.MONGO_ALARM, intoTrans(context, clear));
+exports.update = alarmsInt(constants.MONGO_ALARM + '_09', intoTrans(context, update));
+exports.remove = alarmsInt(constants.MONGO_ALARM + '_10', intoTrans(context, remove));
+exports.clear = alarmsInt(constants.MONGO_ALARM + '_11', intoTrans(context, clear));

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

@@ -160,6 +160,13 @@ function convertAttrNGSILD(attr) {
             delete obj.value;
             break;
 
+        // LanguageProperties
+        case 'languageproperty':
+            obj.type = 'LanguageProperty';
+            obj.languageMap = attr.value;
+            delete obj.value;
+            break;
+
         default:
             obj.value = { '@type': attr.type, '@value': attr.value };
     }