iotagent-node-lib 4.3.0 → 4.5.0

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

@@ -260,7 +260,7 @@ function sendQueryValueNgsi2(entityName, attributes, typeInformation, token, cal
  * @param {Object} typeInformation  Configuration information for the device.
  * @param {String} token            User token to identify against the PEP Proxies (optional).
  */
-function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, callback) {
+function sendUpdateValueNgsi2(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 = {}) {
@@ -273,315 +273,354 @@ function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, call
             return initObj;
         }
     }
-
-    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);
-
     //Make a clone and overwrite
-    typeInformation = JSON.parse(JSON.stringify(typeInformation));
+    let idTypeSSSList = pluginUtils.getIdTypeServSubServiceFromDevice(originTypeInformation);
 
     //Check mandatory information: type
-    if (!typeInformation || !typeInformation.type) {
-        callback(new errors.TypeNotFound(null, entityName, typeInformation));
+    if (!originTypeInformation || !originTypeInformation.type) {
+        callback(new errors.TypeNotFound(null, entityName, originTypeInformation));
         return;
     }
-    //Rename all measures with matches with id and type to measure_id and measure_type
-    for (let 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);
+    let payload = {}; //will store the final payload
+    let entities = {};
+    payload.actionType = 'append';
+    payload.entities = [];
 
+    const currentIsoDate = new Date().toISOString();
+    const currentMoment = moment(currentIsoDate);
     //Managing timestamp (mustInsertTimeInstant flag to decide if we should insert Timestamp later on)
-    const mustInsertTimeInstant = 
-        typeInformation.timestamp !== undefined 
-            ? typeInformation.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.BadTimestamp(plainMeasures[constants.TIMESTAMP_ATTRIBUTE], entityName, typeInformation)
-                );
-                return;
-            }
-        } 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 called with: entityName=%s,  measures=%j,  typeInformation=%j, initial jexlContext=%j, timestamp=%j with value=%j',
-        entityName,
-        plainMeasures,
-        typeInformation,
-        jexlctxt,
-        mustInsertTimeInstant,
-        timestamp.value
-    );
+    const mustInsertTimeInstant =
+        originTypeInformation.timestamp !== undefined ? originTypeInformation.timestamp : false;
 
-    //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
-            );
-        }
+    // Check if measures is a single measure or a array of measures (a multimeasure)
+    if (originMeasures[0] && !originMeasures[0][0]) {
+        originMeasures = [originMeasures];
     }
+    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)
+
+        let plainMeasures = null; //will contain measures POJO
+        //Make a clone and overwrite
+        let typeInformation = JSON.parse(JSON.stringify(originTypeInformation));
+
+        //Rename all measures with matches with id and type to measure_id and measure_type
+        for (let measure of measures) {
+            if (measure.name === 'id' || measure.name === 'type') {
+                measure.name = constants.MEASURE + measure.name;
+            }
+        }
 
-    entityName = entityNameCalc ? entityNameCalc : entityName;
-    //enrich JEXL context
-    jexlctxt['entity_name'] = entityName;
+        //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);
 
-    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);
-    }
+        logger.debug(
+            context,
+            'sendUpdateValueNgsi2 loop with: entityName=%s,  measures=%j,  typeInformation=%j, initial jexlContext=%j, timestamp=%j',
+            entityName,
+            plainMeasures,
+            typeInformation,
+            jexlctxt,
+            mustInsertTimeInstant
+        );
 
-    //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'
-        ) {
+        //Now we can calculate the EntityName of primary entity
+        let entityNameCalc = null;
+        if (typeInformation.entityNameExp !== undefined && typeInformation.entityNameExp !== '') {
             try {
-                logger.debug(
-                    context,
-                    'Evaluating attribute: %j, for entity_name(exp):%j, with ctxt: %j',
-                    currentAttr.name,
-                    currentAttr.entity_name,
-                    jexlctxt
+                logger.debug(context, 'sendUpdateValueNgsi2 entityNameExp %j', typeInformation.entityNameExp);
+                entityNameCalc = expressionPlugin.applyExpression(
+                    typeInformation.entityNameExp,
+                    jexlctxt,
+                    typeInformation
                 );
-                attrEntityName = jexlParser.applyExpression(currentAttr.entity_name, jexlctxt, typeInformation);
-                if (!attrEntityName) {
-                    attrEntityName = currentAttr.entity_name;
-                }
             } catch (e) {
                 logger.debug(
                     context,
-                    'Exception evaluating entityNameExp:%j, with jexlctxt: %j',
-                    currentAttr.entity_name,
+                    'Error evaluating expression for entityName: %j with context: %j',
+                    typeInformation.entityNameExp,
                     jexlctxt
                 );
-                attrEntityName = currentAttr.entity_name;
             }
         }
 
-        //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;
-        }
+        entityName = entityNameCalc ? entityNameCalc : entityName;
+        //enrich JEXL context
+        jexlctxt['entity_name'] = entityName;
 
-        //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];
+        let preprocessedAttr = [];
+        //Add Raw Static, Lazy, Command and Actives attr attributes
+        if (typeInformation && typeInformation.staticAttributes) {
+            preprocessedAttr = preprocessedAttr.concat(typeInformation.staticAttributes);
         }
-        //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
-            );
+        if (typeInformation && typeInformation.lazy) {
+            preprocessedAttr = preprocessedAttr.concat(typeInformation.lazy);
+        }
+        if (typeInformation && typeInformation.active) {
+            preprocessedAttr = preprocessedAttr.concat(typeInformation.active);
         }
 
-        currentAttr.hitted = hitted;
-        currentAttr.value = valueExpression;
+        //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,
+                        '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,
+                        'Exception evaluating entityNameExp:%j, with jexlctxt: %j',
+                        currentAttr.entity_name,
+                        jexlctxt
+                    );
+                    attrEntityName = currentAttr.entity_name;
+                }
+            }
 
-        //add TimeInstant to attr metadata
-        if (mustInsertTimeInstant) {
-            if (!currentAttr.metadata) {
-                currentAttr.metadata = {};
+            //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;
             }
-            currentAttr.metadata[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
-        }
 
-        //store de New Attributte in entity data structure
-        if (hitted === true) {
-            if (entities[attrEntityName] === undefined) {
-                entities[attrEntityName] = {};
+            //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];
             }
-            if (entities[attrEntityName][attrEntityType] === undefined) {
-                entities[attrEntityName][attrEntityType] = [];
+            //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
+                );
             }
-            //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;
-    }
+            currentAttr.hitted = hitted;
+            currentAttr.value = valueExpression;
 
-    //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 && mustInsertTimeInstant) {
-                explicit.push(constants.TIMESTAMP_ATTRIBUTE);
+            //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);
             }
-            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) {
-        //add Timestamp to measures if needed
-        if (mustInsertTimeInstant) {
-            for (let currentMeasure of measures) {
-                if (!currentMeasure.metadata) {
-                    currentMeasure.metadata = {};
+            //RE-Populate de JEXLcontext (except for null or NaN we preffer undefined)
+            jexlctxt[currentAttr.name] = valueExpression;
+
+            // Expand metadata value expression
+            if (currentAttr.metadata) {
+                for (var metaKey in currentAttr.metadata) {
+                    if (currentAttr.metadata[metaKey].expression && metaKey !== constants.TIMESTAMP_ATTRIBUTE) {
+                        let newAttrMeta = {};
+                        if (currentAttr.metadata[metaKey].type) {
+                            newAttrMeta['type'] = currentAttr.metadata[metaKey].type;
+                        }
+                        let metaValueExpression;
+                        try {
+                            metaValueExpression = jexlParser.applyExpression(
+                                currentAttr.metadata[metaKey].expression,
+                                jexlctxt,
+                                typeInformation
+                            );
+                            //we fallback to null if anything unexpecte happend
+                            if (
+                                metaValueExpression === null ||
+                                metaValueExpression === undefined ||
+                                Number.isNaN(metaValueExpression)
+                            ) {
+                                metaValueExpression = null;
+                            }
+                        } catch (e) {
+                            metaValueExpression = null;
+                        }
+                        newAttrMeta['value'] = metaValueExpression;
+                        currentAttr.metadata[metaKey] = newAttrMeta;
+                    }
                 }
-                currentMeasure.metadata[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
             }
-            //If just measures in the principal entity we missed the Timestamp.
         }
-        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)
-    payload.actionType = 'append';
 
-    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]) {
-                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;
-                    e[attr.name] = { type: attr.type, value: attr.value, metadata: attr.metadata };
+        //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);
                 }
+                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
             }
-            if (!isEmpty) {
+        } 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 (let ename in entities) {
+            for (let etype in entities[ename]) {
+                let e = {};
+                e.id = String(ename);
+                e.type = String(etype);
+                let timestamp = { type: constants.TIMESTAMP_TYPE_NGSI2 }; //timestamp scafold-attr for insertions.
+                let timestampAttrs = null;
                 if (mustInsertTimeInstant) {
-                    e[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
+                    // 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 (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;
+                        }
+                    }
+                }
+                //extract attributes
+                let isEmpty = true;
+                for (let 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 (!isEmpty) {
+                    if (mustInsertTimeInstant) {
+                        e[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
+                    }
+                    payload.entities.push(e);
                 }
-                payload.entities.push(e);
             }
         }
-    }
+    } // end for (let measures of originMeasures)
 
     let url = '/v2/op/update';
-    let options = NGSIUtils.createRequestObject(url, typeInformation, token);
+    let options = NGSIUtils.createRequestObject(url, originTypeInformation, token);
     options.json = payload;
 
     // Prevent to update an entity with an empty payload: more than id and type
@@ -596,13 +635,17 @@ function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, call
         // Note that the options object is prepared for the second case (multi entity), so we "patch" it
         // only in the first case
 
-        //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;
+        //Multi: multientity (more than one name o more than one type at primary entity)
+        //  of multimeasure (originMeasures is an array of more than one element)
+        let multi =
+            Object.keys(entities).length > 1 ||
+            Object.keys(entities[entityName]).length > 1 ||
+            originMeasures.length > 1;
 
-        if (!multientity) {
+        if (!multi) {
             // recreate options object to use single entity update
             url = '/v2/entities?options=upsert';
-            options = NGSIUtils.createRequestObject(url, typeInformation, token);
+            options = NGSIUtils.createRequestObject(url, originTypeInformation, token);
             delete payload.actionType;
 
             let entityAttrs = payload.entities[0];
@@ -619,7 +662,20 @@ function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, call
             transformedObject.type = entityAttrs.type;
             options.json = transformedObject;
             options.method = 'POST';
-        } // else: keep current options object created for a batch update
+        } else if (payload.entities.every((entity) => 'TimeInstant' in entity)) {
+            // Try sort entities by TimeInstant
+            payload.entities.sort(
+                (a, b) => new Date(a.TimeInstant.value).getTime() - new Date(b.TimeInstant.value).getTime()
+            );
+            options.json = payload;
+        } else {
+            // keep current options object created for a batch update
+            logger.debug(
+                context,
+                "some entities lack the 'TimeInstant' key. Sorting is not feasible: %j ",
+                payload.entities
+            );
+        }
 
         //Send the NGSI request
         logger.debug(context, 'Updating device value in the Context Broker at: %j', options.url);
@@ -627,7 +683,7 @@ function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, call
 
         request(
             options,
-            generateNGSI2OperationHandler('update', entityName, typeInformation, token, options, callback)
+            generateNGSI2OperationHandler('update', entityName, originTypeInformation, token, options, callback)
         );
     } else {
         logger.debug(