iotagent-node-lib 2.15.1 → 2.19.0

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

@@ -27,21 +27,24 @@
 
 /* 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;
 const alarms = require('../common/alarmManagement');
 const errors = require('../../errors');
 const utils = require('../northBound/restUtils');
+const pluginUtils = require('../../plugins/pluginUtils');
 const config = require('../../commonConfig');
 const constants = require('../../constants');
+const jexlParser = require('../../plugins/jexlParser');
 const moment = require('moment-timezone');
 const NGSIUtils = require('./ngsiUtils');
 const logger = require('logops');
 const context = {
     op: 'IoTAgentNGSI.Entities-v2'
 };
+const _ = require('underscore');
 
 /**
  * Amends an NGSIv2 Geoattribute from String to GeoJSON format
@@ -234,15 +237,13 @@ function generateNGSI2OperationHandler(operationName, entityName, typeInformatio
 
             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));
             }
@@ -292,7 +293,6 @@ function sendQueryValueNgsi2(entityName, attributes, typeInformation, token, cal
 
     const options = NGSIUtils.createRequestObject(url, typeInformation, token);
     options.method = 'GET';
-    options.json = true;
 
     if (!typeInformation || !typeInformation.type) {
         callback(new errors.TypeNotFound(null, entityName));
@@ -314,6 +314,92 @@ function sendQueryValueNgsi2(entityName, attributes, typeInformation, token, cal
     );
 }
 
+/**
+ * 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 = pluginUtils.extractAttributesArrayFromNgsi2Entity(entity);
+                const ctx = jexlParser.extractContext(attsArray);
+                const res = jexlParser.applyExpression(typeInformation.explicitAttrs, ctx, typeInformation);
+                explicitAttrsList = explicitAttrsList.concat(res);
+            });
+        }
+    }
+    if (explicitAttrsList.length > 0) {
+        logger.debug(context, 'removeHiddenAttrsFromMultiEntity %s', explicitAttrsList);
+        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           An 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 = pluginUtils.extractAttributesArrayFromNgsi2Entity(result);
+        const ctx = jexlParser.extractContext(attsArray);
+        const res = jexlParser.applyExpression(typeInformation.explicitAttrs, ctx, typeInformation);
+        explicitAttrsList = res;
+    }
+    if (explicitAttrsList.length > 0) {
+        logger.debug(context, 'removeHiddenAttrs %s', explicitAttrsList);
+        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 NGSIv2's attribute format.
@@ -328,7 +414,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
 
     let url = '/v2/entities/' + entityName + '/attrs';
 
-    if (typeInformation.type) {
+    if (typeInformation && typeInformation.type) {
         url += '?type=' + typeInformation.type;
     }
 
@@ -343,9 +429,6 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
         return;
     }
 
-    payload.id = entityName;
-    payload.type = typeInformation.type;
-
     for (let i = 0; i < attributes.length; i++) {
         if (attributes[i].name && attributes[i].type) {
             payload[attributes[i].name] = {
@@ -361,7 +444,9 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
             return;
         }
     }
-
+    //overwritte if id or type missnamed atributes reach this point
+    payload.id = entityName;
+    payload.type = typeInformation.type;
     payload = NGSIUtils.castJsonNativeAttributes(payload);
     async.waterfall(
         [
@@ -384,7 +469,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                         ) {
                             // jshint maxdepth:5
                             if (!utils.isTimestampedNgsi2(result)) {
-                                options.json = addTimestampNgsi2(result, typeInformation.timezone);
+                                result = addTimestampNgsi2(result, typeInformation.timezone);
                                 // jshint maxdepth:5
                             } else if (!utils.IsValidTimestampedNgsi2(result)) {
                                 logger.error(context, 'Invalid timestamp:%s', JSON.stringify(result));
@@ -392,15 +477,17 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                                 return;
                             }
                         }
-
                         options.json = {
                             actionType: 'append',
-                            entities: result
+                            entities: removeHiddenAttrsFromMultiEntity(result, typeInformation)
                         };
+                        if (config.getConfig().appendMode === true) {
+                            options.json.actionType = 'append';
+                        } else {
+                            options.json.actionType = 'update';
+                        }
                     } else {
-                        delete result.id;
-                        delete result.type;
-                        options.json = result;
+                        options.json = removeHiddenAttrs(result, typeInformation);
                         logger.debug(context, 'typeInformation: %j', typeInformation);
                         if (
                             'timestamp' in typeInformation && typeInformation.timestamp !== undefined
@@ -415,6 +502,11 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                                 return;
                             }
                         }
+                        if (config.getConfig().appendMode === true) {
+                            options.method = 'POST';
+                        } else {
+                            options.method = 'PATCH';
+                        }
                     }
                 } else {
                     delete payload.id;
@@ -424,6 +516,13 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                 // Purge object_id from entities before sent to CB
                 // object_id was added by createNgsi2Entity to allow multientity
                 // with duplicate attribute names.
+
+                //some entities may be empty if they had only wrong attributes id-type
+                //we filter the array
+                if (options.json.entities) {
+                    options.json.entities = options.json.entities.filter((value) => Object.keys(value).length > 0);
+                }
+
                 let att;
                 if (options.json.entities) {
                     for (let entity = 0; entity < options.json.entities.length; entity++) {
@@ -471,17 +570,28 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                     }
                 }
 
-                logger.debug(context, 'Updating device value in the Context Broker at [%s]', options.url);
-                logger.debug(
-                    context,
-                    'Using the following NGSI v2 request:\n\n%s\n\n',
-                    JSON.stringify(options, null, 4)
-                );
-
-                request(
-                    options,
-                    generateNGSI2OperationHandler('update', entityName, typeInformation, token, options, callback)
-                );
+                // Prevent to update an entity with an empty payload
+                if (Object.keys(options.json).length > 0) {
+                    logger.debug(context, 'Updating device value in the Context Broker at [%s]', options.url);
+                    logger.debug(
+                        context,
+                        'Using the following NGSI v2 request:\n\n%s\n\n',
+                        JSON.stringify(options, null, 4)
+                    );
+
+                    request(
+                        options,
+                        generateNGSI2OperationHandler('update', entityName, typeInformation, token, options, callback)
+                    );
+                } else {
+                    logger.debug(
+                        context,
+                        'Not updating device value in the Context Broker at [%s] due to empty payload \n\n[%s]\n\n',
+                        options.url,
+                        JSON.stringify(options, null, 4)
+                    );
+                    callback(null);
+                }
             }
         }
     );

package/lib/services/ngsi/ngsiService.js

@@ -49,14 +49,11 @@ function init() {
         case 'ld':
             entityHandler = require('./entities-NGSI-LD');
             break;
-        case 'v2':
-            entityHandler = require('./entities-NGSI-v2');
-            break;
         case 'mixed':
             entityHandler = require('./entities-NGSI-mixed');
             break;
         default:
-            entityHandler = require('./entities-NGSI-v1');
+            entityHandler = require('./entities-NGSI-v2');
     }
 }
 
@@ -135,9 +132,10 @@ function executeWithDeviceInformation(operationFunction) {
             attributes,
             deviceInformation
         );
-        config.getGroupRegistry().getType(type, function (error, deviceGroup) {
+        const currentType = type ? type : deviceInformation.type;
+        config.getGroupRegistry().getType(currentType, function (error, deviceGroup) {
             let typeInformation;
-            const configDeviceInfo = config.getConfig().types[type];
+            const configDeviceInfo = config.getConfig().types[currentType];
             if (error) {
                 logger.debug(context, 'error %j in get group device', error);
             }

package/lib/services/ngsi/ngsiUtils.js

@@ -233,27 +233,6 @@ function getMetaData(typeInformation, name, metadata) {
     return undefined;
 }
 
-/**
- * Given a NGSI Body, determines whether it contains any NGSI error.
- *
- * @param {String} body             String representing a NGSI body in JSON format.
- * @return {Number|*}
- */
-function getErrorField(body) {
-    let errorField = body.errorCode || body.orionError;
-
-    if (body && body.contextResponses) {
-        for (const i in body.contextResponses) {
-            if (body.contextResponses[i].statusCode && body.contextResponses[i].statusCode.code !== '200') {
-                errorField = body.contextResponses[i].statusCode;
-            }
-        }
-    }
-
-    return errorField;
-}
-
-exports.getErrorField = intoTrans(context, getErrorField);
 exports.createRequestObject = createRequestObject;
 exports.applyMiddlewares = applyMiddlewares;
 exports.getMetaData = getMetaData;

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

@@ -108,9 +108,14 @@ function subscribeNgsiLD(device, triggers, content, callback) {
     const options = {
         method: 'POST',
         headers: {
-            'fiware-service': device.service
+            'fiware-service': device.service,
+            'fiware-servicepath': device.subservice,
+            'NGSILD-Tenant': device.service,
+            'NGSILD-Path': device.subservice,
+            'Content-Type': 'application/ld+json'
         },
         json: {
+            '@context': config.getConfig().contextBroker.jsonLdContext,
             type: 'Subscription',
             entities: [
                 {
@@ -121,10 +126,12 @@ function subscribeNgsiLD(device, triggers, content, callback) {
 
             watchedAttributes: triggers,
             notification: {
-                http: {
-                    url: config.getConfig().providerUrl + '/notify'
+                endpoint: {
+                    uri: config.getConfig().providerUrl + '/notify',
+                    accept: 'application/json'
                 },
-                attributes: content || []
+                attributes: content || [],
+                format: 'normalized'
             }
         }
     };
@@ -210,7 +217,9 @@ function unsubscribeNgsiLD(device, id, callback) {
         method: 'DELETE',
         headers: {
             'fiware-service': device.service,
-            'fiware-servicepath': device.subservice
+            'fiware-servicepath': device.subservice,
+            'NGSILD-Tenant': device.service,
+            'NGSILD-Path': device.subservice
         }
     };
 

package/lib/services/ngsi/subscriptionService.js

@@ -40,14 +40,11 @@ function init() {
         case 'ld':
             subscriptionHandler = require('./subscription-NGSI-LD');
             break;
-        case 'v2':
-            subscriptionHandler = require('./subscription-NGSI-v2');
-            break;
         case 'mixed':
             subscriptionHandler = require('./subscription-NGSI-mixed');
             break;
         default:
-            subscriptionHandler = require('./subscription-NGSI-v1');
+            subscriptionHandler = require('./subscription-NGSI-v2');
     }
 }
 

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

@@ -40,6 +40,7 @@ const context = {
 const updateContextTemplateNgsiLD = require('../../templates/updateContextNgsiLD.json');
 const notificationTemplateNgsiLD = require('../../templates/notificationTemplateNgsiLD.json');
 const contextServerUtils = require('./contextServerUtils');
+const ngsiLD = require('../ngsi/entities-NGSI-LD');
 
 const updatePaths = ['/ngsi-ld/v1/entities/:entity/attrs/:attr'];
 const queryPaths = ['/ngsi-ld/v1/entities/:entity'];
@@ -250,10 +251,10 @@ function defaultQueryHandlerNgsiLD(id, type, service, subservice, attributes, ca
                     attributeType = lazyAttribute.type;
                 }
 
-                contextElement[attributes[i]] = {
+                contextElement[attributes[i]] = ngsiLD.convertAttrNGSILD({
                     type: attributeType,
                     value: ''
-                };
+                });
             }
 
             callback(null, contextElement);
@@ -408,6 +409,10 @@ function handleQueryNgsiLD(req, res, next) {
     }
 
     logger.debug(context, 'Handling query from [%s]', req.get('host'));
+    if ((req.is('json') || req.is('application/ld+json')) === false) {
+        return handleQueryContextRequests(new errors.UnsupportedContentType(req.header('content-type')));
+    }
+
     if (req.body) {
         logger.debug(context, JSON.stringify(req.body, null, 4));
     }

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

@@ -204,7 +204,7 @@ function handleUpdateNgsi2(req, res, next) {
             [apply(async.map, req.body.entities, apply(generateUpdateActionsNgsi2, req)), reduceActions, async.series],
             function (error, result) {
                 if (error) {
-                    logger.debug(context, 'There was an error handling the update action: %s.', error);
+                    logger.debug(context, 'There was an error handling the update action: %j.', error);
 
                     next(error);
                 } else {
@@ -538,25 +538,37 @@ function handleQueryNgsi2(req, res, next) {
         logger.debug(context, JSON.stringify(req.body, null, 4));
     }
     const contextEntity = {};
+    const entities = req.body.entities || [];
 
-    // At the present moment, IOTA supports query request with one entity and without patterns. This is aligned
-    // with the utilization cases in combination with ContextBroker. Other cases are returned as error
-    if (req.body.entities.length !== 1) {
+    if (!req.is('json')) {
         logger.warn(
-            'queries with entities number different to 1 are not supported (%d found)',
-            req.body.entities.length
+            'queries must offer JSON entities, content-type not supported (%s found)',
+            req.header('content-type')
         );
-        handleQueryContextRequests({ code: 400, name: 'BadRequest', message: 'more than one entity in query' });
-        return;
+        return handleQueryContextRequests(new errors.UnsupportedContentType(req.header('content-type')));
+    }
+
+    // At the present moment, IOTA supports query request with one entity and without patterns. This is aligned
+    // with the utilization cases in combination with ContextBroker. Other cases are returned as error
+    if (entities.length !== 1) {
+        logger.warn('queries with entities number different to 1 are not supported (%d found)', entities.length);
+        return handleQueryContextRequests({
+            code: 400,
+            name: 'BadRequest',
+            message: 'query does not contain a single entity'
+        });
     }
-    if (req.body.entities[0].idPattern) {
+    if (entities[0].idPattern) {
         logger.warn('queries with idPattern are not supported');
-        handleQueryContextRequests({ code: 400, name: 'BadRequest', message: 'idPattern usage in query' });
-        return;
+        return handleQueryContextRequests({
+            code: 400,
+            name: 'BadRequest',
+            message: 'idPattern usage in query'
+        });
     }
 
-    contextEntity.id = req.body.entities[0].id;
-    contextEntity.type = req.body.entities[0].type;
+    contextEntity.id = entities[0].id;
+    contextEntity.type = entities[0].type;
     const queryAtts = req.body.attrs;
     createQueryRequest(queryAtts, contextEntity, handleQueryContextRequests);
 }

package/lib/services/northBound/contextServer.js

@@ -41,14 +41,11 @@ function init() {
         case 'ld':
             contextServerHandler = require('./contextServer-NGSI-LD');
             break;
-        case 'v2':
-            contextServerHandler = require('./contextServer-NGSI-v2');
-            break;
         case 'mixed':
             contextServerHandler = require('./contextServer-NGSI-mixed');
             break;
         default:
-            contextServerHandler = require('./contextServer-NGSI-v1');
+            contextServerHandler = require('./contextServer-NGSI-v2');
     }
 }
 

package/lib/services/northBound/contextServerUtils.js

@@ -26,14 +26,10 @@
 
 const async = require('async');
 const apply = async.apply;
-const logger = require('logops');
 const constants = require('../../constants');
 const config = require('../../commonConfig');
 const ngsi = require('../ngsi/ngsiService');
 const commands = require('../commands/commandService');
-const context = {
-    op: 'IoTAgentNGSI.ContextServerUtils'
-};
 
 /**
  * Returns the Current Tenant  defined for the NGSI-LD Broker. Tenant is based on the request
@@ -68,81 +64,6 @@ function getLDPath(req) {
     return config.getConfig().contextBroker.fallbackPath;
 }
 
-/**
- * Create the response for an UpdateContext operation, based on the results of the individual updates. The signature
- * retains the results object for homogeinity with the createQuery* version.
- *
- * @param {Object} req              Request that was handled in first place.
- * @param {Object} res              Response that will be sent.
- * @param {Object} results          Ignored for this function. TODO: to be removed in later versions.
- * @return {{contextResponses: Array}}
- */
-
-/* eslint-disable-next-line  no-unused-vars */
-function createUpdateResponse(req, res, results) {
-    const result = {
-        contextResponses: []
-    };
-
-    for (let i = 0; i < req.body.contextElements.length; i++) {
-        const contextResponse = {
-            contextElement: {
-                attributes: req.body.contextElements[i].attributes,
-                id: req.body.contextElements[i].id,
-                isPattern: false,
-                type: req.body.contextElements[i].type
-            },
-            statusCode: {
-                code: 200,
-                reasonPhrase: 'OK'
-            }
-        };
-
-        for (let j = 0; j < contextResponse.contextElement.attributes.length; j++) {
-            contextResponse.contextElement.attributes[i].value = '';
-        }
-
-        result.contextResponses.push(contextResponse);
-    }
-
-    logger.debug(context, 'Generated update response: %j', result);
-
-    return result;
-}
-
-/**
- * Create the response for a queryContext operation based on the individual results gathered from the query handlers.
- * The returned response is in the NGSI Response format.
- *
- * @param {Object} req              Request that was handled in first place.
- * @param {Object} res              Response that will be sent.
- * @param {Object} results          Individual Context Element results from the query handlers.
- * @return {{contextResponses: Array}}
- */
-function createQueryResponse(req, res, results) {
-    const result = {
-        contextResponses: []
-    };
-
-    for (let i = 0; i < results.length; i++) {
-        const contextResponse = {
-            contextElement: results[i],
-            statusCode: {
-                code: 200,
-                reasonPhrase: 'OK'
-            }
-        };
-
-        contextResponse.contextElement.isPattern = false;
-
-        result.contextResponses.push(contextResponse);
-    }
-
-    logger.debug(context, 'Generated query response: %j', result);
-
-    return result;
-}
-
 /**
  * Retrieve the Device that corresponds to a Context Update, and execute the update side effects
  * if there were any (e.g.: creation of attributes related to comands).
@@ -199,8 +120,6 @@ exports.updateHandler = null;
 exports.commandHandler = null;
 exports.queryHandler = null;
 exports.notificationHandler = null;
-exports.createUpdateResponse = createUpdateResponse;
-exports.createQueryResponse = createQueryResponse;
 exports.executeUpdateSideEffects = executeUpdateSideEffects;
 exports.pushCommandsToQueue = pushCommandsToQueue;
 exports.getLDTenant = getLDTenant;