iotagent-node-lib 2.26.0 → 3.0.0

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

@@ -26,20 +26,20 @@
 /* eslint-disable consistent-return */
 
 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 expressionPlugin = require('../../plugins/expressionPlugin');
+const compressTimestampPlugin = require('../../plugins/compressTimestamp');
 const moment = require('moment-timezone');
 const logger = require('logops');
 const _ = require('underscore');
 const context = {
-    op: 'IoTAgentNGSI.Entities-LD'
+    op: 'IoTAgentNGSI-LD'
 };
 const NGSIv2 = require('./entities-NGSI-v2');
 const NGSIUtils = require('./ngsiUtils');
@@ -171,7 +171,7 @@ function convertAttrNGSILD(attr) {
             obj.value = { '@type': attr.type, '@value': attr.value };
     }
 
-    if (attr.metadata) {
+    if (!!obj && attr.metadata) {
         let timestamp;
         Object.keys(attr.metadata).forEach(function (key) {
             switch (key) {
@@ -411,89 +411,13 @@ function addLinkedEntities(typeInformation, json) {
 }
 
 /**
- * Remove id, type and any hidden attrs after processing
+ * Determines if a value is of type float
  *
- * @param {Object} enities           Unprocessed entities
- * @param {Object} typeInformation  Configuration information for the device.
+ * @param      {String}   value       Value to be analyzed
+ * @return     {boolean}              True if float, False otherwise.
  */
-function removeHiddenAttrsFromMultiEntity(entities, typeInformation) {
-    let explicitAttrsList;
-    if (typeInformation.explicitAttrs) {
-        explicitAttrsList = [];
-        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 && 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;
-    let explicitAttrsList;
-    if (typeInformation.explicitAttrs && typeof typeInformation.explicitAttrs === 'boolean') {
-        explicitAttrsList = [];
-        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 && explicitAttrsList.length >= 0) {
-        const hidden = _.difference(_.keys(result), explicitAttrsList);
-        hidden.forEach((attr) => {
-            delete result[attr];
-        });
-    }
-    return result;
+function isFloat(value) {
+    return !isNaN(value) && value.toString().indexOf('.') !== -1;
 }
 
 /**
@@ -506,9 +430,31 @@ function removeHiddenAttrs(result, typeInformation) {
  * @param {String} token            User token to identify against the PEP Proxies (optional).
  */
 function sendUpdateValueNgsiLD(entityName, attributes, typeInformation, token, callback) {
-    let payload = {};
+    logger.debug(
+        context,
+        'sendUpdateValueNgsiLD called with: \n entityName=%s \n attributes=%j \n typeInformation=%j',
+        entityName,
+        attributes,
+        typeInformation
+    );
+    const payload = [
+        {
+            id: entityName
+        }
+    ];
+
     const url = '/ngsi-ld/v1/entityOperations/upsert/?options=update';
 
+    if (typeInformation && typeInformation.type) {
+        payload[0].type = typeInformation.type;
+    }
+
+    if (config.getConfig().appendMode === true) {
+        payload.actionType = 'append';
+    } else {
+        payload.actionType = 'update';
+    }
+
     const options = NGSIUtils.createRequestObject(url, typeInformation, token);
     options.method = 'POST';
 
@@ -520,143 +466,598 @@ function sendUpdateValueNgsiLD(entityName, attributes, typeInformation, token, c
         callback(new errors.TypeNotFound(null, entityName));
         return;
     }
+    const idTypeSSSList = pluginUtils.getIdTypeServSubServiceFromDevice(typeInformation);
+    logger.debug(context, 'sendUpdateValueNgsiLD \n idTypeSSS are %j ', idTypeSSSList);
+    const measureAttrsForCtxt = [];
 
-    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] = {
-                value: attributes[i].value,
-                type: attributes[i].type
-            };
-            const metadata = NGSIUtils.getMetaData(typeInformation, attributes[i].name, attributes[i].metadata);
-            if (metadata) {
-                payload[attributes[i].name].metadata = metadata;
+    // Check explicitAttrs: adds all final needed attributes to payload
+    if (
+        typeInformation.explicitAttrs === undefined ||
+        (typeof typeInformation.explicitAttrs === 'boolean' && !typeInformation.explicitAttrs)
+        // explicitAttrs is not defined => default case: all attrs should be included
+    ) {
+        // This loop adds all measure values (attributes) into payload entities (entity[0])
+        for (let i = 0; i < attributes.length; i++) {
+            if (attributes[i].name && attributes[i].type) {
+                payload[0][attributes[i].name] = {
+                    value: attributes[i].value,
+                    type: attributes[i].type
+                };
+                const metadata = NGSIUtils.getMetaData(typeInformation, attributes[i].name, attributes[i].metadata);
+                if (metadata) {
+                    payload[0][attributes[i].name].metadata = metadata;
+                }
+            } else {
+                callback(new errors.BadRequest(null, entityName));
+                return;
             }
-        } else {
-            callback(new errors.BadRequest(null, entityName));
-            return;
         }
-    }
-
-    payload = NGSIUtils.castJsonNativeAttributes(payload);
-    async.waterfall(
-        [
-            apply(statsService.add, 'measureRequests', 1),
-            apply(NGSIUtils.applyMiddlewares, NGSIUtils.updateMiddleware, payload, typeInformation)
-        ],
-        function (error, result) {
-            if (error) {
-                callback(error);
-            } else {
-                if (result) {
-                    // The payload has been transformed by multientity plugin. It is not a JSON object but an Array.
-                    if (result instanceof Array) {
-                        if (
-                            'timestamp' in typeInformation && typeInformation.timestamp !== undefined
-                                ? typeInformation.timestamp
-                                : config.getConfig().timestamp
-                        ) {
-                            if (!utils.isTimestampedNgsi2(result)) {
-                                options.json = NGSIv2.addTimestamp(result, typeInformation.timezone);
-                            } else if (!utils.IsValidTimestampedNgsi2(result)) {
-                                logger.error(context, 'Invalid timestamp:%s', JSON.stringify(result));
-                                callback(new errors.BadTimestamp(result));
-                                return;
-                            }
-                        }
-
-                        options.json = removeHiddenAttrsFromMultiEntity(result, typeInformation);
+        logger.debug(context, 'sendUpdateValueNgsiLD \n pre-initial non-explicitAttrs payload=%j', payload);
+        // Loop for add attrs from type.information.active (and lazys?) into payload entities (entity[0])
+        if (typeInformation.active) {
+            typeInformation.active.forEach((attr) => {
+                if (attr.expression) {
+                    if (attr.object_id) {
+                        payload[0][attr.object_id] = {
+                            value: payload[0][attr.object_id] ? payload[0][attr.object_id].value : undefined,
+                            type: attr.type,
+                            object_id: attr.object_id
+                        };
                     } else {
-                        // 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
-                                ? typeInformation.timestamp
-                                : config.getConfig().timestamp
-                        ) {
-                            if (!utils.isTimestampedNgsi2(options.json)) {
-                                options.json = NGSIv2.addTimestamp(options.json, typeInformation.timezone);
-                            } else if (!utils.IsValidTimestampedNgsi2(options.json)) {
-                                logger.error(context, 'Invalid timestamp:%s', JSON.stringify(options.json));
-                                callback(new errors.BadTimestamp(options.json));
-                                return;
-                            }
-                        }
+                        payload[0][attr.name] = {
+                            value: payload[0][attr.name] ? payload[0][attr.name].value : undefined,
+                            type: attr.type
+                        };
                     }
-                } else {
-                    delete payload.id;
-                    delete payload.type;
-                    options.json = payload;
                 }
-                // Purge object_id from entities before sent to CB
-                // object_id was added by createNgsi2Entity to allow multientity
-                // with duplicate attribute names.
-                let att;
-                if (options.json) {
-                    for (let entity = 0; entity < options.json.length; entity++) {
-                        for (att in options.json[entity]) {
-                            /*jshint camelcase: false */
-                            if (options.json[entity][att].object_id) {
-                                /*jshint camelcase: false */
-                                delete options.json[entity][att].object_id;
-                            }
-                            if (options.json[entity][att].multi) {
-                                delete options.json[entity][att].multi;
-                            }
-                            if (options.json[entity][att].name) {
-                                delete options.json[entity][att].name;
-                            }
+            });
+        }
+    } else {
+        let selectedAttrs = [];
+        if (typeof typeInformation.explicitAttrs === 'string') {
+            // explicitAttrs is a jexlExpression
+            // This ctxt should include all possible attrs
+            const attributesCtxt = [];
+            if (typeInformation.static) {
+                typeInformation.static.forEach(function (att) {
+                    attributesCtxt.push(att);
+                });
+            }
+            // Measures
+            for (let i = 0; i < attributes.length; i++) {
+                if (attributes[i].name && attributes[i].type) {
+                    const measureAttr = {
+                        name: attributes[i].name,
+                        value: attributes[i].value,
+                        type: attributes[i].type
+                    };
+                    attributesCtxt.push(measureAttr);
+                }
+            }
+            // This context is just to calculate explicitAttrs when is an expression
+            let ctxt = expressionPlugin.extractContext(attributesCtxt.concat(idTypeSSSList), typeInformation);
+            // typeInformation.active attrs with expressions expanded by current ctxt
+            if (typeInformation.active) {
+                typeInformation.active.forEach(function (att) {
+                    if (att.expression) {
+                        if (expressionPlugin.contextAvailable(att.expression, ctxt, typeInformation)) {
+                            const expandedAttr = {
+                                name: att.name,
+                                value: att.expression, // it doesn't matter final value here
+                                type: att.type
+                            };
+                            attributesCtxt.push(expandedAttr);
+                            ctxt = expressionPlugin.extractContext(
+                                attributesCtxt.concat(idTypeSSSList),
+                                typeInformation
+                            );
                         }
                     }
-                } else {
-                    for (att in options.json) {
-                        /*jshint camelcase: false */
-                        if (options.json[att].object_id) {
-                            /*jshint camelcase: false */
-                            delete options.json[att].object_id;
-                        }
-                        if (options.json[att].multi) {
-                            delete options.json[att].multi;
-                        }
-                        if (options.json[att].name) {
-                            delete options.json[att].name;
-                        }
+                });
+            }
+            // calculate expression for explicitAttrs
+            try {
+                const res = jexlParser.applyExpression(typeInformation.explicitAttrs, ctxt, typeInformation);
+                if (res === true) {
+                    // like explicitAttrs == true
+                    // selectAttrs should be measures which are defined attributes
+                    typeInformation.active.forEach((attr) => {
+                        selectedAttrs.push(attr.name);
+                        selectedAttrs.push(attr.object_id);
+                    });
+                } else if (res === false) {
+                    // like explicitAttrs == false
+                    // selectAttrs should be measures and defined attributes
+                    typeInformation.active.forEach((attr) => {
+                        selectedAttrs.push(attr.name);
+                        selectedAttrs.push(attr.object_id);
+                    });
+                    for (let i = 0; i < attributes.length; i++) {
+                        selectedAttrs.push(attributes[i].name);
                     }
+                } else {
+                    selectedAttrs = res; // TBD: Check ensure is an array of strings
+                }
+                if (selectedAttrs.length === 0) {
+                    // implies do nothing
+                    logger.info(
+                        context,
+                        'sendUpdateValueNgsiLD \n none selectedAttrs with %j and ctxt %j',
+                        typeInformation.explicitAttrs,
+                        ctxt
+                    );
+                    return callback(null);
                 }
+            } catch (e) {
+                // nothing to do: exception is already logged at info level
+            }
 
-                try {
-                    if (result instanceof Array) {
-                        options.json = _.map(options.json, formatAsNGSILD);
+            typeInformation.active.forEach((attr) => {
+                if (selectedAttrs.includes(attr.name)) {
+                    selectedAttrs.push(attr.object_id);
+                }
+            });
+        } else if (typeInformation.explicitAttrs && typeof typeInformation.explicitAttrs === 'boolean') {
+            // TBD: selectedAttrs could be a boolean as a result of applyExpression
+            // explicitAtts is true => Add measures which are defined attributes
+            typeInformation.active.forEach((attr) => {
+                selectedAttrs.push(attr.name);
+                selectedAttrs.push(attr.object_id);
+            });
+        }
+        // This loop adds selected measured values (attributes) into payload entities (entity[0])
+        for (let i = 0; i < attributes.length; i++) {
+            if (attributes[i].name && selectedAttrs.includes(attributes[i].name) && attributes[i].type) {
+                const attr = typeInformation.active.find((obj) => {
+                    return obj.name === attributes[i].name;
+                });
+                payload[0][attributes[i].name] = {
+                    value: attributes[i].value,
+                    type: attributes[i].type
+                };
+                // ensure payload has attr with proper object_id
+                if (attr && attr.object_id) {
+                    payload[0][attributes[i].name].object_id = attr.object_id;
+                }
+                const metadata = NGSIUtils.getMetaData(typeInformation, attributes[i].name, attributes[i].metadata);
+                if (metadata) {
+                    payload[0][attributes[i].name].metadata = metadata;
+                }
+            } else if (attributes[i].name && !selectedAttrs.includes(attributes[i].name) && attributes[i].type) {
+                const att = {
+                    name: attributes[i].name,
+                    type: attributes[i].type,
+                    value: attributes[i].value
+                };
+                measureAttrsForCtxt.push(att);
+            }
+        }
+        logger.debug(
+            context,
+            'sendUpdateValueNgsiLD \n pre-initial explicitAttrs payload=%j \n selectedAttrs',
+            payload,
+            selectedAttrs
+        );
+
+        // Loop for add seleted attrs from type.information.active into pyaload entities (entity[0])
+        if (typeInformation.active) {
+            typeInformation.active.forEach((attr) => {
+                if (selectedAttrs.includes(attr.name)) {
+                    if (attr.object_id) {
+                        payload[0][attr.object_id] = {
+                            value: payload[0][attr.object_id]
+                                ? payload[0][attr.object_id].value
+                                : payload[0][attr.name]
+                                ? payload[0][attr.name].value
+                                : undefined,
+                            type: attr.type,
+                            object_id: attr.object_id
+                        };
                     } else {
-                        options.json.id = entityName;
-                        options.json.type = typeInformation.type;
-                        options.json = [formatAsNGSILD(options.json)];
+                        payload[0][attr.name] = {
+                            value: payload[0][attr.name] ? payload[0][attr.name].value : undefined,
+                            type: attr.type
+                        };
                     }
-                } catch (error) {
-                    return callback(new errors.BadGeocoordinates(JSON.stringify(payload)));
                 }
+            });
+        }
+    } // END check explicitAttrs
+    logger.debug(context, 'sendUpdateValueNgsiLD \n initial payload=%j', payload);
+
+    const currentEntity = payload[0];
 
+    // Prepare attributes for expresionPlugin
+    const attsArray = pluginUtils.extractAttributesArrayFromNgsi2Entity(currentEntity);
+
+    // Exclude processing all attr expressions when current attr is of type 'commandStatus' or 'commandResult'
+    let attsArrayFiltered = [];
+    if (attsArray) {
+        attsArrayFiltered = attsArray.filter((obj) => {
+            return ![constants.COMMAND_STATUS, constants.COMMAND_RESULT].includes(obj.type);
+        });
+    }
+    let attributesCtxt = [...attsArrayFiltered]; // just copy
+    if (typeInformation.static) {
+        typeInformation.static.forEach(function (att) {
+            attributesCtxt.push(att);
+        });
+    }
+    if (measureAttrsForCtxt) {
+        measureAttrsForCtxt.forEach(function (att) {
+            attributesCtxt.push(att);
+        });
+    }
+    attributesCtxt = attributesCtxt.concat(idTypeSSSList);
+    const ctxt = expressionPlugin.extractContext(attributesCtxt, typeInformation);
+    logger.debug(context, 'sendUpdateValueNgsiLD \n initial ctxt %j ', ctxt);
+
+    // Sort currentEntity to get first attrs without expressions (checking attrs in typeInformation.active)
+    // attributes without expressions should be processed before
+    logger.debug(context, 'sendUpdateValueNgsiLD \n currentEntity %j ', currentEntity);
+    if (typeInformation.active && typeInformation.active.length > 0) {
+        for (const k in currentEntity) {
+            typeInformation.active.forEach(function (att) {
+                if (
+                    (att.object_id && att.object_id === k && att.expression) ||
+                    (att.name && att.name === k && att.expression)
+                ) {
+                    const m = currentEntity[k];
+                    delete currentEntity[k];
+                    currentEntity[k] = m; // put into the end of currentEntity
+                }
+            });
+        }
+    }
+    logger.debug(context, 'sendUpdateValueNgsiLD \n currentEntity sorted %j ', currentEntity);
+    let timestampValue;
+    // Loop for each final attribute to apply alias, multientity and expressions
+    for (const j in currentEntity) {
+        // discard id and type
+        if (j !== 'id' || j !== 'type') {
+            // Apply Mapping Alias: object_id in attributes are in typeInformation.active
+            let attr;
+            let newAttr = payload[0][j];
+            if (typeInformation.active) {
+                attr = typeInformation.active.find((obj) => {
+                    return obj.object_id === j;
+                });
+            }
+            if (!attr) {
+                if (typeInformation.lazy) {
+                    attr = typeInformation.lazy.find((obj) => {
+                        return obj.object_id === j;
+                    });
+                }
+            }
+            if (!attr) {
                 if (typeInformation.active) {
-                    addLinkedEntities(typeInformation, options.json);
+                    attr = typeInformation.active.find((obj) => {
+                        return obj.name === j;
+                    });
                 }
+            }
+            if (attr && attr.name) {
+                if (['id', 'type'].includes(attr.name)) {
+                    // invalid mapping
+                    logger.debug(
+                        context,
+                        'sendUpdateValueNgsiLD \n invalid mapping for attr %j \n newAttr %j',
+                        attr,
+                        newAttr
+                    );
+                    delete payload[0][attr.object_id];
+                    attr = undefined; // stop processing attr
+                    newAttr = undefined;
+                } else {
+                    ctxt[attr.name] = payload[0][j].value;
+                }
+            }
+            logger.debug(
+                context,
+                'sendUpdateValueNgsiLD \n procesing j %j attr %j ctxt %j \n newAttr %j ',
+                j,
+                attr,
+                ctxt,
+                newAttr
+            );
+
+            if (attr && attr.type) {
+                if (attr.type !== 'GeoProperty') {
+                    newAttr.type = attr.type;
+                }
+            }
 
-                logger.debug(context, 'Updating device value in the Context Broker at [%s]', options.url);
+            // Apply expression
+            if (attr && attr.expression) {
                 logger.debug(
                     context,
-                    'Using the following NGSI-LD request:\n\n%s\n\n',
-                    JSON.stringify(options, null, 4)
+                    'sendUpdateValueNgsiLD \n apply expression %j \n over ctxt %j \n and device %j',
+                    attr.expression,
+                    ctxt,
+                    typeInformation
                 );
+                let res = null;
+                try {
+                    if (expressionPlugin.contextAvailable(attr.expression, ctxt, typeInformation)) {
+                        res = expressionPlugin.applyExpression(attr.expression, ctxt, typeInformation);
+                    } else {
+                        logger.warn(
+                            context,
+                            'sendUpdateValueNgsiLD \n no context available for apply expression %j \n',
+                            attr.expression
+                        );
+                        res = newAttr.value; // keep newAttr value
+                    }
+                } catch (e) {
+                    logger.error(context, 'sendUpdateValueNgsiLD \n apply expression exception %j \n', e);
+                    if (!expressionPlugin.checkJexl(typeInformation)) {
+                        return callback(e); // just throw error with legacy parser for backward compatiblity
+                    } else {
+                        res = ctxt[attr.name]; // TBD: add reference to test
+                    }
+                }
+                if (!expressionPlugin.checkJexl(typeInformation)) {
+                    // legacy expression plugin: Involves some legacy checks performed by applierExpression
+                    if (
+                        res &&
+                        res !== 'undefined' &&
+                        res !== 'null' &&
+                        (typeof res === 'string' || res instanceof String) &&
+                        !res.includes('NaN')
+                    ) {
+                        newAttr.value = res;
+                        if (newAttr.type === 'Number' && isFloat(newAttr.value)) {
+                            newAttr.value = Number.parseFloat(newAttr.value);
+                        } else if (newAttr.type === 'Number' && !Number.isNaN(Number.parseInt(newAttr.value))) {
+                            newAttr.value = Number.parseInt(newAttr.value);
+                        } else if (newAttr.type === 'Boolean') {
+                            newAttr.value = newAttr.value === 'true' || newAttr.value === '1';
+                        } else if (newAttr.type === 'None') {
+                            newAttr.value = null;
+                        }
+                    } else if (isNaN(res) || res === 'undefined' || res === 'null') {
+                        logger.debug(
+                            context,
+                            'sendUpdateValueNgsiLD \n apply expression result: isNaN || undefined || null'
+                        );
+                        if (res === 'null' && newAttr.type === 'None') {
+                            newAttr.value = null;
+                        } else {
+                            delete payload[0][j]; // remove measure attr
+                            attr = undefined; // stop process attr
+                        }
+                    }
+                } else {
+                    // jexl expression plugin
+                    newAttr.value = res;
+                }
+                logger.debug(
+                    context,
+                    'sendUpdateValueNgsiLD \n apply expression result %j \n newAttr %j',
+                    res,
+                    newAttr
+                );
+            }
 
-                request(
-                    options,
-                    generateNGSILDOperationHandler('update', entityName, typeInformation, token, options, callback)
+            // Apply Multientity: entity_type and entity_name in attributes are in typeInformation.active
+            if (attr && (attr.entity_type || attr.entity_name)) {
+                // Create a newEntity for this attribute
+                let newEntityName = null;
+                if (attr.entity_name) {
+                    try {
+                        if (expressionPlugin.contextAvailable(attr.entity_name, ctxt, typeInformation)) {
+                            newEntityName = expressionPlugin.applyExpression(attr.entity_name, ctxt, typeInformation);
+                        } else {
+                            logger.warn(
+                                context,
+                                'sendUpdateValueNgsiLD \n MULTI no context available for apply expression %j \n',
+                                attr.entity_name
+                            );
+                            newEntityName = attr.entity_name;
+                        }
+                        newEntityName = newEntityName ? newEntityName : attr.entity_name;
+                    } catch (e) {
+                        logger.error(context, 'sendUpdateValueNgsiLD \n MULTI apply expression exception %j \n', e);
+                        newEntityName = attr.entity_name;
+                    }
+                    logger.debug(
+                        context,
+                        'sendUpdateValueNgsiLD \n MULTI apply expression %j \n result %j \n payload %j',
+                        attr.entity_name,
+                        newEntityName,
+                        payload
+                    );
+                }
+
+                let newEntity = {
+                    id: newEntityName ? newEntityName : payload[0].id,
+                    type: attr.entity_type ? attr.entity_type : payload[0].type
+                };
+                // Check if there is already a newEntity created
+                const alreadyEntity = payload.find((entity) => {
+                    return entity.id === newEntity.id && entity.type === newEntity.type;
+                });
+                if (alreadyEntity) {
+                    // Use alreadyEntity
+                    alreadyEntity[attr.name] = newAttr;
+                } else {
+                    // Add newEntity to payload
+                    newEntity[attr.name] = newAttr;
+                    if (
+                        'timestamp' in typeInformation && typeInformation.timestamp !== undefined
+                            ? typeInformation.timestamp
+                            : config.getConfig().timestamp !== undefined
+                            ? config.getConfig().timestamp
+                            : timestampValue !== undefined
+                    ) {
+                        newEntity = NGSIv2.addTimestamp(newEntity, typeInformation.timezone, timestampValue);
+                        logger.debug(context, 'sendUpdateValueNgsiLD \n timestamped newEntity=%j', newEntity);
+                    }
+                    payload.push(newEntity);
+                }
+                if (attr && attr.name) {
+                    if (attr.name !== j) {
+                        logger.debug(
+                            context,
+                            'sendUpdateValueNgsiLD \n MULTI remove measure attr %j keep alias j %j from %j \n',
+                            j,
+                            attr,
+                            payload
+                        );
+                        delete payload[0][j];
+                    }
+                }
+                // if (attr && (attr.entity_type || attr.entity_name))
+            } else {
+                // Not a multientity attr
+                if (attr && attr.name) {
+                    payload[0][attr.name] = newAttr;
+                    if (attr.name !== j) {
+                        delete payload[0][j]; // keep alias name, remove measure name
+                    }
+                }
+                if (newAttr && newAttr.type === constants.TIMESTAMP_TYPE_NGSI2 && newAttr.value) {
+                    const extendedTime = compressTimestampPlugin.fromBasicToExtended(newAttr.value);
+                    if (extendedTime) {
+                        // TBD: there is not flag about compressTimestamp in iotagent-node-lib,
+                        // but there is one in agents
+                        newAttr.value = extendedTime;
+                    }
+                }
+                if (j === constants.TIMESTAMP_ATTRIBUTE) {
+                    if (newAttr && newAttr.type === constants.TIMESTAMP_TYPE_NGSI2 && newAttr.value) {
+                        timestampValue = newAttr.value;
+                        logger.debug(
+                            context,
+                            'sendUpdateValueNgsiLD \n newAttr is TimeInstant and new payload=%j',
+                            payload
+                        );
+                    }
+                }
+                if (
+                    newAttr &&
+                    newAttr.metadata &&
+                    newAttr.metadata[constants.TIMESTAMP_ATTRIBUTE] &&
+                    newAttr.metadata[constants.TIMESTAMP_ATTRIBUTE].type === constants.TIMESTAMP_TYPE_NGSI2 &&
+                    newAttr.metadata[constants.TIMESTAMP_ATTRIBUTE].value
+                ) {
+                    const extendedTime = compressTimestampPlugin.fromBasicToExtended(
+                        newAttr.metadata[constants.TIMESTAMP_ATTRIBUTE].value
+                    );
+                    if (extendedTime) {
+                        newAttr.metadata[constants.TIMESTAMP_ATTRIBUTE].value = extendedTime;
+                    }
+                }
+            }
+        } // if (j !== 'id' || j !== 'type')
+
+        // final attr loop
+        logger.debug(
+            context,
+            'sendUpdateValueNgsiLD \n after procesing attr %j \n current entity %j \n current payload=%j',
+            j,
+            currentEntity,
+            payload
+        );
+    }
+    // for attr loop
+
+    // Add timestamp to paylaod
+    if (
+        'timestamp' in typeInformation && typeInformation.timestamp !== undefined
+            ? typeInformation.timestamp
+            : config.getConfig().timestamp !== undefined
+            ? config.getConfig().timestamp
+            : timestampValue !== undefined
+    ) {
+        if (timestampValue) {
+            // timeInstant is provided as measure
+            if (Object.keys(payload[0]).length > 3) {
+                // include metadata with TimeInstant in attrs when TimeInstant is provided as measure in all entities
+                payload[0] = NGSIv2.addTimestamp(
+                    payload[0],
+                    typeInformation.timezone,
+                    timestampValue,
+                    false // skipMetadataAtt
+                );
+            } else {
+                // Do not include metadata with TimeInstant in attrs when TimeInstant is provided as measure
+                // and no more entities
+                payload[0] = NGSIv2.addTimestamp(
+                    payload[0],
+                    typeInformation.timezone,
+                    timestampValue,
+                    true // skipMetadataAtt
                 );
             }
+        } else {
+            // jshint maxdepth:5
+            for (let n = 0; n < payload.length; n++) {
+                if (!utils.isTimestampedNgsi2(payload[n])) {
+                    // legacy check needed?
+                    payload[n] = NGSIv2.addTimestamp(payload[n], typeInformation.timezone);
+                    // jshint maxdepth:5
+                } else if (!utils.IsValidTimestampedNgsi2(payload[n])) {
+                    // legacy check needed?
+                    logger.error(context, 'Invalid timestamp:%s', JSON.stringify(payload[0]));
+                    callback(new errors.BadTimestamp(payload));
+                    return;
+                }
+            }
         }
-    );
+    }
+
+    logger.debug(context, 'sendUpdateValueNgsiLD \n ending payload=%j', payload);
+
+    for (let m = 0; m < payload.length; m++) {
+        for (const key in payload[m]) {
+            // purge object_id from payload
+            if (payload[m][key] && payload[m][key].object_id) {
+                delete payload[m][key].object_id;
+            }
+        }
+        payload[m] = NGSIUtils.castJsonNativeAttributes(payload[m]); // native types
+    }
+    logger.debug(context, 'sendUpdateValueNgsiLD \n payload with native types and without object_id %j', payload);
+
+    options.json = payload;
+    try {
+        if (payload instanceof Array) {
+            options.json = _.map(options.json, formatAsNGSILD);
+        } else {
+            options.json.id = entityName;
+            options.json.type = typeInformation.type;
+            options.json = [formatAsNGSILD(options.json)];
+        }
+    } catch (error) {
+        return callback(new errors.BadGeocoordinates(JSON.stringify(payload)));
+    }
+
+    if (typeInformation.active) {
+        addLinkedEntities(typeInformation, options.json);
+    }
+
+    // Prevent to update an entity with an empty payload
+    if (
+        Object.keys(options.json).length > 0 &&
+        (options.json.length > 1 || (options.json.length === 1 && Object.keys(options.json[0]).length > 2)) // more than id and type
+    ) {
+        logger.debug(context, 'Updating device value in the Context Broker at [%s]', options.url);
+        logger.debug(context, 'Using the following NGSI LD request:\n\n%s\n\n', JSON.stringify(options, null, 4));
+        request(
+            options,
+            generateNGSILDOperationHandler('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);
+    }
 }
 
 exports.convertAttrNGSILD = convertAttrNGSILD;