iotagent-node-lib 4.7.0 → 4.8.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/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/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();
         }
     }
 

package/lib/services/northBound/contextServer.js

@@ -30,7 +30,7 @@ const context = {
     op: 'IoTAgentNGSI.ContextServer'
 };
 const contextServerUtils = require('./contextServerUtils');
-
+const executeUpdateSideEffects = contextServerUtils.executeUpdateSideEffects;
 let contextServerHandler;
 
 /**
@@ -157,4 +157,5 @@ exports.setCommandHandler = intoTrans(context, setCommandHandler);
 exports.setNotificationHandler = intoTrans(context, setNotificationHandler);
 exports.addNotificationMiddleware = intoTrans(context, addNotificationMiddleware);
 exports.setQueryHandler = intoTrans(context, setQueryHandler);
+exports.executeUpdateSideEffects = intoTrans(context, executeUpdateSideEffects);
 exports.init = init;

package/lib/services/northBound/northboundServer.js

@@ -125,6 +125,7 @@ exports.setRemoveDeviceHandler = intoTrans(context, deviceProvisioning.setRemove
 exports.addDeviceProvisionMiddleware = deviceProvisioning.addDeviceProvisionMiddleware;
 exports.addConfigurationProvisionMiddleware = groupProvisioning.addConfigurationProvisionMiddleware;
 exports.addNotificationMiddleware = contextServer.addNotificationMiddleware;
+exports.executeUpdateSideEffects = contextServer.executeUpdateSideEffects;
 exports.clear = clear;
 exports.start = intoTrans(context, start);
 exports.stop = intoTrans(context, stop);

package/lib/templates/createDevice.json

@@ -167,6 +167,10 @@
                     "description": "Content type",
                     "type": "string"
                 },
+                "headers": {
+                  "description": "Optional headers to include with command",
+                  "type": "object"
+                },
                 "mqtt": {
                   "description": "Mqtt properties",
                   "type": "object",

package/lib/templates/updateDevice.json

@@ -145,6 +145,10 @@
               "description": "Optional expression for command transformation",
               "type": "string"
           },
+          "headers": {
+              "description": "Optional headers to include with command",
+              "type": "object"
+          },
           "payloadType": {
               "description": "Payload type",
               "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": "4.7.0",
+  "version": "4.8.0",
   "homepage": "https://github.com/telefonicaid/iotagent-node-lib",
   "keywords": [
     "fiware",

package/test/functional/testUtils.js

@@ -74,16 +74,27 @@ function sendMeasureIotaLib(measure, provision) {
          *  This is not a problem for the tests using other transports than Lib, in that case, the type will be retrieved
          *  from the real provision.
          */
+        let typeInformation = {
+            service: provision.headers['fiware-service'],
+            subservice: provision.headers['fiware-servicepath']
+        };
         let type;
+        let staticAttrs;
         if (Array.isArray(provision.json.services) && provision.json.services.length > 0) {
             type = provision.json.services[0].entity_type;
+            staticAttrs = provision.json.services[0].static_attributes;
         } else {
             type = DEF_TYPE;
         }
+        typeInformation.type = type;
+        if (staticAttrs) {
+            typeInformation.staticAttributes = staticAttrs;
+        }
+        typeInformation.id = measure.qs.i;
         iotAgentLib.update(
             type + ':' + measure.qs.i,
             type,
-            '',
+            typeInformation,
             jsonToIotaMeasures(measure.json),
             function (error, result, body) {
                 error ? reject(error) : resolve(result);
@@ -230,7 +241,7 @@ async function testCase(measure, expectation, provision, env, config, type, tran
     if (transport === 'MQTT') {
         try {
             let client = await MQTT.connectAsync('mqtt://' + config.mqtt.host);
-            await client.publish('/' + measure.qs.k + '/' + measure.qs.i + '/attrs', JSON.stringify(measure.json));
+            await client.publish('/json/' + measure.qs.k + '/' + measure.qs.i + '/attrs', JSON.stringify(measure.json));
             await client.end();
         } catch (error) {
             expect.fail(ERR_MQTT + error);

package/test/unit/expressions/jexlExpression-test.js

@@ -40,7 +40,12 @@ describe('Jexl expression interpreter', function () {
         object: {
             name: 'John',
             surname: 'Doe'
-        }
+        },
+        invalidJson: '{"name": "John", surname": "Doe"}', // Invalid JSON for jsonparse
+        invalidDate: 'invalid-date', // Invalid date for toisodate and other date functions
+        emptyArray: [], // Empty array for addreduce
+        invalidHex: 'zz', // Invalid hex string for hextostring
+        nonNumeric: 'not-a-number' // Non-numeric input for parseint, parsefloat
     };
 
     describe('When a expression with a single value is parsed', function () {
@@ -392,4 +397,163 @@ describe('Jexl expression interpreter', function () {
             });
         });
     });
+
+    // Check errors
+    describe('When invalid inputs are used', function () {
+        describe('When an invalid JSON string is parsed', function () {
+            it('should return null for jsonparse', function (done) {
+                expressionParser.parse('invalidJson|jsonparse', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+        });
+
+        describe('When an invalid date string is parsed', function () {
+            it('should return null for toisodate', function (done) {
+                expressionParser.parse('invalidDate|toisodate', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+
+            it('should return null for timeoffset', function (done) {
+                expressionParser.parse('invalidDate|timeoffset', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+        });
+
+        describe('When an empty array is processed with addreduce', function () {
+            it('should return null for addreduce', function (done) {
+                expressionParser.parse('emptyArray|addreduce', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+        });
+
+        describe('When a non-numeric string is parsed by parseint and parsefloat', function () {
+            it('should return null for parseint', function (done) {
+                expressionParser.parse('nonNumeric|parseint', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+
+            it('should return null for parsefloat', function (done) {
+                expressionParser.parse('nonNumeric|parsefloat', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+        });
+
+        describe('When an invalid hex string is processed by hextostring', function () {
+            it('should return null for hextostring', function (done) {
+                expressionParser.parse('invalidHex|hextostring', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+        });
+
+        describe('When invalid regular expressions are used in replace functions', function () {
+            it('should return null for replaceregexp with invalid regex', function (done) {
+                expressionParser.parse(
+                    'theString|replaceregexp("[a-z", "replacement")',
+                    scope,
+                    function (error, result) {
+                        should.not.exist(error);
+                        should(result).be.Null();
+                        done();
+                    }
+                );
+            });
+
+            it('should return null for replaceallregexp with invalid regex', function (done) {
+                expressionParser.parse(
+                    'theString|replaceallregexp("[a-z", "replacement")',
+                    scope,
+                    function (error, result) {
+                        should.not.exist(error);
+                        should(result).be.Null();
+                        done();
+                    }
+                );
+            });
+        });
+
+        describe('When tostring is used with null or undefined', function () {
+            it('should return null for tostring(null)', function (done) {
+                expressionParser.parse('null|tostring', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+
+            it('should return null for tostring(undefined)', function (done) {
+                expressionParser.parse('undefined|tostring', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+        });
+
+        describe('When urldecode is used with an invalid URI', function () {
+            it('should return null for urldecode with malformed URI', function (done) {
+                expressionParser.parse('"%%%invalidURI"|urldecode', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+        });
+
+        describe('When tofixed is used with invalid inputs', function () {
+            it('should return null for tofixed with non-numeric value', function (done) {
+                expressionParser.parse('"notANumber"|tofixed(2)', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+
+            it('should return null for tofixed with invalid decimal value', function (done) {
+                expressionParser.parse('"123.456"|tofixed("invalid")', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+        });
+
+        describe('When gettime is used with invalid date', function () {
+            it('should return null for gettime with invalid date string', function (done) {
+                expressionParser.parse('"invalidDate"|gettime', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+
+            it('should return null for gettime with null', function (done) {
+                expressionParser.parse('null|gettime', scope, function (error, result) {
+                    should.not.exist(error);
+                    should(result).be.Null();
+                    done();
+                });
+            });
+        });
+    });
 });