iotagent-node-lib 3.1.0 → 3.3.0

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

@@ -111,12 +111,10 @@ function addTimestampNgsi2(payload, timezone, timestampValue) {
 
         if (timestampValue) {
             timestamp.value = timestampValue;
+        } else if (!timezone) {
+            timestamp.value = new Date().toISOString();
         } else {
-            if (!timezone) {
-                timestamp.value = new Date().toISOString();
-            } else {
-                timestamp.value = moment().tz(timezone).format('YYYY-MM-DD[T]HH:mm:ss.SSSZ');
-            }
+            timestamp.value = moment().tz(timezone).format('YYYY-MM-DD[T]HH:mm:ss.SSSZ');
         }
 
         function addMetadata(attribute) {
@@ -325,16 +323,6 @@ function sendQueryValueNgsi2(entityName, attributes, typeInformation, token, cal
     );
 }
 
-/**
- * Determines if a value is of type float
- *
- * @param      {String}   value       Value to be analyzed
- * @return     {boolean}              True if float, False otherwise.
- */
-function isFloat(value) {
-    return !isNaN(value) && value.toString().indexOf('.') !== -1;
-}
-
 /**
  * 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.
@@ -347,12 +335,12 @@ function isFloat(value) {
 function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, callback) {
     logger.debug(
         context,
-        'sendUpdateValueNgsi2 called with: \n entityName=%s \n attributes=%j \n typeInformation=%j',
+        'sendUpdateValueNgsi2 called with: entityName=%s  attributes=%j  typeInformation=%j',
         entityName,
         attributes,
         typeInformation
     );
-    let payload = {
+    const payload = {
         entities: [
             {
                 id: entityName
@@ -366,10 +354,10 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
         payload.entities[0].type = typeInformation.type;
     }
 
-    if (config.getConfig().appendMode === true) {
-        payload.actionType = 'append';
-    } else {
+    if (config.getConfig().appendMode === false) {
         payload.actionType = 'update';
+    } else {
+        payload.actionType = 'append';
     }
 
     let options = NGSIUtils.createRequestObject(url, typeInformation, token);
@@ -382,8 +370,9 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
         callback(new errors.TypeNotFound(null, entityName));
         return;
     }
+
     let idTypeSSSList = pluginUtils.getIdTypeServSubServiceFromDevice(typeInformation);
-    logger.debug(context, 'sendUpdateValueNgsi2 \n idTypeSSS are %j ', idTypeSSSList);
+    logger.debug(context, 'sendUpdateValueNgsi2 idTypeSSS are %j ', idTypeSSSList);
     let measureAttrsForCtxt = [];
 
     // Check explicitAttrs: adds all final needed attributes to payload
@@ -408,7 +397,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                 return;
             }
         }
-        logger.debug(context, 'sendUpdateValueNgsi2 \n pre-initial non-explicitAttrs payload=%j', payload);
+        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) => {
@@ -435,7 +424,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
         if (typeof typeInformation.explicitAttrs === 'string') {
             // explicitAttrs is a jexlExpression
             // This ctxt should include all possible attrs
-            let attributesCtxt = [];
+            const attributesCtxt = [];
             if (typeInformation.static) {
                 typeInformation.static.forEach(function (att) {
                     attributesCtxt.push(att);
@@ -444,37 +433,57 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
             // Measures
             for (let i = 0; i < attributes.length; i++) {
                 if (attributes[i].name && attributes[i].type) {
-                    let measureAttr = {
+                    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);
-            // typeInformation.active attrs with expressions expanded by current ctxt
+
+            let ctxt = expressionPlugin.extractContext(attributesCtxt.concat(idTypeSSSList));
+            // typeInformation.active all attrs with expressions
             if (typeInformation.active) {
                 typeInformation.active.forEach(function (att) {
-                    if (att.expression) {
-                        if (expressionPlugin.contextAvailable(att.expression, ctxt, typeInformation)) {
-                            let expandedAttr = {
-                                name: att.name,
-                                value: att.expression, // it doesn't matter final value here
+                    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(expandedAttr);
-                            ctxt = expressionPlugin.extractContext(
-                                attributesCtxt.concat(idTypeSSSList),
-                                typeInformation
-                            );
+                            attributesCtxt.push(expandedAttrByObjectId);
                         }
+                        ctxt = expressionPlugin.extractContext(attributesCtxt.concat(idTypeSSSList));
                     }
                 });
             }
             // calculate expression for explicitAttrs
             try {
+                logger.debug(context, 'sendUpdateValueNgsi2 selectedAttrs ctxt %j', ctxt);
                 let res = jexlParser.applyExpression(typeInformation.explicitAttrs, ctxt, typeInformation);
                 if (res === true) {
                     // like explicitAttrs == true
@@ -500,7 +509,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                     // implies do nothing
                     logger.info(
                         context,
-                        'sendUpdateValueNgsi2 \n none selectedAttrs with %j and ctxt %j',
+                        'sendUpdateValueNgsi2 none selectedAttrs with %j and ctxt %j',
                         typeInformation.explicitAttrs,
                         ctxt
                     );
@@ -514,19 +523,42 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                 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') {
-            // TBD: selectedAttrs could be a boolean as a result of applyExpression
-            // explicitAtts is true => Add measures which are defined attributes
+            // 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) => {
-                selectedAttrs.push(attr.name);
-                selectedAttrs.push(attr.object_id);
+                // 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) {
-                let attr = typeInformation.active.find((obj) => {
+                const attr = typeInformation.active.find((obj) => {
                     return obj.name === attributes[i].name;
                 });
                 payload.entities[0][attributes[i].name] = {
@@ -542,7 +574,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                     payload.entities[0][attributes[i].name].metadata = metadata;
                 }
             } else if (attributes[i].name && !selectedAttrs.includes(attributes[i].name) && attributes[i].type) {
-                let att = {
+                const att = {
                     name: attributes[i].name,
                     type: attributes[i].type,
                     value: attributes[i].value
@@ -552,10 +584,15 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
         }
         logger.debug(
             context,
-            'sendUpdateValueNgsi2 \n pre-initial explicitAttrs payload=%j \n selectedAttrs',
+            '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) {
@@ -577,13 +614,23 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                             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
+                    };
                 }
             });
         }
     } // END check explicitAttrs
-    logger.debug(context, 'sendUpdateValueNgsi2 \n initial payload=%j', payload);
+    logger.debug(context, 'sendUpdateValueNgsi2 initial payload=%j', payload);
 
-    let currentEntity = payload.entities[0];
+    const currentEntity = payload.entities[0];
 
     // Prepare attributes for expresionPlugin
     const attsArray = pluginUtils.extractAttributesArrayFromNgsi2Entity(currentEntity);
@@ -608,11 +655,11 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
     }
     attributesCtxt = attributesCtxt.concat(idTypeSSSList);
     let ctxt = expressionPlugin.extractContext(attributesCtxt, typeInformation);
-    logger.debug(context, 'sendUpdateValueNgsi2 \n initial ctxt %j ', ctxt);
+    logger.debug(context, 'sendUpdateValueNgsi2 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, 'sendUpdateValueNgsi2 \n currentEntity %j ', currentEntity);
+    logger.debug(context, 'sendUpdateValueNgsi2 currentEntity %j ', currentEntity);
     if (typeInformation.active && typeInformation.active.length > 0) {
         for (const k in currentEntity) {
             typeInformation.active.forEach(function (att) {
@@ -620,14 +667,32 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                     (att.object_id && att.object_id === k && att.expression) ||
                     (att.name && att.name === k && att.expression)
                 ) {
-                    let m = currentEntity[k];
+                    const m = currentEntity[k];
                     delete currentEntity[k];
                     currentEntity[k] = m; // put into the end of currentEntity
                 }
             });
         }
     }
-    logger.debug(context, 'sendUpdateValueNgsi2 \n currentEntity sorted %j ', currentEntity);
+
+    // Evaluate entityNameExp with a context including measures
+    if (typeInformation.entityNameExp !== undefined && typeInformation.entityNameExp !== '') {
+        try {
+            logger.debug(context, 'sendUpdateValueNgsi2 entityNameExp %j ', typeInformation.entityNameExp);
+            entityName = expressionPlugin.applyExpression(typeInformation.entityNameExp, ctxt, typeInformation);
+            payload.entities[0].id = entityName;
+            ctxt['entity_name'] = entityName;
+        } catch (e) {
+            logger.debug(
+                context,
+                'Error evaluating expression for entityName: %s with context: %s',
+                typeInformation.entityNameExp,
+                ctxt
+            );
+        }
+    }
+
+    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) {
@@ -660,7 +725,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                     // invalid mapping
                     logger.debug(
                         context,
-                        'sendUpdateValueNgsi2 \n invalid mapping for attr %j \n newAttr %j',
+                        'sendUpdateValueNgsi2 invalid mapping for attr=%j  newAttr=%j',
                         attr,
                         newAttr
                     );
@@ -668,12 +733,12 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                     attr = undefined; // stop processing attr
                     newAttr = undefined;
                 } else {
-                    ctxt[attr.name] = payload.entities[0][j]['value'];
+                    ctxt[attr.name] = payload.entities[0][j].value;
                 }
             }
             logger.debug(
                 context,
-                'sendUpdateValueNgsi2 \n procesing j %j attr %j ctxt %j \n newAttr %j ',
+                'sendUpdateValueNgsi2 procesing j=%j attr=%j ctxt=%j newAttr=%j ',
                 j,
                 attr,
                 ctxt,
@@ -687,7 +752,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
             if (attr && attr.expression) {
                 logger.debug(
                     context,
-                    'sendUpdateValueNgsi2 \n apply expression %j \n over ctxt %j \n and device %j',
+                    'sendUpdateValueNgsi2 apply expression=%j over ctxt=%j and device=%j',
                     attr.expression,
                     ctxt,
                     typeInformation
@@ -696,58 +761,43 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                 try {
                     if (expressionPlugin.contextAvailable(attr.expression, ctxt, typeInformation)) {
                         res = expressionPlugin.applyExpression(attr.expression, ctxt, typeInformation);
+                        if (
+                            // By default undefined is equivalent to null: should not progress
+                            (attr.skipValue === undefined && res === null) ||
+                            (attr.skipValue !== undefined && res === attr.skipValue)
+                        ) {
+                            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.warn(
+                        logger.info(
                             context,
-                            'sendUpdateValueNgsi2 \n no context available for apply expression %j \n',
+                            'sendUpdateValueNgsi2 no context available for apply expression=%j',
                             attr.expression
                         );
                         res = newAttr.value; // keep newAttr value
                     }
                 } catch (e) {
-                    logger.error(context, 'sendUpdateValueNgsi2 \n apply expression exception %j \n', e);
-                    if (!expressionPlugin.checkJexl(typeInformation)) {
-                        return callback(e); // just throw error with legacy parser for backward compatiblity
-                    } else {
-                        res = ctxt[attr.name]; // TBD: add reference to test
+                    logger.error(context, 'sendUpdateValueNgsi2 apply expression exception=%j', e);
+                    if (attr && attr.name) {
+                        res = ctxt[attr.name];
                     }
                 }
-                if (!expressionPlugin.checkJexl(typeInformation)) {
-                    // legacy expression plugin: Involves some legacy checks performed by applierExpression
-                    if (
-                        res &&
-                        res !== 'undefined' &&
-                        res !== 'null' &&
-                        (typeof res === 'string' || res instanceof String) &&
-                        !res.includes('NaN')
-                    ) {
-                        newAttr.value = res;
-                        if (newAttr.type === 'Number' && isFloat(newAttr.value)) {
-                            newAttr.value = Number.parseFloat(newAttr.value);
-                        } else if (newAttr.type === 'Number' && !Number.isNaN(Number.parseInt(newAttr.value))) {
-                            newAttr.value = Number.parseInt(newAttr.value);
-                        } else if (newAttr.type === 'Boolean') {
-                            newAttr.value = newAttr.value === 'true' || newAttr.value === '1';
-                        } else if (newAttr.type === 'None') {
-                            newAttr.value = null;
-                        }
-                    } else if (isNaN(res) || res === 'undefined' || res === 'null') {
-                        logger.debug(
-                            context,
-                            'sendUpdateValueNgsi2 \n apply expression result: isNaN || undefined || null'
-                        );
-                        if (res === 'null' && newAttr.type === 'None') {
-                            newAttr.value = null;
-                        } else {
-                            delete payload.entities[0][j]; // remove measure attr
-                            attr = undefined; // stop process attr
-                        }
-                    }
-                } else {
-                    // jexl expression plugin
-                    newAttr.value = res;
+                // jexl expression plugin
+                newAttr.value = res;
+
+                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;
                 }
-                logger.debug(context, 'sendUpdateValueNgsi2 \n apply expression result %j \n newAttr %j', res, newAttr);
             }
 
             // Apply Multientity: entity_type and entity_name in attributes are in typeInformation.active
@@ -759,21 +809,21 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                         if (expressionPlugin.contextAvailable(attr.entity_name, ctxt, typeInformation)) {
                             newEntityName = expressionPlugin.applyExpression(attr.entity_name, ctxt, typeInformation);
                         } else {
-                            logger.warn(
+                            logger.info(
                                 context,
-                                'sendUpdateValueNgsi2 \n MULTI no context available for apply expression %j \n',
+                                '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 \n MULTI apply expression exception %j \n', e);
+                        logger.error(context, 'sendUpdateValueNgsi2 MULTI apply expression exception=%j', e);
                         newEntityName = attr.entity_name;
                     }
                     logger.debug(
                         context,
-                        'sendUpdateValueNgsi2 \n MULTI apply expression %j \n result %j \n payload %j',
+                        'sendUpdateValueNgsi2 MULTI apply expression=%j result=%j payload=%j',
                         attr.entity_name,
                         newEntityName,
                         payload
@@ -785,7 +835,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                     type: attr.entity_type ? attr.entity_type : payload.entities[0].type
                 };
                 // Check if there is already a newEntity created
-                let alreadyEntity = payload.entities.find((entity) => {
+                const alreadyEntity = payload.entities.find((entity) => {
                     return entity.id === newEntity.id && entity.type === newEntity.type;
                 });
                 if (alreadyEntity) {
@@ -802,7 +852,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                             : timestampValue !== undefined
                     ) {
                         newEntity = addTimestampNgsi2(newEntity, typeInformation.timezone, timestampValue);
-                        logger.debug(context, 'sendUpdateValueNgsi2 \n timestamped newEntity=%j', newEntity);
+                        logger.debug(context, 'sendUpdateValueNgsi2 timestamped newEntity=%j', newEntity);
                     }
                     payload.entities.push(newEntity);
                 }
@@ -810,7 +860,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                     if (attr.name !== j) {
                         logger.debug(
                             context,
-                            'sendUpdateValueNgsi2 \n MULTI remove measure attr %j keep alias j %j from %j \n',
+                            'sendUpdateValueNgsi2 MULTI remove measure attr=%j keep alias j=%j from %j',
                             j,
                             attr,
                             payload
@@ -828,7 +878,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                     }
                 }
                 if (newAttr && newAttr.type === constants.TIMESTAMP_TYPE_NGSI2 && newAttr.value) {
-                    let extendedTime = compressTimestampPlugin.fromBasicToExtended(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
@@ -840,7 +890,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                         timestampValue = newAttr.value;
                         logger.debug(
                             context,
-                            'sendUpdateValueNgsi2 \n newAttr is TimeInstant and new payload=%j',
+                            'sendUpdateValueNgsi2 newAttr is TimeInstant and new payload=%j',
                             payload
                         );
                     }
@@ -852,7 +902,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
                     newAttr.metadata[constants.TIMESTAMP_ATTRIBUTE].type === constants.TIMESTAMP_TYPE_NGSI2 &&
                     newAttr.metadata[constants.TIMESTAMP_ATTRIBUTE].value
                 ) {
-                    let extendedTime = compressTimestampPlugin.fromBasicToExtended(
+                    const extendedTime = compressTimestampPlugin.fromBasicToExtended(
                         newAttr.metadata[constants.TIMESTAMP_ATTRIBUTE].value
                     );
                     if (extendedTime) {
@@ -865,7 +915,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
         // final attr loop
         logger.debug(
             context,
-            'sendUpdateValueNgsi2 \n after procesing attr %j \n current entity %j \n current payload=%j',
+            'sendUpdateValueNgsi2 after procesing attr=%j  current entity=%j  current payload=%j',
             j,
             currentEntity,
             payload
@@ -909,10 +959,10 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
             }
         }
     }
-    logger.debug(context, 'sendUpdateValueNgsi2 \n ending payload=%j', payload);
+    logger.debug(context, 'sendUpdateValueNgsi2 ending payload=%j', payload);
 
     for (let m = 0; m < payload.entities.length; m++) {
-        for (var key in payload.entities[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;
@@ -920,7 +970,7 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
         }
         payload.entities[m] = NGSIUtils.castJsonNativeAttributes(payload.entities[m]); // native types
     }
-    logger.debug(context, 'sendUpdateValueNgsi2 \n payload with native types and without object_id %j', payload);
+    logger.debug(context, 'sendUpdateValueNgsi2 payload with native types and without object_id=%j', payload);
 
     options.json = payload;
 
@@ -937,18 +987,24 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
         // only in the first case
         if (options.json.entities.length === 1) {
             // recreate options object to use single entity update
-            url = '/v2/entities/' + entityName + '/attrs';
-            if (typeInformation && typeInformation.type) {
-                url += '?type=' + typeInformation.type;
+            url = '/v2/entities';
+            if (config.getConfig().appendMode === false) {
+                url += '/' + entityName + '/attrs';
+                if (typeInformation && typeInformation.type) {
+                    url += '?type=' + typeInformation.type;
+                }
+            } else {
+                // appendMode === true
+                url += '?options=upsert';
             }
             options = NGSIUtils.createRequestObject(url, typeInformation, token);
             options.json = payload.entities[0];
-            delete options.json.id;
-            delete options.json.type;
-            if (config.getConfig().appendMode === true) {
-                options.method = 'POST';
-            } else {
+            if (config.getConfig().appendMode === false) {
                 options.method = 'PATCH';
+                delete options.json.id;
+                delete options.json.type;
+            } else {
+                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);
@@ -969,6 +1025,10 @@ function sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, ca
 }
 
 exports.sendQueryValue = sendQueryValueNgsi2;
-exports.sendUpdateValue = sendUpdateValueNgsi2;
+exports.sendUpdateValue = function (entityName, attributes, typeInformation, token, callback) {
+    NGSIUtils.applyMiddlewares(NGSIUtils.updateMiddleware, attributes, typeInformation, () => {
+        return sendUpdateValueNgsi2(entityName, attributes, typeInformation, token, callback);
+    });
+};
 exports.addTimestamp = addTimestampNgsi2;
 exports.formatGeoAttrs = formatGeoAttrs;

package/lib/services/northBound/deviceProvisioningServer.js

@@ -62,7 +62,6 @@ const provisioningAPITranslation = {
     static_attributes: 'staticAttributes',
     autoprovision: 'autoprovision',
     explicitAttrs: 'explicitAttrs',
-    expressionLanguage: 'expressionLanguage',
     ngsiVersion: 'ngsiVersion',
     entityNameExp: 'entityNameExp'
 };
@@ -142,7 +141,6 @@ function handleProvision(req, res, next) {
             internalId: null,
             autoprovision: body.autoprovision,
             explicitAttrs: body.explicitAttrs,
-            expressionLanguage: body.expressionLanguage,
             ngsiVersion: body.ngsiVersion
         });
     }
@@ -181,6 +179,7 @@ function attributeToProvisioningAPIFormat(attribute) {
         name: attribute.name,
         type: attribute.type,
         expression: attribute.expression,
+        skipValue: attribute.skipValue,
         reverse: attribute.reverse,
         entity_name: attribute.entity_name,
         entity_type: attribute.entity_type,
@@ -218,7 +217,6 @@ function toProvisioningAPIFormat(device) {
         internal_attributes: device.internalAttributes,
         protocol: device.protocol,
         autoprovision: device.autoprovision,
-        expressionLanguage: device.expressionLanguage,
         explicitAttrs: device.explicitAttrs,
         ngsiVersion: device.ngsiVersion
     };
@@ -352,20 +350,22 @@ function handleUpdateDevice(req, res, next) {
                     if (req.body.entity_name || req.body.entity_type) {
                         isTypeOrNameUpdated = true;
                     }
-                    async.waterfall([apply(applyUpdatingHandler, newDevice)], function handleUpdating(
-                        error,
-                        newDeviceUpdated
-                    ) {
-                        deviceService.updateRegister(newDeviceUpdated, isTypeOrNameUpdated, function handleDeviceUpdate(
-                            error
-                        ) {
-                            if (error) {
-                                next(error);
-                            } else {
-                                res.status(204).json({});
-                            }
-                        });
-                    });
+                    async.waterfall(
+                        [apply(applyUpdatingHandler, newDevice)],
+                        function handleUpdating(error, newDeviceUpdated) {
+                            deviceService.updateRegister(
+                                newDeviceUpdated,
+                                isTypeOrNameUpdated,
+                                function handleDeviceUpdate(error) {
+                                    if (error) {
+                                        next(error);
+                                    } else {
+                                        res.status(204).json({});
+                                    }
+                                }
+                            );
+                        }
+                    );
                 } else {
                     next(new errors.DeviceNotFound(req.params.deviceId));
                 }