iotagent-node-lib 2.15.1 → 2.19.0

package/lib/model/Device.js

@@ -23,6 +23,9 @@
 
 const mongoose = require('mongoose');
 const Schema = mongoose.Schema;
+const Group = require('./Group');
+
+mongoose.Schema.Types.ExplicitAttrsType = Group.ExplicitAttrsType;
 
 const Device = new Schema({
     id: String,
@@ -38,7 +41,7 @@ const Device = new Schema({
     transport: String,
     staticAttributes: Array,
     subscriptions: Array,
-    service: String,
+    service: { type: String, lowercase: true },
     subservice: String,
     polling: Boolean,
     timezone: String,
@@ -49,7 +52,7 @@ const Device = new Schema({
     internalAttributes: Object,
     autoprovision: Boolean,
     expressionLanguage: String,
-    explicitAttrs: Boolean,
+    explicitAttrs: Group.ExplicitAttrsType,
     ngsiVersion: String
 });
 

package/lib/model/Group.js

@@ -24,12 +24,29 @@
 const mongoose = require('mongoose');
 const Schema = mongoose.Schema;
 
+class ExplicitAttrsType extends mongoose.SchemaType {
+    constructor(key, options) {
+        super(key, options, 'ExplicitAttrsType');
+    }
+    // `cast()` takes a parameter that can be anything. You need to
+    // validate the provided `val` and throw a `CastError` if you
+    // can't convert it.
+    cast(val) {
+        if (!(typeof val === 'boolean' || typeof val === 'string')) {
+            throw new Error('ExplicitAttrsType: ' + val + ' is not Boolean or String');
+        }
+        return val;
+    }
+}
+
+mongoose.Schema.Types.ExplicitAttrsType = ExplicitAttrsType;
+
 const Group = new Schema({
     url: String,
     resource: String,
     apikey: String,
     type: String,
-    service: String,
+    service: { type: String, lowercase: true },
     subservice: String,
     description: String,
     trust: String,
@@ -43,7 +60,7 @@ const Group = new Schema({
     internalAttributes: Array,
     autoprovision: Boolean,
     expressionLanguage: String,
-    explicitAttrs: Boolean,
+    explicitAttrs: ExplicitAttrsType,
     defaultEntityNameConjunction: String,
     ngsiVersion: String
 });
@@ -55,3 +72,4 @@ function load(db) {
 }
 
 module.exports.load = load;
+module.exports.ExplicitAttrsType = ExplicitAttrsType;

package/lib/model/dbConn.js

@@ -106,7 +106,13 @@ function init(host, db, port, options, callback) {
     }
 
     function connectionAttempt(url, options, callback) {
-        logger.info(context, 'Attempting to connect to MongoDB instance. Attempt %d', retries);
+        logger.info(
+            context,
+            'Attempting to connect to MongoDB instance with url %j and options %j. Attempt %d',
+            url,
+            options,
+            retries
+        );
         options.useNewUrlParser = true;
         mongoose.set('useCreateIndex', true);
         /* eslint-disable-next-line no-unused-vars */

package/lib/plugins/attributeAlias.js

@@ -23,7 +23,6 @@
  * Modified by: Daniel Calvo - ATOS Research & Innovation
  */
 
-const config = require('../commonConfig');
 const utils = require('./pluginUtils');
 /* eslint-disable no-unused-vars */
 const logger = require('logops');
@@ -73,10 +72,7 @@ function extractAllMappings(typeInformation) {
 function applyAlias(mappings) {
     return function aliasApplier(attribute) {
         if (mappings.direct[attribute.name]) {
-            if (config.isCurrentNgsi()) {
-                /*jshint camelcase: false */
-                attribute.object_id = attribute.name; // inverse not usefull due to collision
-            }
+            attribute.object_id = attribute.name;
             attribute.metadata = mappings.metadata[attribute.name];
             attribute.type = mappings.types[attribute.name];
             attribute.name = mappings.direct[attribute.name];
@@ -93,14 +89,11 @@ function applyAlias(mappings) {
  */
 function updateAttribute(entity, typeInformation, callback) {
     const mappings = extractAllMappings(typeInformation);
-    if (config.isCurrentNgsi()) {
-        let attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
-        attsArray = attsArray.map(applyAlias(mappings));
-        entity = utils.createNgsi2Entity(entity.id, entity.type, attsArray, true);
-        ngsiUtils.castJsonNativeAttributes(entity);
-    } else {
-        entity.contextElements[0].attributes = entity.contextElements[0].attributes.map(applyAlias(mappings));
-    }
+
+    let attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
+    attsArray = attsArray.map(applyAlias(mappings));
+    entity = utils.createNgsi2Entity(entity.id, entity.type, attsArray, true);
+    ngsiUtils.castJsonNativeAttributes(entity);
 
     callback(null, entity, typeInformation);
 }

package/lib/plugins/bidirectionalData.js

@@ -26,15 +26,13 @@
 const async = require('async');
 const apply = async.apply;
 const _ = require('underscore');
-const legacyParser = require('./expressionParser');
-const jexlParser = require('./jexlParser');
+const parser = require('./expressionParser');
 const logger = require('logops');
 const subscriptions = require('../services/ngsi/subscriptionService');
 const deviceService = require('../services/devices/deviceService');
 const context = {
     op: 'IoTAgentNGSI.BidirectionalPlugin'
 };
-const config = require('../commonConfig');
 
 /**
  * Extract a list of all the bidirectional attributes (those containing reverse expressions) from a device object.
@@ -99,21 +97,6 @@ function extractVariables(item) {
  * @param {Array} attributeList     List of active attributes for subscription.
  */
 function sendSubscriptions(device, attributeList, callback) {
-    function sendSingleSubscriptionNgsi1(item, innerCb) {
-        const variables = extractVariables(item);
-
-        subscriptions.subscribe(device, [item.name], variables, function handleSubscription(error, subId) {
-            if (error) {
-                innerCb(error);
-            } else {
-                innerCb(null, {
-                    id: subId,
-                    triggers: [item.name]
-                });
-            }
-        });
-    }
-
     function sendSingleSubscriptionNgsi2(item, innerCb) {
         const variables = extractVariables(item);
 
@@ -131,11 +114,7 @@ function sendSubscriptions(device, attributeList, callback) {
 
     logger.debug(context, 'Sending bidirectionality subscriptions for device [%s]', device.id);
 
-    if (config.isCurrentNgsi()) {
-        async.map(attributeList, sendSingleSubscriptionNgsi2, callback);
-    } else {
-        async.map(attributeList, sendSingleSubscriptionNgsi1, callback);
-    }
+    async.map(attributeList, sendSingleSubscriptionNgsi2, callback);
 }
 
 /**
@@ -208,10 +187,6 @@ function getReverseTransformations(list, values, callback) {
  */
 function processTransformations(values, transformations, callback) {
     let cleanedExpression;
-    let parser = legacyParser;
-    // if (checkJexl()) {
-    //     parser = jexlParser;
-    // }    
     const ctx = parser.extractContext(values);
     let resultTransformations = [];
 

package/lib/plugins/expressionParser.js

@@ -28,16 +28,16 @@
 const Parser = require('jison').Parser;
 const errors = require('../errors');
 const logger = require('logops');
-const config = require('../commonConfig');
+const fillService = require('../services/common/domain').fillService;
 const _ = require('underscore');
-const logContext = {
+let logContext = {
     op: 'IoTAgentNGSI.Expression'
 };
 const grammar = {
     lex: {
         rules: [
             ['\\s+', '/* skip whitespace */'],
-            ['@[a-zA-Z0-9]+\\b', 'return "VARIABLE";'],
+            ['@[a-zA-Z0-9_]+\\b', 'return "VARIABLE";'],
             ['[0-9]+(?:\\.[0-9]+)?\\b', 'return "NUMBER";'],
             ['\\*', 'return "*";'],
             ['\\/', 'return "/";'],
@@ -107,6 +107,7 @@ function parse(expression, context, type, callback) {
 
         try {
             result = parser.parse(expression);
+            logger.debug(logContext, 'parse expression "[%j]" over "[%j]" result "[%j]" ', expression, context, result);
         } catch (e) {
             error = new errors.InvalidExpression(expression);
 
@@ -129,12 +130,12 @@ function extractContext(attributeList) {
     const context = {};
 
     for (let i = 0; i < attributeList.length; i++) {
-      if (attributeList[i].name) {
-          context[attributeList[i].name] = attributeList[i].value;
-      }
-      if (attributeList[i].object_id) {
-          context[attributeList[i].object_id] = attributeList[i].value;
-      }
+        if (attributeList[i].name) {
+            context[attributeList[i].name] = attributeList[i].value;
+        }
+        if (attributeList[i].object_id) {
+            context[attributeList[i].object_id] = attributeList[i].value;
+        }
     }
 
     return context;
@@ -156,6 +157,7 @@ function processExpression(context) {
 
 /* eslint-disable-next-line no-unused-vars */
 function applyExpression(expression, context, typeInformation) {
+    logContext = fillService(logContext, typeInformation);
     const expressionList = expression.match(/\$\{.*?\}/g) || [];
     const substitutions = expressionList.map(processExpression(context));
     let expressionResult = expression;
@@ -163,7 +165,13 @@ function applyExpression(expression, context, typeInformation) {
     for (let i = 0; i < substitutions.length; i++) {
         expressionResult = expressionResult.replace(substitutions[i].original, substitutions[i].value);
     }
-    logger.debug(logContext, 'applyExpression "[%j]" over "[%j]" result "[%j]" ',  expression, context, expressionResult);
+    logger.debug(
+        logContext,
+        'applyExpression "[%j]" over "[%j]" result "[%j]" ',
+        expression,
+        context,
+        expressionResult
+    );
     return expressionResult;
 }
 
@@ -185,7 +193,7 @@ function expressionApplier(context, typeInformation) {
         };
 
         /*jshint camelcase: false */
-        if (config.isCurrentNgsi() && attribute.object_id) {
+        if (attribute.object_id) {
             newAttribute.object_id = attribute.object_id;
         }
 
@@ -206,12 +214,27 @@ function expressionApplier(context, typeInformation) {
 }
 
 function contextAvailable(expression, context) {
-    const variables = expression.match(/@[a-zA-Z0-9]+/g).map(function (item) {
-        return item.substr(1);
-    });
-    const keys = Object.keys(context);
-
-    return _.difference(variables, keys).length === 0;
+    let error;
+    try {
+        const variablesList = expression.match(/@[a-zA-Z0-9_]+/g) || [];
+        const variables = variablesList.map(function (item) {
+            return item.substr(1);
+        });
+        const keys = Object.keys(context);
+        let validContext = _.difference(variables, keys).length === 0;
+        if (!validContext) {
+            logger.info(
+                logContext,
+                'For expression "[%s]" context "[%j]" does not have element to match',
+                expression,
+                context
+            );
+        }
+        return validContext;
+    } catch (e) {
+        error = new errors.InvalidExpression(expression);
+        throw error;
+    }
 }
 
 function processExpressionAttributes(typeInformation, list, context) {
@@ -225,4 +248,5 @@ function processExpressionAttributes(typeInformation, list, context) {
 exports.parse = parse;
 exports.extractContext = extractContext;
 exports.processExpressionAttributes = processExpressionAttributes;
+exports.contextAvailable = contextAvailable;
 exports.applyExpression = applyExpression;

package/lib/plugins/expressionPlugin.js

@@ -35,6 +35,13 @@ const context = {
 };
 const utils = require('./pluginUtils');
 
+//set the basic JEXL Transformation SET
+setJEXLTransforms(null);
+
+function setJEXLTransforms(transformationMap) {
+    jexlParser.setTransforms(transformationMap);
+}
+
 function mergeAttributes(attrList1, attrList2) {
     const finalCollection = _.clone(attrList1);
     const additionalItems = [];
@@ -45,11 +52,11 @@ function mergeAttributes(attrList1, attrList2) {
 
         for (let j = 0; j < finalCollection.length; j++) {
             if (finalCollection[j].name === attrList2[i].name && attrList2[i].object_id) {
-                if(finalCollection[j].object_id === attrList2[i].object_id){
+                if (finalCollection[j].object_id === attrList2[i].object_id) {
                     finalCollection[j].value = attrList2[i].value;
                     found = true;
                 }
-            } else if (finalCollection[j].name === attrList2[i].name && !attrList2[i].object_id){
+            } else if (finalCollection[j].name === attrList2[i].name && !attrList2[i].object_id) {
                 finalCollection[j].value = attrList2[i].value;
                 found = true;
             }
@@ -83,30 +90,19 @@ function update(entity, typeInformation, callback) {
         return false;
     }
 
-    function processEntityUpdateNgsi1(entity) {
-        let parser = legacyParser;
-        if (checkJexl(typeInformation)) {
-            parser = jexlParser;
-        }
-        let expressionAttributes = [];
-        const ctx = parser.extractContext(entity.attributes);
-
-        if (typeInformation.active) {
-            expressionAttributes = parser.processExpressionAttributes(typeInformation, typeInformation.active, ctx);
-        }
-
-        entity.attributes = mergeAttributes(entity.attributes, expressionAttributes);
-
-        return entity;
-    }
-
     function processEntityUpdateNgsi2(attributes) {
         let parser = legacyParser;
         if (checkJexl(typeInformation)) {
             parser = jexlParser;
         }
         let expressionAttributes = [];
-        const ctx = parser.extractContext(attributes);
+        let attributesCtxt = [...attributes]; // just copy
+        if (typeInformation.static) {
+            typeInformation.static.forEach(function (att) {
+                attributesCtxt.push(att);
+            });
+        }
+        const ctx = parser.extractContext(attributesCtxt);
 
         if (typeInformation.active) {
             expressionAttributes = parser.processExpressionAttributes(typeInformation, typeInformation.active, ctx);
@@ -117,13 +113,10 @@ function update(entity, typeInformation, callback) {
     }
 
     try {
-        if (config.isCurrentNgsi()) {
-            let attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
-            attsArray = processEntityUpdateNgsi2(attsArray);
-            entity = utils.createNgsi2Entity(entity.id, entity.type, attsArray, true);
-        } else {
-            entity.contextElements = entity.contextElements.map(processEntityUpdateNgsi1);
-        }
+        logger.debug(context, 'expressionPlugin entity %j', entity);
+        let attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
+        attsArray = processEntityUpdateNgsi2(attsArray);
+        entity = utils.createNgsi2Entity(entity.id, entity.type, attsArray, true);
 
         callback(null, entity, typeInformation);
     } catch (e) {
@@ -132,3 +125,4 @@ function update(entity, typeInformation, callback) {
 }
 
 exports.update = update;
+exports.setJEXLTransforms = setJEXLTransforms;

package/lib/plugins/jexlParser.js

@@ -30,22 +30,21 @@
 const jexl = require('jexl');
 const errors = require('../errors');
 const logger = require('logops');
+const fillService = require('../services/common/domain').fillService;
 const config = require('../commonConfig');
-const logContext = {
+const baseTranformsMap = require('../jexlTranformsMap.js').map;
+let logContext = {
     op: 'IoTAgentNGSI.JEXL'
 };
 
-jexl.addTransform('indexOf', (val, char) => String(val).indexOf(char));
-jexl.addTransform('length', (val) => String(val).length);
-jexl.addTransform('trim', (val) => String(val).trim());
-jexl.addTransform('substr', (val, int1, int2) => String(val).substr(int1, int2));
-
 function parse(expression, context, callback) {
     let result;
     let error;
 
     try {
         result = jexl.evalSync(expression, context);
+        //avoid undefined result
+        result = result !== undefined ? result : null;
         logger.debug(logContext, 'parse expression "[%j]" over "[%j]" result "[%j]" ', expression, context, result);
     } catch (e) {
         error = new errors.InvalidExpression(expression);
@@ -68,19 +67,21 @@ function extractContext(attributeList) {
     let value;
 
     for (let i = 0; i < attributeList.length; i++) {
-        if (
-            !Number.isNaN(Number.parseFloat(attributeList[i].value)) &&
-            !Number.isInteger(Number.parseFloat(attributeList[i].value))
-        ) {
-            value = Number.parseFloat(attributeList[i].value);
-        } else if (!Number.isNaN(Number.parseInt(attributeList[i].value))) {
-            value = Number.parseInt(attributeList[i].value);
-        } else if (String(attributeList[i].value) === 'true') {
-            value = true;
-        } else if (String(attributeList[i].value) === 'false') {
-            value = false;
-        } else {
+        if (isNaN(attributeList[i].value)) {
             value = attributeList[i].value;
+        } else {
+            let floatValue = Number.parseFloat(attributeList[i].value);
+            if (!Number.isNaN(floatValue) && !Number.isInteger(floatValue)) {
+                value = floatValue;
+            } else if (!Number.isNaN(Number.parseInt(attributeList[i].value))) {
+                value = Number.parseInt(attributeList[i].value);
+            } else if (String(attributeList[i].value) === 'true') {
+                value = true;
+            } else if (String(attributeList[i].value) === 'false') {
+                value = false;
+            } else {
+                value = attributeList[i].value;
+            }
         }
         if (attributeList[i].name) {
             context[attributeList[i].name] = value;
@@ -96,9 +97,10 @@ function extractContext(attributeList) {
 }
 
 function applyExpression(expression, context, typeInformation) {
-    const result = jexl.evalSync(expression, context);
+    logContext = fillService(logContext, typeInformation);
+    const result = parse(expression, context);
     logger.debug(logContext, 'applyExpression "[%j]" over "[%j]" result "[%j]" ', expression, context, result);
-    let expressionResult = result !== undefined ? result : expression;
+    const expressionResult = result !== undefined ? result : expression;
     return expressionResult;
 }
 
@@ -120,31 +122,11 @@ function expressionApplier(context, typeInformation) {
         };
 
         /*jshint camelcase: false */
-        if (config.isCurrentNgsi() && attribute.object_id) {
+        if (attribute.object_id) {
             newAttribute.object_id = attribute.object_id;
         }
 
         newAttribute.value = applyExpression(attribute.expression, context, typeInformation);
-
-        if (attribute.type === 'Number' && isFloat(newAttribute.value)) {
-            newAttribute.value = Number.parseFloat(newAttribute.value);
-        } else if (attribute.type === 'Number' && !Number.isNaN(Number.parseInt(newAttribute.value))) {
-            newAttribute.value = Number.parseInt(newAttribute.value);
-        } else if (attribute.type === 'Boolean') {
-            newAttribute.value = newAttribute.value === 'true' || newAttribute.value === '1';
-        } else if (attribute.type === 'None') {
-            newAttribute.value = null;
-        } else if (attribute.type === 'Text' || attribute.type === 'String') {
-            newAttribute.value = String(newAttribute.value);
-        } else if (
-            attribute.type.toLowerCase().includes('structuredvalue') ||
-            attribute.type.toLowerCase().startsWith('geo') ||
-            attribute.type.toLowerCase().includes('json')
-        ) {
-            newAttribute.value = newAttribute.value;
-        } else {
-            newAttribute.value = String(newAttribute.value);
-        }
         return newAttribute;
     };
 }
@@ -156,32 +138,8 @@ function isTransform(identifier) {
 function contextAvailable(expression, context) {
     let error;
     try {
-        const lexer = jexl._getLexer();
-        const identifiers = lexer.tokenize(expression).filter(function (token) {
-            return token.type === 'identifier';
-        });
-        const keys = Object.keys(context);
-        let validContext = true;
-        identifiers.some(function (element) {
-            if (!keys.includes(element.value) && !isTransform(element.value)) {
-                validContext = false;
-                logger.warn(
-                    logContext,
-                    'For expression "[%s]" context does not have element %s',
-                    expression,
-                    element.value
-                );
-            }
-            // FIXME: Workaround to allow keys of JSON geopoints
-            if (element.value === 'type' || element.value === 'coordinates') {
-                validContext = true;
-            }
-            return validContext === false;
-        });
-        if (validContext) {
-            jexl.evalSync(expression, context);
-        }
-        return validContext;
+        jexl.evalSync(expression, context);
+        return true;
     } catch (e) {
         error = new errors.InvalidExpression(expression);
         throw error;
@@ -196,7 +154,53 @@ function processExpressionAttributes(typeInformation, list, context) {
         .map(expressionApplier(context, typeInformation));
 }
 
+function checkTransformationMap(tranformsMap) {
+    let error = null;
+    let message = 'No trasformations were added to JEXL Parser';
+    let resultMap = {};
+
+    if (typeof tranformsMap != 'object') {
+        error = true;
+    } else if (
+        tranformsMap === null ||
+        (tranformsMap && Object.keys(tranformsMap).length === 0 && tranformsMap.constructor === Object)
+    ) {
+        //default
+    } else {
+        //detecting wrong transformations
+        let wrongList = [];
+        for (var transformation in tranformsMap) {
+            if (typeof tranformsMap[transformation] != 'function') {
+                wrongList.push(transformation);
+            } else {
+                resultMap[transformation] = tranformsMap[transformation];
+            }
+        }
+        if (wrongList.length === 0) {
+            message = 'Trasformations can be added to JEXL parser';
+        } else {
+            message = wrongList.toString() + ' must be a function';
+        }
+    }
+    return [error, message, resultMap];
+}
+
+function setTransforms(configMap) {
+    //Check provided transforms since they are provided by user
+    //Note that in case of name conflict, baseTransformsMap would take precedence
+    const tranformsMap = { ...configMap, ...baseTranformsMap };
+    var [error, message, cleanTranformsMap] = checkTransformationMap(tranformsMap);
+    if (!error) {
+        //merge baseTransformation with provided map
+        jexl.addTransforms(cleanTranformsMap);
+    }
+    logger.info(logContext, message);
+}
+
 exports.extractContext = extractContext;
 exports.processExpressionAttributes = processExpressionAttributes;
+exports.contextAvailable = contextAvailable;
 exports.applyExpression = applyExpression;
 exports.parse = parse;
+exports.checkTransformationMap = checkTransformationMap;
+exports.setTransforms = setTransforms;