iotagent-node-lib 4.3.0 → 4.4.0

package/doc/api.md

@@ -8,6 +8,7 @@
     -   [IoT Agent information model](#iot-agent-information-model)
         -   [Config groups](#config-groups)
         -   [Devices](#devices)
+        -   [Uniqueness of groups and devices](#uniqueness-of-groups-and-devices)
     -   [Special measures and attributes names](#special-measures-and-attributes-names)
     -   [Entity attributes](#entity-attributes)
     -   [Multientity support)](#multientity-support)
@@ -133,9 +134,9 @@ parameters. The specific parameters that can be configured for a given config gr
 ### Devices
 
 A device contains the information that connects a physical device to a particular entity in the Context Broker. Devices
-are identified by a `device_id`, and they are associated to an existing config group based in `apiKey` matching or
-`type` matching (in the case `apiKey` matching fails). For instance, let's consider a situation in which a config group
-has been provisioned with `type=X`/`apiKey=111` and no other config group has been provisioned.
+are identified by a `device_id`, and they are associated to an existing config group based in `apikey` matching. For
+instance, let's consider a situation in which a config group has been provisioned with `type=X`/`apikey=111` and no
+other config group has been provisioned.
 
 The IoT Agents offer a provisioning API where devices can be preregistered, so all the information about service and
 subservice mapping, security information and attribute configuration can be specified in a per device way instead of
@@ -143,7 +144,7 @@ relaying on the config group configuration. The specific parameters that can be
 described in the [Device datamodel](#device-datamodel) section.
 
 If devices are not pre-registered, they will be automatically created when a measure arrives to the IoT Agent - this
-process is known as autoprovisioning. The IoT Agent will create an empty device with the group `apiKey` and `type` - the
+process is known as autoprovisioning. The IoT Agent will create an empty device with the group `apikey` and `type` - the
 associated document created in database doesn't include config group parameters (in particular, `timestamp`,
 `explicitAttrs`, `active` or `attributes`, `static` and `lazy` attributes and commands). The IoT Agent will also create
 the entity in the Context Broker if it does not exist yet.
@@ -152,6 +153,13 @@ This behavior allows that autoprovisioned parameters can freely established modi
 creation using the provisioning API. However, note that if a device (autoprovisioned or not) doesn't have these
 parameters defined at device level in database, the parameters are inherit from config group parameters.
 
+### Uniqueness of groups and devices
+
+Group service uniqueness is defined by the combination of: service, subservice and apikey
+
+Device uniqueness is defined by the combination of: service, subservice, device_id and apikey. Note that several devices
+with the same device_id are allowed in the same service and subservice as long as their apikeys are different.
+
 ## Special measures and attributes names
 
 In case of arriving measures with name `id` or `type`, they are automatically transformed to `measure_id` and
@@ -306,6 +314,43 @@ e.g.:
    }
 ```
 
+Metadata could also has `expression` like attributes in order to expand it:
+
+e.g.:
+
+```json
+{
+     "entity_type": "Lamp",
+     "resource":    "/iot/d",
+     "protocol":    "PDI-IoTA-UltraLight",
+..etc
+     "commands": [
+        {"name": "on","type": "command"},
+        {"name": "off","type": "command"}
+     ],
+     "attributes": [
+        {"object_id": "s", "name": "state", "type":"Text"},
+        {"object_id": "l", "name": "luminosity", "type":"Integer",
+          "metadata":{
+              "unitCode":{"type": "Text", "value" :"CAL"}
+          }
+        }
+     ],
+     "static_attributes": [
+          {"name": "category", "type":"Text", "value": ["actuator","sensor"]},
+          {"name": "controlledProperty", "type": "Text", "value": ["light"],
+            "metadata":{
+              "includes":{"type": "Text",
+                          "value" :["state", "luminosity"],
+                          "expression": "level / 100"
+                         },
+              "alias":{"type": "Text", "value" :"lamp"}
+            }
+          },
+     ]
+   }
+```
+
 ### NGSI-LD data and metadata considerations
 
 When provisioning devices for an NGSI-LD Context Broker, `type` values should typically correspond to one of the
@@ -517,8 +562,8 @@ expression. In all cases the following data is available to all expressions:
 -   `subservice`: device subservice
 -   `staticAttributes`: static attributes defined in the device or config group
 
-Additionally, for attribute expressions (`expression`, `entity_name`) and `entityNameExp` measures are avaiable in the
-**context** used to evaluate them.
+Additionally, for attribute expressions (`expression`, `entity_name`), `entityNameExp` and metadata expressions
+(`expression`) measures are available in the **context** used to evaluate them.
 
 ### Examples of JEXL expressions
 
@@ -964,32 +1009,41 @@ Will now generate the following NGSI v2 payload:
 
 ## Timestamp Processing
 
-The IOTA processes the entity attributes looking for a `TimeInstant` attribute. If one is found, for NGSI v2, then it
-adds a `TimeInstant` attribute as metadata for every other attribute in the same request. With NGSI-LD, the Standard
-`observedAt` property-of-a-property is used instead.
+Timestamp processing done by IOTA is as follows:
 
-If a `TimeInstant` arrives as measure but not follows [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) then measure is
-refused.
+-   An attribute `TimeInstant` is added to updated entities
+-   In the case of NGSI-v2, a `TimeInstant` metadata is added in each updated attribute. With NGSI-LD, the Standard
+    `observedAt` property-of-a-property is used instead.
 
 Depending on the `timestamp` configuration and if the measure contains a value named `TimeInstant` with a correct value,
 the IoTA behaviour is described in the following table:
 
-| `timestamp` value | measure contains `TimeInstant` | Behaviour                                              |
-| ----------------- | ------------------------------ | ------------------------------------------------------ |
-| true              | Yes                            | TimeInstant and metadata updated with measure value    |
-| true              | No                             | TimeInstant and metadata updated with server timestamp |
-| false             | Yes                            | TimeInstant and metadata updated with measure value    |
-| false             | No                             | TimeInstant and metadata updated with server timestamp |
-| Not defined       | Yes                            | TimeInstant and metadata updated with measure value    |
-| Not defined       | No                             | TimeInstant and metadata updated with server timestamp |
+| `timestamp` conf value | measure contains `TimeInstant` | Behaviour                                              |
+| ---------------------- | ------------------------------ | ------------------------------------------------------ |
+| true                   | Yes                            | TimeInstant and metadata updated with measure value    |
+| true                   | No                             | TimeInstant and metadata updated with server timestamp |
+| false                  | Yes                            | TimeInstant and metadata updated with measure value    |
+| false                  | No                             | TimeInstant and metadata updated with server timestamp |
+| Not defined            | Yes                            | TimeInstant and metadata updated with measure value    |
+| Not defined            | No                             | TimeInstant and metadata updated with server timestamp |
 
-The `timestamp` value used is:
+The `timestamp` conf value used is:
 
 -   The one defined at device level
 -   The one defined at group level (if not defined at device level)
 -   The one defined at [IoTA configuration level](admin.md#timestamp) / `IOTA_TIMESTAMP` env var (if not defined at
     group level or device level)
 
+Some additional considerations to take into account:
+
+-   If there is an attribute which maps a measure to `TimeInstant` attribute (after
+    [expression evaluation](#expression-language-support) if any is defined), then that value will be used as
+    `TimeInstant, overwriting the above rules specified in "Behaviour" column. Note that an expression in the could be
+    used in that mapping.
+-   If the resulting `TimeInstant` not follows [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) (either from a direct
+    measure of after a mapping, as described in the previous bullet) then it is refused (so a failover to server
+    timestamp will take place).
+
 ## Overriding global Context Broker host
 
 **cbHost**: Context Broker host URL. This option can be used to override the global CB configuration for specific types

package/docker/Mosquitto/Dockerfile

@@ -1,4 +1,4 @@
-ARG  IMAGE_TAG=12.4-slim
+ARG  IMAGE_TAG=12.5-slim
 FROM debian:${IMAGE_TAG}
 
 ARG CLEAN_DEV_TOOLS

package/lib/commonConfig.js

@@ -485,6 +485,23 @@ function getConfig() {
     return config;
 }
 
+function getConfigForTypeInformation() {
+    // Just return relevant configuration flags
+    // avoid to include server, authentication, mongodb, orion and iotamanger info
+    let conf = {
+        timestamp: config.timestamp,
+        defaultResource: config.defaultResource,
+        explicitAttrs: config.explicitAttrs,
+        pollingExpiration: config.pollingExpiration,
+        pollingDaemonFrequency: config.pollingDaemonFrequency,
+        multiCore: config.multiCore,
+        relaxTemplateValidation: config.relaxTemplateValidation,
+        defaultEntityNameConjunction: config.defaultEntityNameConjunction,
+        defaultType: config.defaultType
+    };
+    return conf;
+}
+
 function setRegistry(newRegistry) {
     registry = newRegistry;
 }
@@ -541,6 +558,7 @@ function getSecurityService() {
 
 exports.setConfig = setConfig;
 exports.getConfig = getConfig;
+exports.getConfigForTypeInformation = getConfigForTypeInformation;
 exports.setRegistry = setRegistry;
 exports.getRegistry = getRegistry;
 exports.setGroupRegistry = setGroupRegistry;

package/lib/errors.js

@@ -107,7 +107,10 @@ class DuplicateDeviceId {
     constructor(device) {
         this.name = 'DUPLICATE_DEVICE_ID';
         this.message =
-            'A device with the same pair (Service, DeviceId) was found:' + device.id + ' and ' + JSON.stringify(device);
+            'A device with the same info (DeviceId, ApiKey, Service, Subservice) was found:' +
+            device.id +
+            ' and ' +
+            JSON.stringify(device);
         this.code = 409;
     }
 }

package/lib/services/devices/deviceRegistryMongoDB.js

@@ -243,14 +243,7 @@ function getDeviceById(id, apikey, service, subservice, callback) {
 function getDevice(id, apikey, service, subservice, callback) {
     getDeviceById(id, apikey, service, subservice, function (error, data) {
         if (error) {
-            // Try without apikey: apikey will be added to device later
-            getDeviceById(id, null, service, subservice, function (error, data) {
-                if (error) {
-                    callback(error);
-                } else {
-                    callback(null, data);
-                }
-            });
+            callback(error);
         } else {
             callback(null, data);
         }

package/lib/services/devices/deviceService.js

@@ -615,6 +615,7 @@ function findOrCreate(deviceId, apikey, group, callback) {
         } else if (error.name === 'DEVICE_NOT_FOUND') {
             const newDevice = {
                 id: deviceId,
+                apikey: apikey,
                 service: group.service,
                 subservice: group.subservice,
                 type: group.type

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

@@ -277,7 +277,6 @@ function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, call
     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);
 
@@ -308,43 +307,16 @@ function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, call
     jexlctxt = reduceAttrToPlainObject(idTypeSSSList, jexlctxt);
 
     //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;
-        }
-    }
+    const mustInsertTimeInstant = typeInformation.timestamp !== undefined ? typeInformation.timestamp : false;
 
     logger.debug(
         context,
-        'sendUpdateValueNgsi2 called with: entityName=%s,  measures=%j,  typeInformation=%j, initial jexlContext=%j, timestamp=%j with value=%j',
+        'sendUpdateValueNgsi2 called with: entityName=%s,  measures=%j,  typeInformation=%j, initial jexlContext=%j, timestamp=%j',
         entityName,
         plainMeasures,
         typeInformation,
         jexlctxt,
-        mustInsertTimeInstant,
-        timestamp.value
+        mustInsertTimeInstant
     );
 
     //Now we can calculate the EntityName of primary entity
@@ -479,14 +451,6 @@ function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, call
         currentAttr.hitted = hitted;
         currentAttr.value = valueExpression;
 
-        //add TimeInstant to attr metadata
-        if (mustInsertTimeInstant) {
-            if (!currentAttr.metadata) {
-                currentAttr.metadata = {};
-            }
-            currentAttr.metadata[constants.TIMESTAMP_ATTRIBUTE] = timestamp;
-        }
-
         //store de New Attributte in entity data structure
         if (hitted === true) {
             if (entities[attrEntityName] === undefined) {
@@ -501,6 +465,38 @@ function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, call
 
         //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;
+                }
+            }
+        }
     }
 
     //now we can compute explicit (Bool or Array) with the complete JexlContext
@@ -527,16 +523,6 @@ function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, call
 
     //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;
-            }
-            //If just measures in the principal entity we missed the Timestamp.
-        }
         entities[entityName][typeInformation.type] = entities[entityName][typeInformation.type].concat(measures);
     }
 
@@ -547,11 +533,40 @@ function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, call
     payload.actionType = 'append';
 
     payload.entities = [];
+    const currentIsoDate = new Date().toISOString();
+    const currentMoment = moment(currentIsoDate);
     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) {
+                // 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]) {
@@ -568,6 +583,15 @@ function sendUpdateValueNgsi2(entityName, measures, typeInformation, token, call
                                 ))))
                 ) {
                     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 };
                 }
             }

package/lib/services/ngsi/ngsiService.js

@@ -144,9 +144,9 @@ function executeWithDeviceInformation(operationFunction) {
             // For preregistered devices, augment the existing deviceInformation with selected attributes.
             if (!callback) {
                 callback = deviceInformation;
-                typeInformation = deviceGroup || { ...config.getConfig(), ...configDeviceInfo };
+                typeInformation = deviceGroup || { ...config.getConfigForTypeInformation(), ...configDeviceInfo };
             } else {
-                typeInformation = { ...config.getConfig(), ...deviceInformation };
+                typeInformation = { ...config.getConfigForTypeInformation(), ...deviceInformation };
                 attributeList.forEach((key) => {
                     typeInformation[key] =
                         typeInformation[key] || (deviceGroup || {})[key] || (configDeviceInfo || {})[key];

package/package.json

@@ -2,7 +2,7 @@
   "name": "iotagent-node-lib",
   "license": "AGPL-3.0-only",
   "description": "IoT Agent library to interface with NGSI Context Broker",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "homepage": "https://github.com/telefonicaid/iotagent-node-lib",
   "keywords": [
     "fiware",
@@ -45,7 +45,7 @@
   "dependencies": {
     "async": "2.6.4",
     "body-parser": "~1.20.0",
-    "express": "~4.18.1",
+    "express": "~4.19.2",
     "got": "~11.8.5",
     "jexl": "2.3.0",
     "jison": "0.4.18",

package/scripts/legacy_expression_tool/requirements.txt

@@ -1,3 +1,3 @@
 matplotlib==3.7.1
 pandas==2.0.2
-pymongo==4.3.3
+pymongo==4.6.3

package/test/functional/testCases.js

@@ -445,6 +445,74 @@ const testCases = [
             }
         ]
     },
+    {
+        describeName: '0021   Simple group with active attributes with metadata',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Boolean',
+                                metadata: {
+                                    accuracy: {
+                                        value: 0.8,
+                                        type: 'Float'
+                                    }
+                                }
+                            }
+                        ],
+                        static_attributes: []
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending defined object_ids (measures) through http IT should send measures to Context Broker preserving value types, name mappings and metadatas',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: false
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: false,
+                        type: 'Boolean',
+                        metadata: {
+                            accuracy: {
+                                value: 0.8,
+                                type: 'Float'
+                            }
+                        }
+                    }
+                }
+            }
+        ]
+    },
     // 0100 - JEXL TESTS
     {
         describeName: '0100 - Simple group with active attribute + JEXL expression boolean (!)',
@@ -1036,7 +1104,8 @@ const testCases = [
         ]
     },
     {
-        describeName: '0140 - Simple group with active attribute + chained JEXL expression text (a|substr(0,2))',
+        describeName:
+            '0140 - Simple group with active attribute + chained JEXL expression text (a | trim | replacestr("hello","hi"))',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -1476,6 +1545,75 @@ const testCases = [
             }
         ]
     },
+    {
+        describeName: '0191 - Simple group with JEXL expression in metadata',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Boolean',
+                                expression: 'a?threshold[90|tostring].max:true',
+                                metadata: {
+                                    unit: {
+                                        type: 'Text',
+                                        expression: '"hola" + "adios"'
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a measure  through http IT should send to Context Broker expanded metadata value  ',
+                type: 'single',
+                isRegex: true,
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: false
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: true,
+                        type: 'Boolean',
+                        metadata: {
+                            unit: {
+                                type: 'Text',
+                                value: 'holaadios'
+                            }
+                        }
+                    }
+                }
+            }
+        ]
+    },
     // 0200 - COMMANDS TESTS
     {
         describeName: '0200 - Simple group with commands',
@@ -1704,6 +1842,78 @@ const testCases = [
             }
         ]
     },
+    {
+        describeName: '0320 - Simple group with active attributes + metadata in Static attributes ',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [],
+                        static_attributes: [
+                            {
+                                name: 'static_a',
+                                type: 'Number',
+                                value: 4,
+                                metadata: {
+                                    accuracy: {
+                                        value: 0.8,
+                                        type: 'Float'
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending measures through http IT should store metatada static attributes into Context Broker',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 10
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    a: {
+                        value: 10,
+                        type: 'Text'
+                    },
+                    static_a: {
+                        value: 4,
+                        type: 'Number',
+                        metadata: {
+                            accuracy: {
+                                value: 0.8,
+                                type: 'Float'
+                            }
+                        }
+                    }
+                }
+            }
+        ]
+    },
     // 0400 - TIMESTAMP TESTS
     {
         describeName: '0400 - Simple group with active attribute + timestamp:false',
@@ -1976,6 +2186,527 @@ const testCases = [
             }
         ]
     },
+    {
+        describeName: '0430 - Simple group with active attribute + timestamp mapping defined',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        timestamp: true,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'mydatetime',
+                                name: 'TimeInstant',
+                                type: 'DateTime'
+                            }
+                        ]
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a measure through http IT should map the measure to timestamp attribute and use it for timestmap and other metadata attributes sent to Context Broker',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        mydatetime: '2022-02-02T02:22:22.222Z',
+                        a: 23
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: '2022-02-02T02:22:22.222Z',
+                                type: 'DateTime'
+                            }
+                        }
+                    },
+                    TimeInstant: {
+                        value: '2022-02-02T02:22:22.222Z',
+                        type: 'DateTime'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'A - WHEN sending a measure without timestamp through http IT should use system timestamp for mapped attribute and use it for timestmap and other metadata attributes sent to Context Broker',
+                type: 'single',
+                isRegex: true,
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 23
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: _.isDateString,
+                                type: 'DateTime'
+                            }
+                        }
+                    },
+                    TimeInstant: {
+                        value: _.isDateString,
+                        type: 'DateTime'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'A - WHEN sending a measure with timestamp through http IT should map the measure to timestamp attribute and use it for timestmap and other metadata attributes sent to Context Broker',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        mydatetime: '2022-02-02T02:22:22.222Z',
+                        TimeInstant: '2033-03-03T03:33:33.333Z',
+                        a: 23
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: '2022-02-02T02:22:22.222Z',
+                                type: 'DateTime'
+                            }
+                        }
+                    },
+                    TimeInstant: {
+                        value: '2022-02-02T02:22:22.222Z',
+                        type: 'DateTime'
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName: '0431 - Simple group with active attribute + timestamp mapping defined + explicitAttrs',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        timestamp: true,
+                        explicitAttrs: true,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'mydatetime',
+                                name: 'TimeInstant',
+                                type: 'DateTime'
+                            },
+                            {
+                                object_id: 'a',
+                                name: 'a',
+                                type: 'Text'
+                            }
+                        ]
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a measure through http IT should map the measure to timestamp attribute and use it for timestmap and other metadata attributes sent to Context Broker',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        mydatetime: '2022-02-02T02:22:22.222Z',
+                        a: 23
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: '2022-02-02T02:22:22.222Z',
+                                type: 'DateTime'
+                            }
+                        }
+                    },
+                    TimeInstant: {
+                        value: '2022-02-02T02:22:22.222Z',
+                        type: 'DateTime'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'A - WHEN sending a measure without timestamp through http IT should use system timestamp for mapped attribute and use it for timestmap and other metadata attributes sent to Context Broker',
+                type: 'single',
+                isRegex: true,
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 23
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: _.isDateString,
+                                type: 'DateTime'
+                            }
+                        }
+                    },
+                    TimeInstant: {
+                        value: _.isDateString,
+                        type: 'DateTime'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'A - WHEN sending a measure with timestamp through http IT should map the measure to timestamp attribute and use it for timestmap and other metadata attributes sent to Context Broker',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        mydatetime: '2022-02-02T02:22:22.222Z',
+                        TimeInstant: '2033-03-03T03:33:33.333Z',
+                        a: 23
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: '2022-02-02T02:22:22.222Z',
+                                type: 'DateTime'
+                            }
+                        }
+                    },
+                    TimeInstant: {
+                        value: '2022-02-02T02:22:22.222Z',
+                        type: 'DateTime'
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName: '0432 - Simple group with active attribute + bad timestamp mapping defined',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        timestamp: true,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'mydatetime',
+                                name: 'TimeInstant',
+                                type: 'DateTime',
+                                expression: '"2033-03-03T" + "03:33:33.333Z"'
+                            }
+                        ]
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a measure through http IT should map the measure to fixed timestamp attribute and use it for timestmap sent to Context Broker',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        mydatetime: '2022-02-02T02:22:22.222Z',
+                        a: 23
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: '2033-03-03T03:33:33.333Z',
+                                type: 'DateTime'
+                            }
+                        }
+                    },
+                    TimeInstant: {
+                        value: '2033-03-03T03:33:33.333Z',
+                        type: 'DateTime'
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName: '0433 - Simple group with active attribute + several timestamp mappings defined in multientity',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        timestamp: true,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'a',
+                                type: 'Text'
+                            },
+                            {
+                                object_id: 'mydatetime1',
+                                name: 'TimeInstant',
+                                type: 'DateTime',
+                                entity_name: 'TestType:TestDevice1',
+                                entity_type: 'TestType'
+                            },
+                            {
+                                object_id: 'mydatetime2',
+                                name: 'TimeInstant',
+                                type: 'DateTime',
+                                entity_name: 'TestType:TestDevice2',
+                                entity_type: 'TestType'
+                            },
+                            {
+                                object_id: 'a1',
+                                name: 'a1',
+                                type: 'Text',
+                                expression: 'a',
+                                entity_name: 'TestType:TestDevice1',
+                                entity_type: 'TestType'
+                            },
+                            {
+                                object_id: 'a2',
+                                name: 'a2',
+                                type: 'Text',
+                                expression: 'a',
+                                entity_name: 'TestType:TestDevice2',
+                                entity_type: 'TestType'
+                            }
+                        ]
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a measure through http IT should map the measure to timestamp attributes and use it for timestmap and other metadata attributes sent to Context Broker',
+                type: 'multientity',
+                isRegex: true,
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 23,
+                        mydatetime1: '2011-01-01T01:11:11.111Z',
+                        mydatetime2: '2022-02-02T02:22:22.222Z'
+                    }
+                },
+                expectation: {
+                    actionType: 'append',
+                    entities: [
+                        {
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type,
+                            a: {
+                                value: 23,
+                                type: 'Text',
+                                metadata: {
+                                    TimeInstant: {
+                                        value: _.isDateString,
+                                        type: 'DateTime'
+                                    }
+                                }
+                            },
+                            TimeInstant: {
+                                value: _.isDateString,
+                                type: 'DateTime'
+                            }
+                        },
+                        {
+                            id: 'TestType:TestDevice1',
+                            type: globalEnv.entity_type,
+                            a1: {
+                                value: 23,
+                                type: 'Text',
+                                metadata: {
+                                    TimeInstant: {
+                                        value: '2011-01-01T01:11:11.111Z',
+                                        type: 'DateTime'
+                                    }
+                                }
+                            },
+                            TimeInstant: {
+                                value: '2011-01-01T01:11:11.111Z',
+                                type: 'DateTime'
+                            }
+                        },
+                        {
+                            id: 'TestType:TestDevice2',
+                            type: globalEnv.entity_type,
+                            a2: {
+                                value: 23,
+                                type: 'Text',
+                                metadata: {
+                                    TimeInstant: {
+                                        value: '2022-02-02T02:22:22.222Z',
+                                        type: 'DateTime'
+                                    }
+                                }
+                            },
+                            TimeInstant: {
+                                value: '2022-02-02T02:22:22.222Z',
+                                type: 'DateTime'
+                            }
+                        }
+                    ]
+                }
+            },
+            {
+                shouldName:
+                    'A - WHEN sending a measure through http IT should map the measure to timestamp attributes for just mapped entity and sent to Context Broker',
+                type: 'multientity',
+                isRegex: true,
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        mydatetime1: '2011-01-01T01:11:11.111Z'
+                    }
+                },
+                expectation: {
+                    actionType: 'append',
+                    entities: [
+                        {
+                            id: 'TestType:TestDevice1',
+                            type: globalEnv.entity_type,
+                            TimeInstant: {
+                                value: '2011-01-01T01:11:11.111Z',
+                                type: 'DateTime'
+                            }
+                        }
+                    ]
+                }
+            }
+        ]
+    },
+
     // 0500 - EXPLICIT ATTRIBUTES TESTS
     {
         describeName: '0500 - Group with explicit attrs:false (boolean) + active atributes',

package/test/unit/ngsiv2/plugins/multientity-plugin_test.js

@@ -307,6 +307,38 @@ const iotAgentConfig = {
                 }
             ]
         },
+        WeatherStation10: {
+            commands: [],
+            type: 'WeatherStation',
+            lazy: [],
+            active: [
+                {
+                    object_id: 'p',
+                    name: 'pressure',
+                    type: 'Hgmm'
+                },
+                {
+                    object_id: 'h',
+                    name: 'humidity',
+                    type: 'Percentage',
+                    entity_name: 'Higro2000',
+                    entity_type: 'Higrometer',
+                    metadata: {
+                        unitCode: {
+                            type: 'Text',
+                            value: 'Hgmm'
+                        }
+                    }
+                },
+                {
+                    object_id: 'TimeInstant',
+                    name: 'TimeInstant',
+                    type: 'DateTime',
+                    entity_name: 'Higro2000',
+                    entity_type: 'Higrometer'
+                }
+            ]
+        },
         Sensor001: {
             commands: [],
             type: 'Sensor',
@@ -1488,7 +1520,7 @@ describe('NGSI-v2 - Multi-entity plugin', function () {
 
 describe('NGSI-v2 - Multi-entity plugin is executed before timestamp process plugin', function () {
     beforeEach(function (done) {
-        logger.setLevel('FATAL');
+        logger.setLevel('DEBUG');
         iotAgentConfig.timestamp = true;
         iotAgentLib.activate(iotAgentConfig, function () {
             iotAgentLib.clearAll(function () {
@@ -1635,7 +1667,7 @@ describe('NGSI-v2 - Multi-entity plugin is executed before timestamp process plu
                     value: '2018-06-13T13:28:34.611Z'
                 }
             ];
-            iotAgentLib.update('ws5', 'WeatherStation', '', tsValue, function (error) {
+            iotAgentLib.update('ws5', 'WeatherStation10', '', tsValue, function (error) {
                 should.not.exist(error);
                 contextBrokerMock.done();
                 done();