iotagent-node-lib 3.4.3 → 4.0.0

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

@@ -30,13 +30,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 NGSIUtils = require('./ngsiUtils');
 const logger = require('logops');
@@ -94,83 +92,6 @@ function formatGeoAttrs(attr) {
     return obj;
 }
 
-/**
- * Adds timestamp to ngsiv2 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 addTimestampNgsi2(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);
-}
-
 /**
  * Generate an operation handler for NGSIv2-based operations (query and update). The handler takes care of identifiying
  * the errors and calling the appropriate callback with a success or a failure depending on how the operation ended.
@@ -328,677 +249,373 @@ function sendQueryValueNgsi2(entityName, attributes, typeInformation, token, cal
  * array should comply to the NGSIv2's attribute format.
  *
  * @param {String} entityName       Name of the entity to register.
- * @param {Array} attributes        Attribute array containing the values to update.
+ * @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 sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, callback) {
-    logger.debug(
-        context,
-        'sendUpdateValueNgsi2 called with: entityName=%s  attributes=%j  typeInformation=%j',
-        entityName,
-        attributes,
-        typeInformation
-    );
-    const payload = {
-        entities: [
-            {
-                // CB entity id should be always a String
-                id: String(entityName)
-            }
-        ]
-    };
-
-    let url = '/v2/op/update';
-
-    if (typeInformation && typeInformation.type) {
-        // CB entity type should be always a String
-        payload.entities[0].type = String(typeInformation.type);
+function sendUpdateValueNgsi2(entityName, measures, typeInformation, 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;
+        }
     }
 
-    payload.actionType = 'append';
-
-    let options = NGSIUtils.createRequestObject(url, typeInformation, token);
+    let entities = {}; //{entityName:{entityType:[attrs]}}  //SubGoal Populate entoties data striucture
+    let jexlctxt = {}; //will store the whole context (not just for JEXL)
+    let payload = {}; //will store the final payload
+    let timestamp = { type: constants.TIMESTAMP_TYPE_NGSI2 }; //timestamp scafold-attr for insertions.
+    let plainMeasures = null; //will contain measures POJO
+    let idTypeSSSList = pluginUtils.getIdTypeServSubServiceFromDevice(typeInformation);
 
-    if (typeInformation && typeInformation.staticAttributes) {
-        attributes = attributes.concat(typeInformation.staticAttributes);
-    }
+    //Make a clone and overwrite
+    typeInformation = JSON.parse(JSON.stringify(typeInformation));
 
+    //Check mandatory information: type
     if (!typeInformation || !typeInformation.type) {
         callback(new errors.TypeNotFound(null, entityName));
         return;
     }
 
-    let idTypeSSSList = pluginUtils.getIdTypeServSubServiceFromDevice(typeInformation);
-    logger.debug(context, 'sendUpdateValueNgsi2 idTypeSSS are %j ', idTypeSSSList);
-    let measureAttrsForCtxt = [];
+    //Make a copy of measures in an plain object: plainMeasures
+    plainMeasures = reduceAttrToPlainObject(measures);
 
-    // 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.entities[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.entities[0][attributes[i].name].metadata = metadata;
-                }
+    //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);
+
+    //Managing timestamp (mustInsertTimeInstant flag to decide if we should insert Timestamp later on)
+    const mustInsertTimeInstant =
+        typeInformation.timestamp !== undefined
+            ? typeInformation.timestamp
+            : config.getConfig().timestamp !== undefined
+            ? config.getConfig().timestamp
+            : false;
+
+    if (mustInsertTimeInstant) {
+        //remove TimeInstant from measures
+        measures = measures.filter((item) => item.name !== constants.TIMESTAMP_ATTRIBUTE);
+
+        if (plainMeasures[constants.TIMESTAMP_ATTRIBUTE]) {
+            //if it comes from a measure
+            if (moment(plainMeasures[constants.TIMESTAMP_ATTRIBUTE], moment.ISO_8601, true).isValid()) {
+                timestamp.value = plainMeasures[constants.TIMESTAMP_ATTRIBUTE];
             } else {
-                callback(new errors.BadRequest(null, entityName));
-                return;
+                callback(new errors.BadTimestamp(null, entityName));
             }
+        } else if (!typeInformation.timezone) {
+            timestamp.value = new Date().toISOString();
+            jexlctxt[constants.TIMESTAMP_ATTRIBUTE] = timestamp.value;
+        } else {
+            timestamp.value = moment().tz(typeInformation.timezone).format('YYYY-MM-DD[T]HH:mm:ss.SSSZ');
+            jexlctxt[constants.TIMESTAMP_ATTRIBUTE] = timestamp.value;
         }
-        logger.debug(context, 'sendUpdateValueNgsi2 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.entities[0][attr.object_id] = {
-                            value: payload.entities[0][attr.object_id]
-                                ? payload.entities[0][attr.object_id].value
-                                : undefined,
-                            type: attr.type,
-                            object_id: attr.object_id
-                        };
-                    } else {
-                        payload.entities[0][attr.name] = {
-                            value: payload.entities[0][attr.name] ? payload.entities[0][attr.name].value : undefined,
-                            type: attr.type
-                        };
-                    }
-                }
-            });
+    }
+
+    logger.debug(
+        context,
+        'sendUpdateValueNgsi2 called with: entityName=%s,  measures=%j,  typeInformation=%j, initial jexlContext=%j, timestamp=%j with value=%j',
+        entityName,
+        plainMeasures,
+        typeInformation,
+        jexlctxt,
+        mustInsertTimeInstant,
+        timestamp.value
+    );
+
+    //Now we can calculate the EntityName of primary entity
+    let entityNameCalc = null;
+    if (typeInformation.entityNameExp !== undefined && typeInformation.entityNameExp !== '') {
+        try {
+            logger.debug(context, 'sendUpdateValueNgsi2 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
+            );
         }
-    } 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);
-                    // check measureAttr by object_id -> if in active
-                    let j = 0;
-                    let found = false;
-                    while (j < typeInformation.active.length && !found) {
-                        if (attributes[i].name === typeInformation.active[j].object_id) {
-                            let measureAttrByObjectId = {
-                                name: typeInformation.active[j].name,
-                                value: attributes[i].value,
-                                type: attributes[i].type
-                            };
-                            attributesCtxt.push(measureAttrByObjectId);
-                            found = true;
-                        }
-                        j++;
-                    }
-                }
-            }
-            // This context is just to calculate explicitAttrs when is an expression
+    }
 
-            let ctxt = expressionPlugin.extractContext(attributesCtxt.concat(idTypeSSSList));
-            // typeInformation.active all attrs with expressions
-            if (typeInformation.active) {
-                typeInformation.active.forEach(function (att) {
-                    if (att.expression !== undefined) {
-                        let expandedAttr = {
-                            name: att.name,
-                            value: att.expression,
-                            type: att.type
-                        };
-                        attributesCtxt.push(expandedAttr);
-                        if (att.object_id !== undefined) {
-                            let expandedAttrByObjectId = {
-                                name: att.object_id,
-                                value: att.expression,
-                                type: att.type
-                            };
-                            attributesCtxt.push(expandedAttrByObjectId);
-                        }
-                        ctxt = expressionPlugin.extractContext(attributesCtxt.concat(idTypeSSSList));
-                    }
-                });
-            }
-            // calculate expression for explicitAttrs
+    entityName = entityNameCalc ? entityNameCalc : entityName;
+    //enrich JEXL context
+    jexlctxt['entity_name'] = entityName;
+
+    let preprocessedAttr = [];
+    //Add Raw Static, Lazy, Command and Actives attr attributes
+    if (typeInformation && typeInformation.staticAttributes) {
+        preprocessedAttr = preprocessedAttr.concat(typeInformation.staticAttributes);
+    }
+    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 (let 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, 'sendUpdateValueNgsi2 selectedAttrs ctxt %j', ctxt);
-                let 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,
-                        'sendUpdateValueNgsi2 none selectedAttrs with %j and ctxt %j',
-                        typeInformation.explicitAttrs,
-                        ctxt
-                    );
-                    return callback(null);
+                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) {
-                // nothing to do: exception is already logged at info level
+                logger.debug(
+                    context,
+                    'Exception evaluating entityNameExp:%j, with jexlctxt: %j',
+                    currentAttr.entity_name,
+                    jexlctxt
+                );
+                attrEntityName = currentAttr.entity_name;
             }
-
-            typeInformation.active.forEach((attr) => {
-                if (selectedAttrs.includes(attr.name)) {
-                    selectedAttrs.push(attr.object_id);
-                }
-                // Check if selectedAttrs includes an attribute with format {object_id: xxxx}
-                if (selectedAttrs.includes({ object_id: attr.object_id })) {
-                    selectedAttrs.push(attr.object_id);
-                }
-            });
-        } else if (typeInformation.explicitAttrs && typeof typeInformation.explicitAttrs === 'boolean') {
-            // explicitAtts is true => Add just measures which are defined in active attributes
-            // and active attributes with expressions
-            // and TimeInstant
-            selectedAttrs = ['TimeInstant'];
-            typeInformation.active.forEach((attr) => {
-                // Measures
-                if (attr.expression !== undefined) {
-                    selectedAttrs.push(attr.name);
-                    selectedAttrs.push(attr.object_id);
-                } else {
-                    // check if active attr is receiving a measure
-                    let i = 0;
-                    let found = false;
-                    while (i < attributes.length && !found) {
-                        if (attributes[i].name && attributes[i].type) {
-                            if (attributes[i].name === attr.object_id || attributes[i].name === attr.name) {
-                                selectedAttrs.push(attr.name);
-                                selectedAttrs.push(attr.object_id);
-                                found = true;
-                            }
-                        }
-                        i++;
-                    }
-                }
-            });
         }
-        // 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.entities[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.entities[0][attributes[i].name].object_id = attr.object_id;
-                }
-                const metadata = NGSIUtils.getMetaData(typeInformation, attributes[i].name, attributes[i].metadata);
-                if (metadata) {
-                    payload.entities[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);
-            }
+
+        //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;
         }
-        logger.debug(
-            context,
-            'sendUpdateValueNgsi2 pre-initial explicitAttrs payload=%j selectedAttrs=%j',
-            payload,
-            selectedAttrs
-        );
-        let selectedAttrsByObjectId = selectedAttrs
-            .filter((o) => o !== undefined && o.object_id)
-            .map(function (el) {
-                return el.object_id;
-            });
 
-        // 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.entities[0][attr.object_id] = {
-                            value: payload.entities[0][attr.object_id]
-                                ? payload.entities[0][attr.object_id].value
-                                : payload.entities[0][attr.name]
-                                ? payload.entities[0][attr.name].value
-                                : undefined,
-                            type: attr.type,
-                            object_id: attr.object_id
-                        };
-                    } else {
-                        payload.entities[0][attr.name] = {
-                            value: payload.entities[0][attr.name] ? payload.entities[0][attr.name].value : undefined,
-                            type: attr.type
-                        };
-                    }
-                } else if (attr.object_id !== undefined && selectedAttrsByObjectId.includes(attr.object_id)) {
-                    payload.entities[0][attr.object_id] = {
-                        value: payload.entities[0][attr.object_id]
-                            ? payload.entities[0][attr.object_id].value
-                            : payload.entities[0][attr.name]
-                            ? payload.entities[0][attr.name].value
-                            : undefined,
-                        type: attr.type,
-                        object_id: attr.object_id
-                    };
+        //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 {
+                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) {
+                valueExpression = null;
+            }
+            logger.debug(context, 
+                'Evaluated attr: %j, with expression: %j, and ctxt: %j resulting: %j', 
+                currentAttr.name,
+                currentAttr.expression, 
+                jexlctxt,
+                valueExpression
+            );
         }
-    } // END check explicitAttrs
-    logger.debug(context, 'sendUpdateValueNgsi2 initial payload=%j', payload);
-
-    const currentEntity = payload.entities[0];
 
-    // Prepare attributes for expresionPlugin
-    const attsArray = pluginUtils.extractAttributesArrayFromNgsi2Entity(currentEntity);
+        currentAttr.hitted = hitted;
+        currentAttr.value = valueExpression;
 
-    // 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);
-    let ctxt = expressionPlugin.extractContext(attributesCtxt, typeInformation);
-    logger.debug(context, 'sendUpdateValueNgsi2 initial ctxt %j ', ctxt);
+        //add TimeInstant to attr metadata
+        if (mustInsertTimeInstant) {
+            if (!currentAttr.metadata) {
+                currentAttr.metadata = {};
+            }
+            currentAttr.metadata[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
+        }
 
-    // Sort currentEntity to get first attrs without expressions (checking attrs in typeInformation.active)
-    // attributes without expressions should be processed before
-    logger.debug(context, 'sendUpdateValueNgsi2 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
-                }
-            });
+        //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;
     }
 
-    // Evaluate entityNameExp with a context including measures
-    if (typeInformation.entityNameExp !== undefined && typeInformation.entityNameExp !== '') {
+    //now we can compute explicit (Bool or Array) with the complete JexlContext
+    let explicit = false;
+    if (typeof typeInformation.explicitAttrs === 'string') {
         try {
-            logger.debug(context, 'sendUpdateValueNgsi2 entityNameExp %j ', typeInformation.entityNameExp);
-            entityName = expressionPlugin.applyExpression(typeInformation.entityNameExp, ctxt, typeInformation);
-            // CB entity id should be always a String
-            entityName = String(entityName);
-            payload.entities[0].id = entityName;
-            ctxt['entity_name'] = entityName;
-        } catch (e) {
+            explicit = jexlParser.applyExpression(typeInformation.explicitAttrs, jexlctxt, typeInformation);
+            if (explicit instanceof Array && mustInsertTimeInstant) {
+                explicit.push(constants.TIMESTAMP_ATTRIBUTE);
+            }
             logger.debug(
                 context,
-                'Error evaluating expression for entityName: %s with context: %s',
-                typeInformation.entityNameExp,
-                ctxt
+                '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;
     }
 
-    logger.debug(context, 'sendUpdateValueNgsi2 currentEntity sorted %j ', currentEntity);
-    let timestampValue = undefined;
-    // 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.entities[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
-                    logger.debug(
-                        context,
-                        'sendUpdateValueNgsi2 invalid mapping for attr=%j  newAttr=%j',
-                        attr,
-                        newAttr
-                    );
-                    delete payload.entities[0][attr.object_id];
-                    attr = undefined; // stop processing attr
-                    newAttr = undefined;
-                } else {
-                    ctxt[attr.name] = payload.entities[0][j].value;
+    //more mesures may be added to the attribute list (unnhandled/left mesaures) l
+    if (explicit === false && Object.keys(measures).length > 0) {
+        //add Timestamp to measures if needed
+        if (mustInsertTimeInstant) {
+            for (let currentMeasure of measures) {
+                if (!currentMeasure.metadata) {
+                    currentMeasure.metadata = {};
                 }
+                currentMeasure.metadata[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
             }
-            logger.debug(
-                context,
-                'sendUpdateValueNgsi2 procesing j=%j attr=%j ctxt=%j newAttr=%j ',
-                j,
-                attr,
-                ctxt,
-                newAttr
-            );
-            if (attr && attr.type) {
-                newAttr.type = attr.type;
-            }
+            //If just measures in the principal entity we missed the Timestamp.
+        }
+        entities[entityName][typeInformation.type] = entities[entityName][typeInformation.type].concat(measures);
+    }
 
-            // Apply expression
-            if (attr && attr.expression) {
-                logger.debug(
-                    context,
-                    'sendUpdateValueNgsi2 apply expression=%j over ctxt=%j 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);
-                        if (
-                            // By default undefined is handled like null: should not progress
-                            // Some op results (like nonexistent * 2) are a kind of null with a number type
-                            // but NaN value
-                            (attr.skipValue === undefined &&
-                                (res === null || (typeof res === 'number' && isNaN(res)))) ||
-                            (attr.skipValue !== undefined &&
-                                (res === attr.skipValue ||
-                                    (typeof res === 'number' && isNaN(res) && attr.skipValue === null)))
-                        ) {
-                            logger.debug(
-                                context,
-                                'sendUpdateValueNgsi2 skip value=%j for res=%j with expression=%j',
-                                attr.skipValue,
-                                res,
-                                attr.expression
-                            );
-                            delete payload.entities[0][j]; // remove measure attr
-                            attr = undefined; // stop process attr
-                        }
-                    } else {
-                        logger.info(
-                            context,
-                            'sendUpdateValueNgsi2 no context available for apply expression=%j',
-                            attr.expression
-                        );
-                        res = newAttr.value; // keep newAttr value
-                    }
-                } catch (e) {
-                    logger.error(context, 'sendUpdateValueNgsi2 apply expression exception=%j', e);
-                    if (attr && attr.name) {
-                        res = ctxt[attr.name];
-                    }
-                }
-                // jexl expression plugin
-                newAttr.value = res;
+    //PRE-PROCESSING FINISHED
+    //Explicit ATTRS and SKIPVALUES will be managed while we build NGSI payload
 
-                logger.debug(context, 'sendUpdateValueNgsi2 apply expression result=%j newAttr=%j', res, newAttr);
-                // update current context with value
-                if (attr && attr.name && ctxt[attr.name] !== undefined) {
-                    ctxt[attr.name] = newAttr.value;
-                }
-            }
+    //Get ready to build and send NGSI payload (entities-->payload)
+    payload.actionType = 'append';
 
-            // 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.info(
-                                context,
-                                'sendUpdateValueNgsi2 MULTI no context available for apply expression=%j',
-                                attr.entity_name
-                            );
-                            newEntityName = attr.entity_name;
-                        }
-                        newEntityName = newEntityName ? newEntityName : attr.entity_name;
-                    } catch (e) {
-                        logger.error(context, 'sendUpdateValueNgsi2 MULTI apply expression exception=%j', e);
-                        newEntityName = attr.entity_name;
-                    }
-                    logger.debug(
-                        context,
-                        'sendUpdateValueNgsi2 MULTI apply expression=%j result=%j payload=%j',
-                        attr.entity_name,
-                        newEntityName,
-                        payload
-                    );
-                }
-                // CB entity id and type should be always a String
-                let newEntity = {
-                    id: newEntityName ? String(newEntityName) : String(payload.entities[0].id),
-                    type: attr.entity_type ? String(attr.entity_type) : String(payload.entities[0].type)
-                };
-                // Check if there is already a newEntity created
-                const alreadyEntity = payload.entities.find((entity) => {
-                    return entity.id === newEntity.id && entity.type === newEntity.type;
-                });
-                if (alreadyEntity) {
-                    // Use alreadyEntity
-                    alreadyEntity[attr.name] = newAttr;
-                } else {
-                    // Add newEntity to payload.entities
-                    newEntity[attr.name] = newAttr;
-                    if (
-                        'timestamp' in typeInformation && typeInformation.timestamp !== undefined
-                            ? typeInformation.timestamp
-                            : config.getConfig().timestamp !== undefined
-                            ? config.getConfig().timestamp
-                            : timestampValue !== undefined
-                    ) {
-                        newEntity = addTimestampNgsi2(newEntity, typeInformation.timezone, timestampValue);
-                        logger.debug(context, 'sendUpdateValueNgsi2 timestamped newEntity=%j', newEntity);
-                    }
-                    payload.entities.push(newEntity);
-                }
-                if (attr && attr.name) {
-                    if (attr.name !== j) {
-                        logger.debug(
-                            context,
-                            'sendUpdateValueNgsi2 MULTI remove measure attr=%j keep alias j=%j from %j',
-                            j,
-                            attr,
-                            payload
-                        );
-                        delete payload.entities[0][j];
-                    }
-                }
-                // if (attr && (attr.entity_type || attr.entity_name))
-            } else {
-                // Not a multientity attr
-                if (attr && attr.name) {
-                    payload.entities[0][attr.name] = newAttr;
-                    if (attr.name !== j) {
-                        delete payload.entities[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,
-                            'sendUpdateValueNgsi2 newAttr is TimeInstant and new payload=%j',
-                            payload
-                        );
-                    }
-                }
+    payload.entities = [];
+    for (let ename in entities) {
+        for (let etype in entities[ename]) {
+            let e = {};
+            e.id = String(ename);
+            e.type = String(etype);
+            //extract attributes
+            let isEmpty = true;
+            for (let attr of entities[ename][etype]) {
+                //Handling id/type measures, skip, hit & explicit (condition)
                 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
+                    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
+                                ))))
                 ) {
-                    const extendedTime = compressTimestampPlugin.fromBasicToExtended(
-                        newAttr.metadata[constants.TIMESTAMP_ATTRIBUTE].value
-                    );
-                    if (extendedTime) {
-                        newAttr.metadata[constants.TIMESTAMP_ATTRIBUTE].value = extendedTime;
-                    }
+                    isEmpty = false;
+                    e[attr.name] = { type: attr.type, value: attr.value, metadata: attr.metadata };
                 }
             }
-        } // if (j !== 'id' || j !== 'type')
-
-        // final attr loop
-        logger.debug(
-            context,
-            'sendUpdateValueNgsi2 after procesing attr=%j  current entity=%j  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 (payload.entities.length > 0) {
-                for (let n = 0; n < payload.entities.length; n++) {
-                    // include metadata with TimeInstant in attrs when TimeInstant is provided as measure in all entities
-                    payload.entities[n] = addTimestampNgsi2(
-                        payload.entities[n],
-                        typeInformation.timezone,
-                        timestampValue
-                    );
+            if (!isEmpty) {
+                if (mustInsertTimeInstant) {
+                    e[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
                 }
-            }
-        } else {
-            // jshint maxdepth:5
-            for (let n = 0; n < payload.entities.length; n++) {
-                if (!utils.isTimestampedNgsi2(payload.entities[n])) {
-                    // legacy check needed?
-                    payload.entities[n] = addTimestampNgsi2(payload.entities[n], typeInformation.timezone);
-                    // jshint maxdepth:5
-                } else if (!utils.IsValidTimestampedNgsi2(payload.entities[n])) {
-                    // legacy check needed?
-                    logger.error(context, 'Invalid timestamp:%s', JSON.stringify(payload.entities[0]));
-                    callback(new errors.BadTimestamp(payload.entities));
-                    return;
-                }
-            }
-        }
-    }
-    logger.debug(context, 'sendUpdateValueNgsi2 ending payload=%j', payload);
-
-    for (let m = 0; m < payload.entities.length; m++) {
-        for (const key in payload.entities[m]) {
-            // purge object_id from payload
-            if (payload.entities[m][key] && payload.entities[m][key].object_id) {
-                delete payload.entities[m][key].object_id;
+                payload.entities.push(e);
             }
         }
-        payload.entities[m] = NGSIUtils.castJsonNativeAttributes(payload.entities[m]); // native types
     }
-    logger.debug(context, 'sendUpdateValueNgsi2 payload with native types and without object_id=%j', payload);
-
+  
+    let url = '/v2/op/update';
+    let options = NGSIUtils.createRequestObject(url, typeInformation, token);
     options.json = payload;
 
-    // Prevent to update an entity with an empty payload
+    // Prevent to update an entity with an empty payload: more than id and type
     if (
         Object.keys(options.json).length > 0 &&
         (options.json.entities.length > 1 ||
-            (options.json.entities.length === 1 && Object.keys(options.json.entities[0]).length > 2)) // more than id and type
+            (options.json.entities.length === 1 && Object.keys(options.json.entities[0]).length > 2))
     ) {
         // Final check: (to keep tests unchanged) before do CB requests
         //              one entity     -> request /v2/entities/ + entityName + /atts ?type=typeInformation.type
         //              multi entities -> request /v2/op/update
         // Note that the options object is prepared for the second case (multi entity), so we "patch" it
         // only in the first case
-        if (options.json.entities.length === 1) {
+
+        //Multientity more than one name o more than one type at primary entity
+        let multientity = Object.keys(entities).length > 1 || Object.keys(entities[entityName]).length > 1;
+
+        if (!multientity) {
             // recreate options object to use single entity update
             url = '/v2/entities?options=upsert';
             options = NGSIUtils.createRequestObject(url, typeInformation, token);
-            options.json = payload.entities[0];
+            delete payload.actionType;
+
+            let entityAttrs = payload.entities[0];
+            const transformedObject = {};
+            for (let attrname in entityAttrs) {
+                let attr = entityAttrs[attrname];
+                transformedObject[attrname] = {
+                    type: attr.type,
+                    value: attr.value,
+                    metadata: attr.metadata
+                };
+            }
+            transformedObject.id = entityAttrs.id;
+            transformedObject.type = entityAttrs.type;
+            options.json = transformedObject;
             options.method = 'POST';
         } // else: keep current options object created for a batch update
-        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));
+
+        //Send the NGSI request
+        logger.debug(context, 
+            'Updating device value in the Context Broker at: %j', 
+            options.url
+        );
+        logger.debug(context, 
+            'Using the following NGSI v2 request: %j', 
+            options
+        );
+        
         request(
             options,
             generateNGSI2OperationHandler('update', entityName, typeInformation, token, options, callback)
@@ -1006,19 +623,19 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
     } else {
         logger.debug(
             context,
-            'Not updating device value in the Context Broker at [%s] due to empty payload \n\n[%s]\n\n',
+            'Not updating device value in the Context Broker at: %j, due to empty payload: %j',
             options.url,
-            JSON.stringify(options, null, 4)
+            options
         );
         callback(null);
     }
 }
 
 exports.sendQueryValue = sendQueryValueNgsi2;
-exports.sendUpdateValue = function (entityName, attributes, typeInformation, token, callback) {
-    NGSIUtils.applyMiddlewares(NGSIUtils.updateMiddleware, attributes, typeInformation, () => {
-        return sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, callback);
+exports.sendUpdateValue = function (entityName, measures, typeInformation, token, callback) {
+    NGSIUtils.applyMiddlewares(NGSIUtils.updateMiddleware, measures, typeInformation, () => {
+        return sendUpdateValueNgsi2(entityName, measures, typeInformation, token, callback);
     });
 };
-exports.addTimestamp = addTimestampNgsi2;
+
 exports.formatGeoAttrs = formatGeoAttrs;