iotagent-node-lib 2.15.1 → 2.19.0

package/lib/services/groups/groupRegistryMemory.js

@@ -289,9 +289,11 @@ exports.find = intoTrans(context, find);
 exports.findBy = intoTrans(context, findBy);
 exports.findType = intoTrans(context, findBy(['service', 'subservice', 'type']));
 exports.findTypeSilently = intoTrans(context, findBy(['service', 'subservice', 'type']));
+exports.findSilently = intoTrans(context, findBy(['service', 'subservice']));
 exports.get = intoTrans(context, getSingleGroup);
 exports.getSilently = intoTrans(context, getSingleGroup);
 exports.getType = intoTrans(context, getSingleGroupType);
+exports.getTypeSilently = intoTrans(context, getSingleGroupType);
 exports.update = intoTrans(context, update);
 exports.remove = intoTrans(context, remove);
 exports.clear = intoTrans(context, clear);

package/lib/services/groups/groupRegistryMongoDB.js

@@ -36,6 +36,30 @@ let context = {
     op: 'IoTAgentNGSI.MongoDBGroupRegister'
 };
 
+const attributeList = [
+    'url',
+    'resource',
+    'apikey',
+    'type',
+    'service',
+    'subservice',
+    'description',
+    'trust',
+    'cbHost',
+    'timezone',
+    'timestamp',
+    'commands',
+    'lazy',
+    'attributes',
+    'staticAttributes',
+    'internalAttributes',
+    'autoprovision',
+    'explicitAttrs',
+    'expressionLanguage',
+    'defaultEntityNameConjunction',
+    'ngsiVersion'
+];
+
 /**
  * Generates a handler for the save device group operations. The handler will take the customary error and the saved
  * device group as the parameters (and pass the serialized DAO as the callback value).
@@ -58,33 +82,10 @@ function saveGroupHandler(groupDAO, callback) {
 function createGroup(group, callback) {
     /* eslint-disable-next-line  new-cap */
     const groupObj = new Group.model();
-    const attributeList = [
-        'url',
-        'resource',
-        'apikey',
-        'type',
-        'service',
-        'subservice',
-        'description',
-        'trust',
-        'cbHost',
-        'timezone',
-        'timestamp',
-        'commands',
-        'lazy',
-        'attributes',
-        'staticAttributes',
-        'internalAttributes',
-        'autoprovision',
-        'explicitAttrs',
-        'expressionLanguage',
-        'defaultEntityNameConjunction',
-        'ngsiVersion'
-    ];
-
-    for (let i = 0; i < attributeList.length; i++) {
-        groupObj[attributeList[i]] = group[attributeList[i]];
-    }
+
+    attributeList.forEach((key) => {
+        groupObj[key] = group[key];
+    });
 
     logger.debug(
         context,
@@ -163,7 +164,7 @@ function getById(id, callback) {
     const query = Group.model.findOne({ _id: id });
     query.select({ __v: 0 });
 
-    query.exec(function handleGet(error, data) {
+    query.lean().exec(function handleGet(error, data) {
         if (error) {
             logger.debug(context, 'Internal MongoDB Error getting group: %s', error);
 
@@ -210,6 +211,24 @@ function find(service, subservice, callback) {
     });
 }
 
+function findOneInMongoDB(queryObj, fields, callback) {
+    const query = Group.model.findOne(queryObj);
+    query.select({ __v: 0 });
+    query.lean().exec(function handleGet(error, data) {
+        if (error) {
+            logger.debug(context, 'Internal MongoDB Error getting group: %s', error);
+            callback(new errors.InternalDbError(error));
+        } else if (data) {
+            context = fillService(context, data);
+            logger.debug(context, 'Device group data found: %j', data);
+            callback(null, data);
+        } else {
+            logger.debug(context, 'Device group for fields [%j] not found: [%j]', fields, queryObj);
+            callback(new errors.DeviceGroupNotFound(fields, queryObj));
+        }
+    });
+}
+
 function findBy(fields) {
     return function () {
         const queryObj = {};
@@ -228,24 +247,7 @@ function findBy(fields) {
 
         context = fillService(context, { service: 'n/a', subservice: 'n/a' });
         logger.debug(context, 'Looking for group params %j with queryObj %j', fields, queryObj);
-        const query = Group.model.findOne(queryObj);
-
-        query.select({ __v: 0 });
-
-        query.exec(function handleGet(error, data) {
-            if (error) {
-                logger.debug(context, 'Internal MongoDB Error getting group: %s', error);
-                callback(new errors.InternalDbError(error));
-            } else if (data) {
-                context = fillService(context, data);
-                logger.debug(context, 'Device group data found: %j', data.toObject());
-                callback(null, data.toObject());
-            } else {
-                logger.debug(context, 'Device group for fields [%j] not found: [%j]', fields, queryObj);
-
-                callback(new errors.DeviceGroupNotFound(fields, queryObj));
-            }
-        });
+        findOneInMongoDB(queryObj, fields, callback);
     };
 }
 
@@ -255,36 +257,15 @@ function update(id, body, callback) {
         if (error) {
             callback(error);
         } else {
-            const attributes = [
-                'url',
-                'apikey',
-                'type',
-                'service',
-                'subservice',
-                'description',
-                'trust',
-                'cbHost',
-                'timezone',
-                'timestamp',
-                'commands',
-                'lazy',
-                'attributes',
-                'staticAttributes',
-                'internalAttributes',
-                'explicitAttrs',
-                'expressionLanguage',
-                'defaultEntityNameConjunction',
-                'ngsiVersion'
-            ];
-
-            for (let i = 0; i < attributes.length; i++) {
-                if (body[attributes[i]] !== undefined) {
-                    group[attributes[i]] = body[attributes[i]];
+            attributeList.forEach((key) => {
+                if (body[key] !== undefined) {
+                    group[key] = body[key];
                 }
-            }
-
-            group.isNew = false;
-            group.save(saveGroupHandler(group, callback));
+            });
+            /* eslint-disable-next-line  new-cap */
+            const groupObj = new Group.model(group);
+            groupObj.isNew = false;
+            groupObj.save(saveGroupHandler(groupObj, callback));
         }
     });
 }
@@ -303,7 +284,6 @@ function remove(id, callback) {
                     callback(new errors.InternalDbError(error));
                 } else {
                     logger.debug(context, 'Device [%s] successfully removed.', id);
-
                     callback(null, deviceGroup);
                 }
             });
@@ -328,10 +308,12 @@ exports.findType = alarmsInt(
     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.getSilently = intoTrans(context, findBy(['resource', 'apikey']));
 exports.getType = alarmsInt(constants.MONGO_ALARM, 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));

package/lib/services/groups/groupService.js

@@ -46,7 +46,7 @@ function validateGroup(group, callback) {
 
     function generateDuplicateHandler(innerCb) {
         return function (error, foundGroup) {
-            logger.debug(context, 'generateDuplicateHander error %s and foundGroup %j', error, foundGroup);
+            logger.debug(context, 'generateDuplicateHander error %j and foundGroup %j', error, foundGroup);
             if (!error || (foundGroup && foundGroup.count > 0)) {
                 innerCb(new errors.DuplicateGroup(group.resource, group.apikey));
             } else {

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

@@ -25,7 +25,7 @@
 
 /* eslint-disable consistent-return */
 
-const request = require('request');
+const request = require('../../request-shim');
 const statsService = require('./../stats/statsRegistry');
 const async = require('async');
 const apply = async.apply;
@@ -34,6 +34,7 @@ const errors = require('../../errors');
 const utils = require('../northBound/restUtils');
 const config = require('../../commonConfig');
 const constants = require('../../constants');
+const jexlParser = require('../../plugins/jexlParser');
 const moment = require('moment-timezone');
 const logger = require('logops');
 const _ = require('underscore');
@@ -43,19 +44,8 @@ const context = {
 const NGSIv2 = require('./entities-NGSI-v2');
 const NGSIUtils = require('./ngsiUtils');
 
-const NGSI_LD_NULL = { '@type': 'Intangible', '@value': null };
 const NGSI_LD_URN = 'urn:ngsi-ld:';
 
-/**
- * Determines if a value is a number - Not a Number replaced by Null
- *
- * @param      {String}   value       Value to be analyzed
- * @return     {Number}
- */
-function valueOfOrNull(value) {
-    return isNaN(value) ? NGSI_LD_NULL : value;
-}
-
 /**
  * Amends an NGSIv2 attribute to NGSI-LD format
  * All native JSON types are respected and cast as Property values
@@ -66,100 +56,112 @@ function valueOfOrNull(value) {
  *                                   format
  */
 
-function convertNGSIv2ToLD(attr) {
-    const obj = { type: 'Property', value: attr.value };
-
-    if (attr.value === null){
-        obj.value = NGSI_LD_NULL;
-    } else {
-        switch (attr.type.toLowerCase()) {
-            // Properties
-            case 'property':
-            case 'string':
-                break;
-
-            // Other Native JSON Types
-            case 'boolean':
-                obj.value = !!attr.value;
-                break;
-            case 'float':
-                obj.value = valueOfOrNull(Number.parseFloat(attr.value));
-                break;
-            case 'integer':
-                obj.value = valueOfOrNull(Number.parseInt(attr.value));
-                break;
-            case 'number':
-                if (NGSIUtils.isFloat(attr.value)) {
-                    obj.value = valueOfOrNull(Number.parseFloat(attr.value));
-                } else {
-                    obj.value = valueOfOrNull(Number.parseInt(attr.value));
-                }
-                break;
-
-            // Temporal Properties
-            case 'datetime':
-                obj.value = {
-                    '@type': 'DateTime',
-                    '@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)
-                };
-                break;
-            case 'time':
-                obj.value = {
-                    '@type': 'Time',
-                    '@value': moment.tz(attr.value, 'Etc/UTC').format(moment.HTML5_FMT.TIME_SECONDS)
-                };
-                break;
-
-            // GeoProperties
-            case 'geoproperty':
-            case 'point':
-            case 'geo:point':
-            case 'geo:json':
-                obj.type = 'GeoProperty';
-                obj.value = NGSIUtils.getLngLats('Point', attr.value);
-                break;
-            case 'linestring':
-            case 'geo:linestring':
-                obj.type = 'GeoProperty';
-                obj.value = NGSIUtils.getLngLats('LineString', attr.value);
-                break;
-            case 'polygon':
-            case 'geo:polygon':
-                obj.type = 'GeoProperty';
-                obj.value = NGSIUtils.getLngLats('Polygon', attr.value);
-                break;
-            case 'multipoint':
-            case 'geo:multipoint':
-                obj.type = 'GeoProperty';
-                obj.value = NGSIUtils.getLngLats('MultiPoint', attr.value);;
-                break;
-            case 'multilinestring':
-            case 'geo:multilinestring':
-                obj.type = 'GeoProperty';
-                obj.value = NGSIUtils.getLngLats( 'MultiLineString', attr.value);
-                break;
-            case 'multipolygon':
-            case 'geo:multipolygon':
-                obj.type = 'GeoProperty';
-                obj.value = NGSIUtils.getLngLats( 'MultiPolygon', attr.value);
-                break;
-
-            // Relationships
-            case 'relationship':
-                obj.type = 'Relationship';
-                obj.object = attr.value;
-                delete obj.value;
-                break;
+function convertAttrNGSILD(attr) {
+    // eslint eqeqeq - deliberate double equals to include undefined.
+    if (attr.value == null || Number.isNaN(attr.value)) {
+        return undefined;
+    }
+    let obj = { type: 'Property', value: attr.value };
+
+    switch (attr.type.toLowerCase()) {
+        // Properties
+        case 'property':
+        case 'string':
+        case 'text':
+        case 'textunrestricted':
+            break;
+
+        // Other Native JSON Types
+        case 'boolean':
+            obj.value = !!attr.value;
+            break;
+        case 'float':
+            if (isNaN(attr.value)) {
+                obj = undefined;
+            } else {
+                obj.value = Number.parseFloat(attr.value);
+            }
+            break;
+        case 'integer':
+            if (isNaN(attr.value)) {
+                obj = undefined;
+            } else {
+                obj.value = Number.parseInt(attr.value);
+            }
+            break;
+        case 'number':
+            if (isNaN(attr.value)) {
+                obj = undefined;
+            } else if (NGSIUtils.isFloat(attr.value)) {
+                obj.value = Number.parseFloat(attr.value);
+            } else {
+                obj.value = Number.parseInt(attr.value);
+            }
+            break;
 
-            default:
-                obj.value = { '@type': attr.type, '@value': attr.value };
-        }
+        // Temporal Properties
+        case 'datetime':
+            obj.value = {
+                '@type': 'DateTime',
+                '@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)
+            };
+            break;
+        case 'time':
+            obj.value = {
+                '@type': 'Time',
+                '@value': moment.tz(attr.value, 'Etc/UTC').format(moment.HTML5_FMT.TIME_SECONDS)
+            };
+            break;
+
+        // GeoProperties
+        case 'geoproperty':
+        case 'point':
+        case 'geo:point':
+        case 'geo:json':
+            obj.type = 'GeoProperty';
+            obj.value = NGSIUtils.getLngLats('Point', attr.value);
+            break;
+        case 'linestring':
+        case 'geo:linestring':
+            obj.type = 'GeoProperty';
+            obj.value = NGSIUtils.getLngLats('LineString', attr.value);
+            break;
+        case 'polygon':
+        case 'geo:polygon':
+            obj.type = 'GeoProperty';
+            obj.value = NGSIUtils.getLngLats('Polygon', attr.value);
+            break;
+        case 'multipoint':
+        case 'geo:multipoint':
+            obj.type = 'GeoProperty';
+            obj.value = NGSIUtils.getLngLats('MultiPoint', attr.value);
+            break;
+        case 'multilinestring':
+        case 'geo:multilinestring':
+            obj.type = 'GeoProperty';
+            obj.value = NGSIUtils.getLngLats('MultiLineString', attr.value);
+            break;
+        case 'multipolygon':
+        case 'geo:multipolygon':
+            obj.type = 'GeoProperty';
+            obj.value = NGSIUtils.getLngLats('MultiPolygon', attr.value);
+            break;
+
+        // Relationships
+        case 'relationship':
+            obj.type = 'Relationship';
+            obj.object = attr.value;
+            delete obj.value;
+            break;
+
+        default:
+            obj.value = { '@type': attr.type, '@value': attr.value };
     }
 
     if (attr.metadata) {
@@ -178,7 +180,7 @@ function convertNGSIv2ToLD(attr) {
                     obj.unitCode = attr.metadata[key].value;
                     break;
                 default:
-                    obj[key] = convertNGSIv2ToLD(attr.metadata[key]);
+                    obj[key] = convertAttrNGSILD(attr.metadata[key]);
             }
         });
         delete obj.TimeInstant;
@@ -201,7 +203,7 @@ function formatAsNGSILD(json) {
             case 'id':
                 id = json[key];
                 obj[key] = id;
-                if (!id.startsWith(NGSI_LD_URN)){
+                if (!id.startsWith(NGSI_LD_URN)) {
                     obj[key] = NGSI_LD_URN + json.type + ':' + id;
                     logger.debug(context, 'Amending id to a valid URN: %s', obj[key]);
                 }
@@ -214,7 +216,7 @@ function formatAsNGSILD(json) {
                 // element for NSGI-LD.
                 break;
             default:
-                obj[key] = convertNGSIv2ToLD(json[key]);
+                obj[key] = convertAttrNGSILD(json[key]);
         }
     });
 
@@ -288,18 +290,15 @@ function generateNGSILDOperationHandler(operationName, entityName, typeInformati
             );
         } else if (response && body && response.statusCode === 404) {
             logger.info(context, 'Received the following response from the CB:\n\n%s\n\n', bodyAsString);
-
             logger.error(context, 'Operation ' + operationName + ' error connecting to the Context Broker: %j', body);
 
-            const errorField = NGSIUtils.getErrorField(body);
-            if (
-                response.statusCode &&
-                response.statusCode === 404 &&
-                errorField.details.includes(typeInformation.type)
-            ) {
+            let errorField = body.error;
+            if (body.description) {
+                errorField += ':' + body.description;
+            }
+
+            if (errorField !== undefined) {
                 callback(new errors.DeviceNotFound(entityName));
-            } else if (errorField.code && errorField.code === '404') {
-                callback(new errors.AttributeNotFound());
             } else {
                 callback(new errors.EntityGenericError(entityName, typeInformation.type, body));
             }
@@ -332,7 +331,6 @@ function sendQueryValueNgsiLD(entityName, attributes, typeInformation, token, ca
 
     const options = NGSIUtils.createRequestObject(url, typeInformation, token);
     options.method = 'GET';
-    options.json = true;
 
     if (!typeInformation || !typeInformation.type) {
         callback(new errors.TypeNotFound(null, entityName));
@@ -376,7 +374,7 @@ function addLinkedEntities(typeInformation, json) {
         return calculatedType;
     }
     const linkedTypeInfo = {};
-    if(typeInformation.staticAttributes){
+    if (typeInformation.staticAttributes) {
         typeInformation.staticAttributes.forEach((item) => {
             if (item.link) {
                 linkedTypeInfo[item.name] = item.link;
@@ -405,6 +403,90 @@ function addLinkedEntities(typeInformation, json) {
     });
 }
 
+/**
+ * Remove id, type and any hidden attrs after processing
+ *
+ * @param {Object} enities           Unprocessed entities
+ * @param {Object} typeInformation  Configuration information for the device.
+ */
+function removeHiddenAttrsFromMultiEntity(entities, typeInformation) {
+    var explicitAttrsList = [];
+    if (typeInformation.explicitAttrs) {
+        explicitAttrsList.push('type');
+        explicitAttrsList.push('id');
+        if (typeof typeInformation.explicitAttrs === 'boolean') {
+            if (typeInformation.timestamp) {
+                explicitAttrsList.push(constants.TIMESTAMP_ATTRIBUTE);
+            }
+            if (typeInformation.active) {
+                typeInformation.active.forEach((attr) => {
+                    explicitAttrsList.push(attr.name);
+                });
+            }
+            if (typeInformation.staticAttributes) {
+                typeInformation.staticAttributes.forEach((attr) => {
+                    explicitAttrsList.push(attr.name);
+                });
+            }
+        } else if (typeof typeInformation.explicitAttrs === 'string') {
+            entities.forEach((entity) => {
+                const attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
+                const ctx = jexlParser.extractContext(attsArray);
+                const res = jexlParser.parse(typeInformation.explicitAttrs, ctx);
+                explicitAttrsList = explicitAttrsList.concat(res);
+            });
+        }
+    }
+    if (explicitAttrsList.length > 0) {
+        entities.forEach((entity) => {
+            const hidden = _.difference(_.keys(entity), explicitAttrsList);
+            hidden.forEach((attr) => {
+                delete entity[attr];
+            });
+        });
+    }
+    return entities;
+}
+
+/**
+ * Remove id, type and any hidden attrs after processing
+ *
+ * @param {Object} result           Unprocessed entity
+ * @param {Object} typeInformation  Configuration information for the device.
+ */
+function removeHiddenAttrs(result, typeInformation) {
+    delete result.id;
+    delete result.type;
+    var explicitAttrsList = [];
+    if (typeInformation.explicitAttrs && typeof typeInformation.explicitAttrs === 'boolean') {
+        if (typeInformation.timestamp) {
+            explicitAttrsList.push(constants.TIMESTAMP_ATTRIBUTE);
+        }
+        if (typeInformation.active) {
+            typeInformation.active.forEach((attr) => {
+                explicitAttrsList.push(attr.name);
+            });
+        }
+        if (typeInformation.staticAttributes) {
+            typeInformation.staticAttributes.forEach((attr) => {
+                explicitAttrsList.push(attr.name);
+            });
+        }
+    } else if (typeInformation.explicitAttrs && typeof typeInformation.explicitAttrs === 'string') {
+        const attsArray = utils.extractAttributesArrayFromNgsi2Entity(result);
+        const ctx = jexlParser.extractContext(attsArray);
+        const res = jexlParser.parse(typeInformation.explicitAttrs, ctx);
+        explicitAttrsList = res;
+    }
+    if (explicitAttrsList.length > 0) {
+        const hidden = _.difference(_.keys(result), explicitAttrsList);
+        hidden.forEach((attr) => {
+            delete result[attr];
+        });
+    }
+    return result;
+}
+
 /**
  * Makes an update in the Device's entity in the context broker, with the values given in the 'attributes' array.
  * This array should comply to the NGSI-LD's attribute format.
@@ -416,7 +498,6 @@ function addLinkedEntities(typeInformation, json) {
  */
 function sendUpdateValueNgsiLD(entityName, attributes, typeInformation, token, callback) {
     let payload = {};
-
     const url = '/ngsi-ld/v1/entityOperations/upsert/?options=update';
 
     const options = NGSIUtils.createRequestObject(url, typeInformation, token);
@@ -477,11 +558,10 @@ function sendUpdateValueNgsiLD(entityName, attributes, typeInformation, token, c
                             }
                         }
 
-                        options.json = result;
+                        options.json = removeHiddenAttrsFromMultiEntity(result, typeInformation);
                     } else {
-                        delete result.id;
-                        delete result.type;
-                        options.json = result;
+                        // Remove id, type and any hidden attrs after processing
+                        options.json = removeHiddenAttrs(result, typeInformation);
                         logger.debug(context, 'typeInformation: %j', typeInformation);
                         if (
                             'timestamp' in typeInformation && typeInformation.timestamp !== undefined
@@ -570,6 +650,7 @@ function sendUpdateValueNgsiLD(entityName, attributes, typeInformation, token, c
     );
 }
 
+exports.convertAttrNGSILD = convertAttrNGSILD;
 exports.formatAsNGSILD = formatAsNGSILD;
 exports.sendUpdateValue = sendUpdateValueNgsiLD;
 exports.sendQueryValue = sendQueryValueNgsiLD;