iotagent-node-lib 4.5.0 → 4.7.0

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

@@ -28,13 +28,11 @@
 const request = require('../../request-shim');
 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');
@@ -45,83 +43,6 @@ const NGSIUtils = require('./ngsiUtils');
 
 const NGSI_LD_URN = 'urn:ngsi-ld:';
 
-/**
- * Adds timestamp to ngsi payload entities accoding to timezone, and an optional timestampvalue.
- *
- * @param      {Object}   payload         NGSIv2 payload with one or more entities
- * @param      String     timezone        TimeZone value (optional)
- * @param      String     timestampValue  Timestamp value (optional). If not provided current timestamp is used
- * @param     Boolean     skipMetadataAtt  An optional flag to indicate if timestamp should be added to each metadata attribute. Default is false
- * @return     {Object}                   NGSIv2 payload entities with timestamp
- */
-function addTimestamp(payload, timezone, timestampValue) {
-    function addTimestampEntity(entity, timezone, timestampValue) {
-        const timestamp = {
-            type: constants.TIMESTAMP_TYPE_NGSI2
-        };
-
-        if (timestampValue) {
-            timestamp.value = timestampValue;
-        } else if (!timezone) {
-            timestamp.value = new Date().toISOString();
-        } else {
-            timestamp.value = moment().tz(timezone).format('YYYY-MM-DD[T]HH:mm:ss.SSSZ');
-        }
-
-        function addMetadata(attribute) {
-            let timestampFound = false;
-
-            if (!attribute.metadata) {
-                attribute.metadata = {};
-            }
-
-            for (let i = 0; i < attribute.metadata.length; i++) {
-                if (attribute.metadata[i] === constants.TIMESTAMP_ATTRIBUTE) {
-                    if (
-                        attribute.metadata[constants.TIMESTAMP_ATTRIBUTE].type === constants.TIMESTAMP_TYPE_NGSI2 &&
-                        attribute.metadata[constants.TIMESTAMP_ATTRIBUTE].value === timestamp.value
-                    ) {
-                        timestampFound = true;
-                        break;
-                    }
-                }
-            }
-
-            if (!timestampFound) {
-                attribute.metadata[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
-            }
-
-            return attribute;
-        }
-        let keyCount = 0;
-        for (const key in entity) {
-            /* eslint-disable-next-line  no-prototype-builtins */
-            if (entity.hasOwnProperty(key) && key !== 'id' && key !== 'type') {
-                addMetadata(entity[key]);
-                keyCount += 1;
-            }
-        }
-        // Add timestamp just to entity with attrs: multientity plugin could
-        // create empty entities just with id and type.
-        if (keyCount > 0) {
-            entity[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
-        }
-
-        return entity;
-    }
-
-    if (payload instanceof Array) {
-        for (let i = 0; i < payload.length; i++) {
-            if (!utils.isTimestampedNgsi2(payload[i])) {
-                payload[i] = addTimestampEntity(payload[i], timezone, timestampValue);
-            }
-        }
-
-        return payload;
-    }
-    return addTimestampEntity(payload, timezone, timestampValue);
-}
-
 /**
  * Amends an NGSIv2 attribute to NGSI-LD format
  * All native JSON types are respected and cast as Property values
@@ -503,560 +424,389 @@ function addLinkedEntities(typeInformation, json) {
  * @param {Object} typeInformation  Configuration information for the device.
  * @param {String} token            User token to identify against the PEP Proxies (optional).
  */
-function sendUpdateValueNgsiLD(entityName, attributes, typeInformation, token, callback) {
-    logger.debug(
-        context,
-        'sendUpdateValueNgsiLD called with: \n entityName=%s \n attributes=%j \n typeInformation=%j',
-        entityName,
-        attributes,
-        typeInformation
-    );
-    const payload = [
-        {
-            id: entityName
+/**
+ * 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.
+ *
+ * @param {String} entityName       Name of the entity to register.
+ * @param {Array} measures          measure array containing the values to update.
+ * @param {Object} typeInformation  Configuration information for the device.
+ * @param {String} token            User token to identify against the PEP Proxies (optional).
+ */
+function sendUpdateValueNgsiLD(entityName, originMeasures, originTypeInformation, token, callback) {
+    //aux function used to builf JEXL context.
+    //it returns a flat object from an Attr array
+    function reduceAttrToPlainObject(attrs, initObj = {}) {
+        if (attrs !== undefined && Array.isArray(attrs)) {
+            return attrs.reduce((result, item) => {
+                result[item.name] = item.value;
+                return result;
+            }, initObj);
+        } else {
+            return initObj;
         }
-    ];
-
-    const url = '/ngsi-ld/v1/entityOperations/upsert/?options=update';
-
-    if (typeInformation && typeInformation.type) {
-        payload[0].type = typeInformation.type;
     }
+    //Make a clone and overwrite
+    const idTypeSSSList = pluginUtils.getIdTypeServSubServiceFromDevice(originTypeInformation);
 
-    if (config.getConfig().appendMode === false) {
-        payload.actionType = 'update';
-    } else {
-        payload.actionType = 'append';
+    //Check mandatory information: type
+    if (!originTypeInformation || !originTypeInformation.type) {
+        callback(new errors.TypeNotFound(null, entityName, originTypeInformation));
+        return;
     }
 
-    const options = NGSIUtils.createRequestObject(url, typeInformation, token);
-    options.method = 'POST';
+    const payload = []; //will store the final payload
+    let entities = {};
 
-    if (typeInformation && typeInformation.staticAttributes) {
-        attributes = attributes.concat(typeInformation.staticAttributes);
-    }
+    const currentIsoDate = new Date().toISOString();
+    const currentMoment = moment(currentIsoDate);
+    //Managing timestamp (mustInsertTimeInstant flag to decide if we should insert Timestamp later on)
+    const mustInsertTimeInstant =
+        originTypeInformation.timestamp !== undefined ? originTypeInformation.timestamp : false;
 
-    if (!typeInformation || !typeInformation.type) {
-        callback(new errors.TypeNotFound(null, entityName, typeInformation));
-        return;
+    // Check if measures is a single measure or a array of measures (a multimeasure)
+    if (originMeasures[0] && !originMeasures[0][0]) {
+        originMeasures = [originMeasures];
     }
-    const idTypeSSSList = pluginUtils.getIdTypeServSubServiceFromDevice(typeInformation);
-    logger.debug(context, 'sendUpdateValueNgsiLD \n idTypeSSS are %j ', idTypeSSSList);
-    const measureAttrsForCtxt = [];
 
-    // 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;
-            }
-        }
-        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 {
-                        payload[0][attr.name] = {
-                            value: payload[0][attr.name] ? payload[0][attr.name].value : undefined,
-                            type: attr.type
-                        };
-                    }
-                }
-            });
-        }
-    } 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.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));
-                        }
-                    }
-                });
-            }
-            // 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
-            }
+    for (let measures of originMeasures) {
+        entities = {}; //{entityName:{entityType:[attrs]}}  //SubGoal Populate entities data structure
+        let jexlctxt = {}; //will store the whole context (not just for JEXL)
 
-            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);
+        let plainMeasures = null; //will contain measures POJO
+        //Make a clone and overwrite
+        const typeInformation = JSON.parse(JSON.stringify(originTypeInformation));
+
+        //Rename all measures with matches with id and type to measure_id and measure_type
+        for (const measure of measures) {
+            if (measure.name === 'id' || measure.name === 'type') {
+                measure.name = constants.MEASURE + measure.name;
             }
         }
+
+        //Make a copy of measures in an plain object: plainMeasures
+        plainMeasures = reduceAttrToPlainObject(measures);
+        //Build the initital JEXL Context
+        //All the measures (avoid references make another copy instead)
+        jexlctxt = reduceAttrToPlainObject(measures);
+        //All the static
+        jexlctxt = reduceAttrToPlainObject(typeInformation.staticAttributes, jexlctxt);
+        //id type Service and Subservice
+        jexlctxt = reduceAttrToPlainObject(idTypeSSSList, jexlctxt);
+
         logger.debug(
             context,
-            'sendUpdateValueNgsiLD \n pre-initial explicitAttrs payload=%j \n selectedAttrs',
-            payload,
-            selectedAttrs
+            'sendUpdateValueNgsiLD loop with: entityName=%s,  measures=%j,  typeInformation=%j, initial jexlContext=%j, timestamp=%j',
+            entityName,
+            plainMeasures,
+            typeInformation,
+            jexlctxt,
+            mustInsertTimeInstant
         );
 
-        // 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 {
-                        payload[0][attr.name] = {
-                            value: payload[0][attr.name] ? payload[0][attr.name].value : undefined,
-                            type: attr.type
-                        };
-                    }
-                }
-            });
+        //Now we can calculate the EntityName of primary entity
+        let entityNameCalc = null;
+        if (typeInformation.entityNameExp !== undefined && typeInformation.entityNameExp !== '') {
+            try {
+                logger.debug(context, 'sendUpdateValueNgsiLD entityNameExp %j', typeInformation.entityNameExp);
+                entityNameCalc = expressionPlugin.applyExpression(
+                    typeInformation.entityNameExp,
+                    jexlctxt,
+                    typeInformation
+                );
+            } catch (e) {
+                logger.debug(
+                    context,
+                    'Error evaluating expression for entityName: %j with context: %j',
+                    typeInformation.entityNameExp,
+                    jexlctxt
+                );
+            }
         }
-    } // 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);
+        entityName = entityNameCalc ? entityNameCalc : entityName;
+        //enrich JEXL context
+        jexlctxt.entity_name = entityName;
 
-    // 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);
-    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
-                }
-            });
+        let preprocessedAttr = [];
+        //Add Raw Static, Lazy, Command and Actives attr attributes
+        if (typeInformation && typeInformation.staticAttributes) {
+            preprocessedAttr = preprocessedAttr.concat(typeInformation.staticAttributes);
         }
-    }
-    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) {
-                    attr = typeInformation.active.find((obj) => {
-                        return obj.name === j;
-                    });
-                }
-            }
-            if (attr && attr.name) {
-                if (['id', 'type'].includes(attr.name)) {
-                    // invalid mapping
+        if (typeInformation && typeInformation.lazy) {
+            preprocessedAttr = preprocessedAttr.concat(typeInformation.lazy);
+        }
+        if (typeInformation && typeInformation.active) {
+            preprocessedAttr = preprocessedAttr.concat(typeInformation.active);
+        }
+
+        //Proccess every proto Attribute to populate entities data steuture
+        entities[entityName] = {};
+        entities[entityName][typeInformation.type] = [];
+
+        for (const currentAttr of preprocessedAttr) {
+            let hitted = false; //any measure, expressiom or value hit the attr (avoid propagate "silent attr" with null values )
+            let attrEntityName = entityName;
+            let attrEntityType = typeInformation.type;
+            let valueExpression = null;
+            //manage active attr without object__id (name by default)
+            currentAttr.object_id = currentAttr.object_id ? currentAttr.object_id : currentAttr.name;
+            //Enrich the attr (skip, hit, value, meta-timeInstant)
+            currentAttr.skipValue = currentAttr.skipValue ? currentAttr.skipValue : null;
+
+            //determine AttrEntityName for multientity
+            if (
+                currentAttr.entity_name !== null &&
+                currentAttr.entity_name !== undefined &&
+                currentAttr.entity_name !== '' &&
+                typeof currentAttr.entity_name === 'string'
+            ) {
+                try {
+                    logger.debug(
+                        context,
+                        'Evaluating attribute: %j, for entity_name(exp):%j, with ctxt: %j',
+                        currentAttr.name,
+                        currentAttr.entity_name,
+                        jexlctxt
+                    );
+                    attrEntityName = jexlParser.applyExpression(currentAttr.entity_name, jexlctxt, typeInformation);
+                    if (!attrEntityName) {
+                        attrEntityName = currentAttr.entity_name;
+                    }
+                } catch (e) {
                     logger.debug(
                         context,
-                        'sendUpdateValueNgsiLD \n invalid mapping for attr %j \n newAttr %j',
-                        attr,
-                        newAttr
+                        'Exception evaluating entityNameExp:%j, with jexlctxt: %j',
+                        currentAttr.entity_name,
+                        jexlctxt
                     );
-                    delete payload[0][attr.object_id];
-                    attr = undefined; // stop processing attr
-                    newAttr = undefined;
-                } else {
-                    ctxt[attr.name] = payload[0][j].value;
+                    attrEntityName = currentAttr.entity_name;
                 }
             }
-            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;
-                }
+            //determine AttrEntityType for multientity
+            if (
+                currentAttr.entity_type !== null &&
+                currentAttr.entity_type !== undefined &&
+                currentAttr.entity_type !== '' &&
+                typeof currentAttr.entity_type === 'string'
+            ) {
+                attrEntityType = currentAttr.entity_type;
             }
 
-            // Apply expression
-            if (attr && attr.expression) {
-                logger.debug(
-                    context,
-                    'sendUpdateValueNgsiLD \n apply expression %j \n over ctxt %j \n and device %j',
-                    attr.expression,
-                    ctxt,
-                    typeInformation
-                );
-                let res = null;
+            //PRE POPULATE CONTEXT
+            jexlctxt[currentAttr.name] = plainMeasures[currentAttr.object_id];
+
+            //determine Value
+            if (currentAttr.value !== undefined) {
+                //static attributes already have a value
+                hitted = true;
+                valueExpression = currentAttr.value;
+            } else if (plainMeasures[currentAttr.object_id] !== undefined) {
+                //we have got a meaure for that Attr
+                //actives ¿lazis?
+                hitted = true;
+                valueExpression = plainMeasures[currentAttr.object_id];
+            }
+            //remove measures that has been shadowed by an alias (some may be left and managed later)
+            //Maybe we must filter object_id if there is name == object_id
+            measures = measures.filter((item) => item.name !== currentAttr.object_id && item.name !== currentAttr.name);
+
+            if (
+                currentAttr.expression !== undefined &&
+                currentAttr.expression !== '' &&
+                typeof currentAttr.expression === 'string'
+            ) {
                 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
+                    hitted = true;
+                    valueExpression = jexlParser.applyExpression(currentAttr.expression, jexlctxt, typeInformation);
+                    //we fallback to null if anything unexpecte happend
+                    if (valueExpression === null || valueExpression === undefined || Number.isNaN(valueExpression)) {
+                        valueExpression = null;
                     }
                 } catch (e) {
-                    logger.error(context, 'sendUpdateValueNgsiLD \n apply expression exception %j \n', e);
-                    res = ctxt[attr.name]; // TBD: add reference to test
+                    valueExpression = null;
                 }
-
-                // jexl expression plugin
-                newAttr.value = res;
-
                 logger.debug(
                     context,
-                    'sendUpdateValueNgsiLD \n apply expression result %j \n newAttr %j',
-                    res,
-                    newAttr
+                    'Evaluated attr: %j, with expression: %j, and ctxt: %j resulting: %j',
+                    currentAttr.name,
+                    currentAttr.expression,
+                    jexlctxt,
+                    valueExpression
                 );
             }
 
-            // 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
+            currentAttr.hitted = hitted;
+            currentAttr.value = valueExpression;
+
+            //store de New Attributte in entity data structure
+            if (hitted === true) {
+                if (entities[attrEntityName] === undefined) {
+                    entities[attrEntityName] = {};
+                }
+                if (entities[attrEntityName][attrEntityType] === undefined) {
+                    entities[attrEntityName][attrEntityType] = [];
+                }
+                //store de New Attributte
+                entities[attrEntityName][attrEntityType].push(currentAttr);
+            }
+
+            //RE-Populate de JEXLcontext (except for null or NaN we preffer undefined)
+            jexlctxt[currentAttr.name] = valueExpression;
+
+            // Expand metadata value expression
+            if (currentAttr.metadata) {
+                for (const metaKey in currentAttr.metadata) {
+                    if (currentAttr.metadata[metaKey].expression && metaKey !== constants.TIMESTAMP_ATTRIBUTE) {
+                        const newAttrMeta = {};
+                        if (currentAttr.metadata[metaKey].type) {
+                            newAttrMeta.type = currentAttr.metadata[metaKey].type;
+                        }
+                        let metaValueExpression;
+                        try {
+                            metaValueExpression = jexlParser.applyExpression(
+                                currentAttr.metadata[metaKey].expression,
+                                jexlctxt,
+                                typeInformation
                             );
-                            newEntityName = attr.entity_name;
+                            //we fallback to null if anything unexpecte happend
+                            if (
+                                metaValueExpression === null ||
+                                metaValueExpression === undefined ||
+                                Number.isNaN(metaValueExpression)
+                            ) {
+                                metaValueExpression = null;
+                            }
+                        } catch (e) {
+                            metaValueExpression = null;
                         }
-                        newEntityName = newEntityName ? newEntityName : attr.entity_name;
-                    } catch (e) {
-                        logger.error(context, 'sendUpdateValueNgsiLD \n MULTI apply expression exception %j \n', e);
-                        newEntityName = attr.entity_name;
+                        newAttrMeta.value = metaValueExpression;
+                        currentAttr.metadata[metaKey] = newAttrMeta;
                     }
-                    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 = 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];
-                    }
+        //now we can compute explicit (Bool or Array) with the complete JexlContext
+        let explicit = false;
+        if (typeof typeInformation.explicitAttrs === 'string') {
+            try {
+                explicit = jexlParser.applyExpression(typeInformation.explicitAttrs, jexlctxt, typeInformation);
+                if (explicit instanceof Array && explicit.length > 0 && mustInsertTimeInstant) {
+                    explicit.push(constants.TIMESTAMP_ATTRIBUTE);
                 }
-                // 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
+                logger.debug(
+                    context,
+                    'Calculated explicitAttrs with expression: %j and ctxt: %j resulting: %j',
+                    typeInformation.explicitAttrs,
+                    jexlctxt,
+                    explicit
+                );
+            } catch (e) {
+                // nothing to do: exception is already logged at info level
+            }
+        } else if (typeof typeInformation.explicitAttrs === 'boolean') {
+            explicit = typeInformation.explicitAttrs;
+        }
+
+        //more mesures may be added to the attribute list (unnhandled/left mesaures) l
+        if (explicit === false && Object.keys(measures).length > 0) {
+            entities[entityName][typeInformation.type] = entities[entityName][typeInformation.type].concat(measures);
+        }
+
+        //PRE-PROCESSING FINISHED
+        //Explicit ATTRS and SKIPVALUES will be managed while we build NGSI payload
+        //Get ready to build and send NGSI payload (entities-->payload)
+
+        for (const ename in entities) {
+            for (const etype in entities[ename]) {
+                const e = {};
+                e.id = String(ename);
+                e.type = String(etype);
+                const timestamp = { type: constants.TIMESTAMP_TYPE_NGSI2 }; //timestamp scafold-attr for insertions.
+                let timestampAttrs = null;
+                if (mustInsertTimeInstant) {
+                    // get timestamp for current entity
+
+                    timestampAttrs = entities[ename][etype].filter(
+                        (item) => item.name === constants.TIMESTAMP_ATTRIBUTE
+                    );
+                    if (timestampAttrs && timestampAttrs.length > 0) {
+                        timestamp.value = timestampAttrs[0].value;
                     }
-                }
-                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 (timestamp.value) {
+                        if (!moment(timestamp.value, moment.ISO_8601, true).isValid()) {
+                            callback(new errors.BadTimestamp(timestamp.value, entityName, typeInformation));
+                            return;
+                        }
+                    } else if (!typeInformation.timezone) {
+                        timestamp.value = currentIsoDate;
+                        jexlctxt[constants.TIMESTAMP_ATTRIBUTE] = timestamp.value;
+                    } else {
+                        timestamp.value = currentMoment
+                            .tz(typeInformation.timezone)
+                            .format('YYYY-MM-DD[T]HH:mm:ss.SSSZ');
+                        jexlctxt[constants.TIMESTAMP_ATTRIBUTE] = timestamp.value;
                     }
                 }
-                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
-                        );
+                //extract attributes
+                let isEmpty = true;
+                for (const attr of entities[ename][etype]) {
+                    if (
+                        attr.name !== 'id' &&
+                        attr.name !== 'type' &&
+                        (attr.value !== attr.skipValue || attr.skipValue === undefined) &&
+                        (attr.hitted || attr.hitted === undefined) && //undefined is for pure measures
+                        (typeof explicit === 'boolean' || //true and false already handled
+                            (explicit instanceof Array && //check the array version
+                                (explicit.includes(attr.name) ||
+                                    explicit.some(
+                                        (item) => attr.object_id !== undefined && item.object_id === attr.object_id
+                                    ))))
+                    ) {
+                        isEmpty = false;
+                        if (mustInsertTimeInstant) {
+                            // Add TimeInstant to all attribute metadata of all entities
+                            if (attr.name !== constants.TIMESTAMP_ATTRIBUTE) {
+                                if (!attr.metadata) {
+                                    attr.metadata = {};
+                                }
+                                attr.metadata[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
+                            }
+                        }
+                        e[attr.name] = { type: attr.type, value: attr.value, metadata: attr.metadata };
                     }
                 }
-                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 (!isEmpty) {
+                    if (mustInsertTimeInstant) {
+                        e[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
                     }
+                    payload.push(e);
                 }
             }
-        } // 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 > 1) {
-                // include metadata with TimeInstant in attrs when TimeInstant is provided as measure in all entities
-                payload[0] = addTimestamp(payload[0], typeInformation.timezone, timestampValue);
-            }
-        } else {
-            // jshint maxdepth:5
-            for (let n = 0; n < payload.length; n++) {
-                if (!utils.isTimestampedNgsi2(payload[n])) {
-                    // legacy check needed?
-                    payload[n] = 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, entityName, typeInformation));
-                    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;
-            }
         }
-    }
-    logger.debug(context, 'sendUpdateValueNgsiLD \n payload and without object_id %j', payload);
+    } // end for (let measures of originMeasures)
 
+    const url = '/ngsi-ld/v1/entityOperations/upsert/?options=update';
+    const options = NGSIUtils.createRequestObject(url, originTypeInformation, token);
     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.type = originTypeInformation.type;
             options.json = [formatAsNGSILD(options.json)];
         }
     } catch (error) {
-        return callback(new errors.BadGeocoordinates(JSON.stringify(payload), typeInformation));
+        return callback(new errors.BadGeocoordinates(JSON.stringify(payload), originTypeInformation));
     }
 
-    if (typeInformation.active) {
-        addLinkedEntities(typeInformation, options.json);
+    if (originTypeInformation.active) {
+        addLinkedEntities(originTypeInformation, options.json);
     }
 
     // Prevent to update an entity with an empty payload
@@ -1068,7 +818,7 @@ function sendUpdateValueNgsiLD(entityName, attributes, typeInformation, token, c
         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)
+            generateNGSILDOperationHandler('update', entityName, originTypeInformation, token, options, callback)
         );
     } else {
         logger.debug(