iotagent-node-lib 4.7.0 → 4.9.0

package/lib/jexlTranformsMap.js

@@ -26,63 +26,210 @@
 JEXL avaliable transformations*/
 
 const map = {
-    jsonparse: (str) => JSON.parse(str),
-    jsonstringify: (obj) => JSON.stringify(obj),
+    jsonparse: (val) => {
+        const safeOperation =
+            (fn) =>
+            (...args) => {
+                try {
+                    return fn(...args);
+                } catch (e) {
+                    return null;
+                }
+            };
+        return safeOperation(JSON.parse)(val);
+    },
+    jsonstringify: (val) => {
+        const safeOperation =
+            (fn) =>
+            (...args) => {
+                try {
+                    return fn(...args);
+                } catch (e) {
+                    return null;
+                }
+            };
+        return safeOperation(JSON.stringify)(val);
+    },
     indexOf: (val, char) => String(val).indexOf(char),
     length: (val) => String(val).length,
     trim: (val) => String(val).trim(),
     substr: (val, int1, int2) => String(val).substr(int1, int2),
-    addreduce: (arr) => arr.reduce((i, v) => i + v),
+    addreduce: (arr) => {
+        const safeOperation =
+            (fn) =>
+            (...args) => {
+                try {
+                    return fn(...args);
+                } catch (e) {
+                    return null;
+                }
+            };
+        return safeOperation((arr) => arr.reduce((i, v) => i + v))(arr);
+    },
     lengtharray: (arr) => arr.length,
     typeof: (val) => typeof val,
-    isarray: (arr) => Array.isArray(arr),
-    isnan: (val) => isNaN(val),
-    parseint: (val) => parseInt(val),
-    parsefloat: (val) => parseFloat(val),
-    toisodate: (val) => new Date(val).toISOString(),
-    timeoffset: (isostr) => new Date(isostr).getTimezoneOffset(),
-    tostring: (val) => val.toString(),
-    urlencode: (val) => encodeURI(val),
-    urldecode: (val) => decodeURI(val),
+    isarray: Array.isArray,
+    isnan: isNaN,
+    parseint: (val) => {
+        const safeParseNumber = (fn) => (val) => {
+            const result = fn(val);
+            return isNaN(result) ? null : result;
+        };
+        return safeParseNumber((val) => parseInt(val, 10))(val);
+    },
+    parsefloat: (val) => {
+        const safeParseNumber = (fn) => (val) => {
+            const result = fn(val);
+            return isNaN(result) ? null : result;
+        };
+        return safeParseNumber(parseFloat)(val);
+    },
+    toisodate: (val) => {
+        const safeDateOperation = (fn) => (val) => {
+            const date = new Date(val);
+            return isNaN(date.getTime()) ? null : fn(date);
+        };
+        return safeDateOperation((date) => date.toISOString())(val);
+    },
+    timeoffset: (val) => {
+        const safeDateOperation = (fn) => (val) => {
+            const date = new Date(val);
+            return isNaN(date.getTime()) ? null : fn(date);
+        };
+        return safeDateOperation((date) => date.getTimezoneOffset())(val);
+    },
+    tostring: (val) => {
+        const safeOperation =
+            (fn) =>
+            (...args) => {
+                try {
+                    return fn(...args);
+                } catch (e) {
+                    return null;
+                }
+            };
+        return safeOperation((val) => val.toString())(val);
+    },
+    urlencode: encodeURI,
+    urldecode: (val) => {
+        const safeOperation =
+            (fn) =>
+            (...args) => {
+                try {
+                    return fn(...args);
+                } catch (e) {
+                    return null;
+                }
+            };
+        return safeOperation(decodeURI)(val);
+    },
     replacestr: (str, from, to) => str.replace(from, to),
-    replaceregexp: (str, reg, to) => str.replace(new RegExp(reg), to),
-    replaceallstr: (str, from, to) => str.replaceAll(from, to),
-    replaceallregexp: (str, reg, to) => str.replaceAll(new RegExp(reg, 'g'), to),
+    replaceregexp: (str, reg, to) => {
+        const safeOperation =
+            (fn) =>
+            (...args) => {
+                try {
+                    return fn(...args);
+                } catch (e) {
+                    return null;
+                }
+            };
+        return safeOperation((str, reg, to) => str.replace(new RegExp(reg), to))(str, reg, to);
+    },
+    replaceallregexp: (str, reg, to) => {
+        const safeOperation =
+            (fn) =>
+            (...args) => {
+                try {
+                    return fn(...args);
+                } catch (e) {
+                    return null;
+                }
+            };
+        return safeOperation((str, reg, to) => str.replace(new RegExp(reg, 'g'), to))(str, reg, 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[
-            values.reduce((acc, curr, i) => (acc === 0 || acc ? acc : val <= curr ? (acc = i) : (acc = null)), null)
-        ],
+        choices[values.reduce((acc, curr, i) => (acc !== null ? acc : val <= curr ? i : null), null)],
     bitwisemask: (i, mask, op, shf) =>
         (op === '&' ? parseInt(i) & mask : op === '|' ? parseInt(i) | mask : op === '^' ? parseInt(i) ^ mask : i) >>
         shf,
     slice: (arr, init, end) => arr.slice(init, end),
-    addset: (arr, x) => {
-        return Array.from(new Set(arr).add(x));
-    },
+    addset: (arr, x) => Array.from(new Set(arr).add(x)),
     removeset: (arr, x) => {
-        let s = new Set(arr);
+        const s = new Set(arr);
         s.delete(x);
         return Array.from(s);
     },
     touppercase: (val) => String(val).toUpperCase(),
     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(),
-    hextostring: (val) =>
-        new TextDecoder().decode(new Uint8Array(val.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)))),
-    valuePicker: (val,pick) => Object.entries(val).filter(([, v]) => v === pick).map(([k,]) => k),
-    valuePickerMulti: (val,pick) => Object.entries(val).filter(([, v]) => pick.includes(v)).map(([k,]) => k)
+    floor: Math.floor,
+    ceil: Math.ceil,
+    round: Math.round,
+    tofixed: (val, decimals) => {
+        const num = Number.parseFloat(val);
+        const dec = Number.parseInt(decimals);
+        return isNaN(num) || isNaN(dec) ? null : num.toFixed(dec);
+    },
+    gettime: (val) => {
+        const safeDateOperation = (fn) => (val) => {
+            const date = new Date(val);
+            return isNaN(date.getTime()) ? null : fn(date);
+        };
+        return safeDateOperation((date) => date.getTime())(val);
+    },
+    toisostring: (val) => {
+        const safeDateOperation = (fn) => (val) => {
+            const date = new Date(val);
+            return isNaN(date.getTime()) ? null : fn(date);
+        };
+        return safeDateOperation((date) => date.toISOString())(val);
+    },
+    localestring: (d, timezone, options) => {
+        const safeOperation =
+            (fn) =>
+            (...args) => {
+                try {
+                    return fn(...args);
+                } catch (e) {
+                    return null;
+                }
+            };
+        return safeOperation((d, timezone, options) => new Date(d).toLocaleString(timezone, options))(
+            d,
+            timezone,
+            options
+        );
+    },
+    now: Date.now,
+    hextostring: (val) => {
+        const safeOperation =
+            (fn) =>
+            (...args) => {
+                try {
+                    return fn(...args);
+                } catch (e) {
+                    return null;
+                }
+            };
+        return safeOperation((val) => {
+            if (typeof val !== 'string' || !/^[0-9a-fA-F]+$/.test(val) || val.length % 2 !== 0) {
+                return null;
+            }
+            return new TextDecoder().decode(new Uint8Array(val.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))));
+        })(val);
+    },
+    valuePicker: (val, pick) =>
+        Object.entries(val)
+            .filter(([, v]) => v === pick)
+            .map(([k]) => k),
+    valuePickerMulti: (val, pick) =>
+        Object.entries(val)
+            .filter(([, v]) => pick.includes(v))
+            .map(([k]) => k)
 };
 
 exports.map = map;

package/lib/model/Command.js

@@ -31,6 +31,15 @@ const Command = new Schema({
     value: Object,
     service: { type: String, lowercase: true },
     subservice: String,
+    execTs: { type: Date },
+    status: String,
+    info: String,
+    onDelivered: Object,
+    onOk: Object,
+    onError: Object,
+    onInfo: Object,
+    cmdExecution: Boolean,
+    dateExpiration: { type: Date },
     creationDate: { type: Date, default: Date.now }
 });
 

package/lib/model/Device.js

@@ -61,6 +61,7 @@ const Device = new Schema({
 });
 
 function load() {
+    Device.index({ service: 1, subservice: 1, apikey: 1, id: 1 }, { unique: true });
     module.exports.model = mongoose.model('Device', Device);
     module.exports.internalSchema = Device;
 }

package/lib/services/commands/commandRegistryMongoDB.js

@@ -89,7 +89,21 @@ function updateCommand(service, subservice, deviceId, command, callback) {
 function createCommand(service, subservice, deviceId, command, callback) {
     /* eslint-disable-next-line new-cap */
     const commandObj = new Command.model();
-    const attributeList = ['name', 'type', 'value'];
+    const attributeList = [
+        'name',
+        'type',
+        'value',
+        // new Command fields
+        'execTs',
+        'status',
+        'info',
+        'onDelivered',
+        'onOk',
+        'onError',
+        'onInfo',
+        'cmdExecution',
+        'dateExpiration'
+    ];
 
     for (let i = 0; i < attributeList.length; i++) {
         commandObj[attributeList[i]] = command[attributeList[i]];

package/lib/services/commands/commandService.js

@@ -43,7 +43,7 @@ function listCommands(service, subservice, deviceId, callback) {
 }
 
 function addCommand(service, subservice, deviceId, command, callback) {
-    logger.debug(context, 'Adding command [%j] to the queue for device [%s]', command, deviceId);
+    logger.debug(context, 'Adding command [%j] to the queue for deviceId [%s]', command, deviceId);
     config.getCommandRegistry().add(service, subservice, deviceId, command, callback);
 }
 
@@ -73,13 +73,13 @@ function addCommandDevice(service, subservice, device, 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);
+    logger.debug(context, 'Updating command [%s] for deviceId [%s] with value [%s]', name, deviceId, value);
 
     config.getCommandRegistry().update(service, subservice, deviceId, value, callback);
 }
 
 function removeCommand(service, subservice, deviceId, name, callback) {
-    logger.debug(context, 'Removing command [%s] from device [%s]', name, deviceId);
+    logger.debug(context, 'Removing command [%s] from deviceId [%s]', name, deviceId);
 
     config.getCommandRegistry().remove(service, subservice, deviceId, name, callback);
 }

package/lib/services/common/domain.js

@@ -68,7 +68,7 @@ function requestDomain(req, res, next) {
     reqDomain.path = req.path;
     reqDomain.op = req.url;
     reqDomain.start = Date.now();
-
+    reqDomain.from = req.ip || req.connection.remoteAddress;
     reqDomain.add(req);
     reqDomain.add(res);
 
@@ -145,14 +145,15 @@ function ensureSouthboundTransaction(context, callback) {
         if (context.op) {
             reqDomain.op = context.op;
         }
-
         if (context.srv) {
             reqDomain.service = context.srv;
         }
-
         if (context.subsrv) {
             reqDomain.subservice = context.subsrv;
         }
+        if (context.from) {
+            reqDomain.from = context.from;
+        }
     }
 
     return reqDomain.run(callback);

package/lib/services/devices/deviceRegistryMongoDB.js

@@ -90,7 +90,7 @@ function storeDevice(newDevice, callback) {
             if (error.code === 11000) {
                 logger.debug(context, 'Tried to insert a device with duplicate ID in the database: %s', error);
 
-                callback(new errors.DuplicateDeviceId(newDevice));
+                callback(new errors.DuplicateDeviceId(newDevice), newDevice);
             } else {
                 logger.debug(context, 'Error storing device information: %s', error);
 

package/lib/services/devices/deviceService.js

@@ -40,6 +40,8 @@ const registrationUtils = require('./registrationUtils');
 const subscriptions = require('../ngsi/subscriptionService');
 const expressionPlugin = require('./../../plugins/expressionPlugin');
 const pluginUtils = require('./../../plugins/pluginUtils');
+const alarms = require('../common/alarmManagement');
+const constants = require('../../constants');
 const _ = require('underscore');
 const context = {
     op: 'IoTAgentNGSI.DeviceService'
@@ -250,7 +252,7 @@ function registerDevice(deviceObj, callback) {
             /* eslint-disable-next-line no-unused-vars */
             function (error, device) {
                 if (!error) {
-                    innerCb(new errors.DuplicateDeviceId(deviceObj));
+                    innerCb(new errors.DuplicateDeviceId(deviceObj), device);
                 } else {
                     innerCb();
                 }
@@ -664,7 +666,14 @@ function findOrCreate(deviceId, apikey, group, callback) {
             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);
+                    if (error && error.name === 'DUPLICATE_DEVICE_ID') {
+                        alarms.release(constants.MONGO_ALARM, error);
+                        logger.warn(context, 'Error %j already registered autoprovisioned device: %j ', error, device);
+                        callback(null, device, group);
+                    } else {
+                        logger.debug(context, 'registered autoprovisioned device: %j ', device);
+                        callback(error, device, group);
+                    }
                 });
             } else {
                 logger.info(

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

@@ -33,7 +33,6 @@ const logger = require('logops');
 const config = require('../../commonConfig');
 const ngsiLD = require('../ngsi/entities-NGSI-LD');
 const utils = require('../northBound/restUtils');
-const moment = require('moment');
 const _ = require('underscore');
 const registrationUtils = require('./registrationUtils');
 const NGSIv2 = require('./devices-NGSI-v2');
@@ -153,7 +152,7 @@ function updateEntityNgsiLD(deviceData, updatedDevice, callback) {
     ) {
         options.json[constants.TIMESTAMP_ATTRIBUTE] = {
             type: constants.TIMESTAMP_TYPE_NGSI2,
-            value: moment()
+            value: new Date().toISOString()
         };
     }
 

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

@@ -41,7 +41,6 @@ const registrationUtils = require('./registrationUtils');
 const _ = require('underscore');
 const utils = require('../northBound/restUtils');
 const NGSIv2 = require('../ngsi/entities-NGSI-v2');
-const moment = require('moment');
 const context = {
     op: 'IoTAgentNGSI.Devices-v2'
 };
@@ -222,7 +221,7 @@ function updateEntityNgsi2(deviceData, updatedDevice, callback) {
     ) {
         options.json[constants.TIMESTAMP_ATTRIBUTE] = {
             type: constants.TIMESTAMP_TYPE_NGSI2,
-            value: moment()
+            value: new Date().toISOString()
         };
     }
 

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

@@ -59,10 +59,13 @@ function convertAttrNGSILD(attr) {
         return undefined;
     }
     let obj = { type: 'Property', value: attr.value };
+    let hasValueType = true;
 
     switch (attr.type.toLowerCase()) {
         // Properties
         case 'property':
+            hasValueType = false;
+            break;
         case 'string':
         case 'text':
         case 'textunrestricted':
@@ -96,24 +99,26 @@ function convertAttrNGSILD(attr) {
             }
             break;
 
+        case 'object':
+        case 'array':
+            try {
+                obj.value = JSON.parse(attr.value);
+            } catch (e) {
+                // Do nothing
+            }
+            break;
+
         // Temporal Properties
         case 'datetime':
-            obj.value = {
-                '@type': 'DateTime',
-                '@value': moment.tz(attr.value, 'Etc/UTC').toISOString()
-            };
+            obj.value = moment.tz(attr.value, 'Etc/UTC').toISOString();
             break;
         case 'date':
-            obj.value = {
-                '@type': 'Date',
-                '@value': moment.tz(attr.value, 'Etc/UTC').format(moment.HTML5_FMT.DATE)
-            };
+            obj.value = moment.tz(attr.value, 'Etc/UTC').format(moment.HTML5_FMT.DATE);
             break;
         case 'time':
-            obj.value = {
-                '@type': 'Time',
-                '@value': moment.tz(attr.value, 'Etc/UTC').format(moment.HTML5_FMT.TIME_SECONDS)
-            };
+            obj.value = moment
+                .tz(new Date('0000-01-01 ' + attr.value), 'Etc/UTC')
+                .format(moment.HTML5_FMT.TIME_SECONDS);
             break;
 
         // GeoProperties
@@ -121,37 +126,44 @@ function convertAttrNGSILD(attr) {
         case 'point':
         case 'geo:point':
         case 'geo:json':
+            hasValueType = false;
             obj.type = 'GeoProperty';
             obj.value = NGSIUtils.getLngLats('Point', attr.value);
             break;
         case 'linestring':
         case 'geo:linestring':
+            hasValueType = false;
             obj.type = 'GeoProperty';
             obj.value = NGSIUtils.getLngLats('LineString', attr.value);
             break;
         case 'polygon':
         case 'geo:polygon':
+            hasValueType = false;
             obj.type = 'GeoProperty';
             obj.value = NGSIUtils.getLngLats('Polygon', attr.value);
             break;
         case 'multipoint':
         case 'geo:multipoint':
+            hasValueType = false;
             obj.type = 'GeoProperty';
             obj.value = NGSIUtils.getLngLats('MultiPoint', attr.value);
             break;
         case 'multilinestring':
         case 'geo:multilinestring':
+            hasValueType = false;
             obj.type = 'GeoProperty';
             obj.value = NGSIUtils.getLngLats('MultiLineString', attr.value);
             break;
         case 'multipolygon':
         case 'geo:multipolygon':
+            hasValueType = false;
             obj.type = 'GeoProperty';
             obj.value = NGSIUtils.getLngLats('MultiPolygon', attr.value);
             break;
 
         // Relationships
         case 'relationship':
+            hasValueType = false;
             obj.type = 'Relationship';
             obj.object = attr.value;
             delete obj.value;
@@ -159,13 +171,57 @@ function convertAttrNGSILD(attr) {
 
         // LanguageProperties
         case 'languageproperty':
+            hasValueType = false;
             obj.type = 'LanguageProperty';
             obj.languageMap = attr.value;
             delete obj.value;
             break;
 
+        // VocabProperties
+        case 'vocabproperty':
+            hasValueType = false;
+            obj.type = 'VocabProperty';
+            obj.vocab = attr.value;
+            delete obj.value;
+            break;
+        // JsonProperties
+        case 'jsonproperty':
+            hasValueType = false;
+            obj.type = 'JsonProperty';
+            obj.json = attr.value;
+            delete obj.value;
+            break;
+        // ListProperties
+        case 'listproperty':
+            hasValueType = false;
+            obj.type = 'ListProperty';
+            obj.listValue = attr.value;
+            delete obj.value;
+            break;
+        // ListRelationship
+        case 'listrelationship':
+            hasValueType = false;
+            obj.type = 'ListRelationship';
+            obj.listObject = attr.value;
+            delete obj.value;
+            break;
+
         default:
-            obj.value = { '@type': attr.type, '@value': attr.value };
+            obj.value = attr.value;
+    }
+
+    if (hasValueType) {
+        switch (config.getConfig().server.ldSupport.dataType) {
+            case '@type':
+                obj.value = {
+                    '@type': attr.type,
+                    '@value': obj.value
+                };
+                break;
+            case 'valueType':
+                obj.valueType = attr.type;
+                break;
+        }
     }
 
     if (!!obj && attr.metadata) {

package/lib/services/ngsi/ngsiService.js

@@ -95,7 +95,9 @@ function sendUpdateValue(entityName, attributes, typeInformation, token, callbac
     // check config about store last measure
     if (typeInformation.storeLastMeasure) {
         logger.debug(context, 'StoreLastMeasure for %j', typeInformation);
-        deviceService.storeDeviceField('lastMeasure', attributes, typeInformation, function () {
+        let originalMeasure = typeInformation.originalMeasure ? typeInformation.originalMeasure : null;
+        deviceService.storeDeviceField('lastMeasure', originalMeasure, typeInformation, function () {
+            delete typeInformation.originalMeasure;
             return entityHandler.sendUpdateValue(entityName, attributes, typeInformation, token, wrappedNewCallback);
         });
     } else {

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

@@ -46,7 +46,7 @@ const config = require('../../commonConfig');
 
 const overwritePaths = ['/ngsi-ld/v1/entities/:entity/attrs', '/ngsi-ld/v1/entities/:entity/attrs/:attr'];
 const updatePaths = ['/ngsi-ld/v1/entities/:entity/attrs', '/ngsi-ld/v1/entities/:entity/attrs/:attr'];
-const queryPaths = ['/ngsi-ld/v1/entities/:entity'];
+const queryPaths = ['/ngsi-ld/v1/entities/:entity', '/ngsi-ld/v1/entities'];
 
 /**
  * Replacement of NGSI-LD Null placeholders with real null values
@@ -506,6 +506,9 @@ function handleMergePatchNgsiLD(req, res, next) {
  * @param {Object} res              Response that will be sent.
  */
 function handleQueryNgsiLD(req, res, next) {
+    const returnAsArray = req.query.id;
+    req.params.entity = req.params.entity || req.query.id || '';
+
     function getName(element) {
         return element.name;
     }
@@ -641,7 +644,7 @@ function handleQueryNgsiLD(req, res, next) {
             next(error);
         } else {
             logger.debug(context, 'Query from [%s] handled successfully.', req.get('host'));
-            res.status(200).json(result);
+            res.status(200).json(returnAsArray ? [result] : result);
         }
     }
 
@@ -793,7 +796,6 @@ 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);

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

@@ -292,9 +292,18 @@ function handleNotificationNgsi2(req, res, next) {
                 }
             }
         }
+        logger.debug(context, 'extracted atts %j from dataElement %j', atts, dataElement);
+        var id = null;
+        var type = null;
+        if (dataElement.targetEntityId && dataElement.targetEntityId.value) {
+            id = dataElement.targetEntityId.value;
+        }
+        if (dataElement.targetEntityType && dataElement.targetEntityType.value) {
+            type = dataElement.targetEntityType.value;
+        }
         deviceService.getDeviceByNameAndType(
-            dataElement.id,
-            dataElement.type,
+            id,
+            type,
             req.headers['fiware-service'],
             req.headers['fiware-servicepath'],
             function (error, device) {
@@ -336,7 +345,7 @@ function handleNotificationNgsi2(req, res, next) {
             logger.error(context, 'Error found when processing notification: %j', error);
             next(error);
         } else {
-            res.status(200).json({});
+            res.status(204).json();
         }
     }