iotagent-node-lib 2.20.0 → 2.23.0

package/lib/plugins/multiEntity.js_avg2

@@ -0,0 +1,343 @@
+/*
+ * Copyright 2016 Telefonica Investigación y Desarrollo, S.A.U
+ *
+ * This file is part of fiware-iotagent-lib
+ *
+ * fiware-iotagent-lib is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * fiware-iotagent-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License along with fiware-iotagent-lib.
+ * If not, see http://www.gnu.org/licenses/.
+ *
+ * For those usages not covered by the GNU Affero General Public License
+ * please contact with::daniel.moranjimenez@telefonica.com
+ *
+ * Modified by: Daniel Calvo - ATOS Research & Innovation
+ */
+
+/* eslint-disable no-prototype-builtins */
+/* eslint-disable array-callback-return */
+
+const _ = require('underscore');
+const constants = require('../constants');
+const legacyParser = require('./expressionParser');
+const jexlParser = require('./jexlParser');
+const config = require('../commonConfig');
+/* eslint-disable-next-line  no-unused-vars */
+const logger = require('logops');
+/* eslint-disable-next-line  no-unused-vars */
+const context = {
+    op: 'IoTAgentNGSI.MultiEntityPlugin'
+};
+const utils = require('./pluginUtils');
+/* eslint-disable-next-line  no-unused-vars */
+const aliasPlugin = require('./attributeAlias');
+
+function checkJexl(typeInformation) {
+    if (
+        config.getConfig().defaultExpressionLanguage === 'jexl' &&
+        typeInformation.expressionLanguage &&
+        typeInformation.expressionLanguage !== 'legacy'
+    ) {
+        return true;
+    } else if (config.getConfig().defaultExpressionLanguage === 'jexl' && !typeInformation.expressionLanguage) {
+        return true;
+    } else if (
+        config.getConfig().defaultExpressionLanguage === 'legacy' &&
+        typeInformation.expressionLanguage &&
+        typeInformation.expressionLanguage === 'jexl'
+    ) {
+        return true;
+    }
+    return false;
+}
+
+function hasEntityName(item) {
+    return item.entity_name;
+}
+
+/**
+ * Return a list of all the attributes that don't have a multientity option. It considers NGSIv2.
+ *
+ * @param {Array} originalAttrs        Array of original attributes coming from the single-entity device.
+ * @param {Array} meAttributes         Array of all the multientity attributes.
+ * @return {Array}                     List of all the attrbiutes without multientity flag.
+ */
+function filterOutMultientitiesNgsi2(originalAttrs, meAttributes) {
+
+    function filterByEntityName() {
+        return function (item) {
+            return (item.entity_name !== undefined);
+        };
+    }
+    
+    const result = {};
+    logger.debug(context, 'filterOutMultientitiesNgsi2 entity=originalAttrs: %j', originalAttrs);        
+    logger.debug(context, 'filterOutMultientitiesNgsi2 meAttributes: %j', meAttributes);    
+    const meNamesList = _.pluck(meAttributes, 'name');
+    //logger.debug(context, 'filterOutMultientitiesNgsi2 meNamesList: %j', meNamesList);
+    const meObjectsList = _.pluck(meAttributes, 'object_id');
+    logger.debug(context, 'filterOutMultientitiesNgsi2 meObjectsList: %j', meObjectsList);
+    const meEntityNamesList = _.pluck(meAttributes.filter(filterByEntityName()), 'name');
+    logger.debug(context, 'filterOutMultientitiesNgsi2 meEntityNamesList: %j', meEntityNamesList); 
+    let toBeFilteredByObj = [];
+
+    for (const att in originalAttrs) {
+        if (originalAttrs.hasOwnProperty(att)) {
+            logger.debug(context, 'filterOutMultientitiesNgsi2 checking att: %j value %j', att, originalAttrs[att]);
+            //if (!_.contains(meNamesList, att)) {
+            if (!_.contains(meEntityNamesList, att)) {
+                result[att] = originalAttrs[att];
+            } else {
+                // TO DO: should be checked with meAttributes
+                // if (!originalAttrs[att].entity_name && !originalAttrs[att].entity_type) {
+                //     result[att] = originalAttrs[att];
+                // }
+            }
+            if (originalAttrs[att].hasOwnProperty('multi')) {
+                let cleanAttributes = _.union([_.clone(originalAttrs[att])], originalAttrs[att].multi);
+                delete cleanAttributes[0].multi;
+                cleanAttributes = _.map(cleanAttributes, function (val) {
+                    val['name'] = att;
+                    return val;
+                });
+                toBeFilteredByObj = _.union(toBeFilteredByObj, cleanAttributes);
+            }
+        }
+    }
+
+    for (const att in toBeFilteredByObj) {
+        if (!_.contains(meObjectsList, toBeFilteredByObj[att].object_id)) {
+            result[toBeFilteredByObj[att].name] = toBeFilteredByObj[att];
+        }
+    }
+    logger.debug(context, 'filterOutMultientitiesNgsi2 result: %j', result);
+    return result;
+}
+
+/**
+ * Generate new Context Elements for each new Entity, with the attributes of the original entity matching its
+ * entity_name. It considers Ngsiv2.
+ *
+ * @param {Object} entity                   The original entity
+ * @param {Array} newEntities               List of the new entities that will be generated
+ * @param {Array} multiEntityAttributes     List of attributes with multientity option
+ * @return {Array}                          List of the new Context Entities
+ */
+function generateNewCEsNgsi2(entity, newEntities, multiEntityAttributes) {
+    const result = [];
+    let newEntityAttributes;
+    let newEntityAttributeNames;
+    let newEntityAttributeObjectIds;
+    function filterByEntityNameandType(entityNameType) {
+        return function (item) {
+            return (
+                item.entity_name === entityNameType.entity_name &&
+                (!item.entity_type || item.entity_type === entityNameType.entity_type)
+            );
+        };
+    }
+
+    function filterByAttributeObjectIds(entity, newEntityAttributeNames, newEntityAttributeObjectIds) {
+        const result = {};
+        for (const att in entity) {
+            if (entity.hasOwnProperty(att)) {
+                if (_.contains(newEntityAttributeNames, att)) {
+                    if (entity[att].object_id && _.contains(newEntityAttributeObjectIds, entity[att].object_id)) {
+                        result[att] = entity[att];
+                        delete entity[att].object_id;
+                    } else if (entity[att].multi) {
+                        for (const j in entity[att].multi) {
+                            if (
+                                entity[att].multi[j].object_id &&
+                                _.contains(newEntityAttributeObjectIds, entity[att].multi[j].object_id)
+                            ) {
+                                result[att] = entity[att].multi[j];
+                                delete entity[att].multi[j].object_id;
+                                break; // stop in first ocurrence (#635)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    function filterNew(entity, multientityAttributes, name, type) {
+        logger.debug(context, 'filterNew: \n entity %j \n multientityAttribute %j \n name %j type %j',
+                     entity, multientityAttributes, name, type);
+        const result = {};
+        for (const att in entity) { 
+            if (entity.hasOwnProperty(att)) {
+                for (const j in multientityAttributes) {
+                    if ( multientityAttributes[j].object_id && entity[att].object_id &&
+                         multientityAttributes[j].object_id === entity[att].object_id &&
+                         (multientityAttributes[j].entity_type ? 
+                          multientityAttributes[j].entity_type === type : true) && 
+                         multientityAttributes[j].entity_name === name                         
+                       ) {
+                        result[multientityAttributes[j].name] = {
+                            type: entity[att].type,                         
+                            value: entity[att].value
+                        };
+                        if (entity[att].metadata) {
+                            result[multientityAttributes[j].name].metadata = entity[att].metadata;
+                        }
+                    }
+                    if (entity[att].multi){
+                        for (const k in entity[att].multi) {
+                            if ( multientityAttributes[j].object_id && entity[att].multi[k].object_id &&
+                                 multientityAttributes[j].object_id === entity[att].multi[k].object_id &&
+                                 (multientityAttributes[j].entity_type ?
+                                  multientityAttributes[j].entity_type === type : true) && 
+                                 multientityAttributes[j].entity_name === name                         
+                               ) {
+                                result[multientityAttributes[j].name] = {
+                                    type: entity[att].multi[k].type,                         
+                                    value: entity[att].multi[k].value
+                                };
+                                if (entity[att].multi[k].metadata) {
+                                    result[multientityAttributes[j].name].metadata = entity[att].multi[k].metadata;
+                                }
+                            }
+                        }
+                            
+                    }
+                }
+
+            }
+        }
+        logger.debug(context, 'filterNew result: %j', result);
+        return result;
+    }
+
+   // logger.debug(context, 'generateNewCEsNgsi2 entity: %j', entity); // measure
+    // entity: {"vol":{"type":"Number","value":0,"object_id":"v"},"id":"sh3","type":"ShareStation"}
+   // logger.debug(context, 'generateNewCEsNgsi2 multientityAttributes %j', multiEntityAttributes);
+    // multiEntityAttributes: [{"object_id":"v","name":"vol","type":"Number","entity_name":"WeatherStation1","entity_type":"Type1"},{"object_id":"v","name":"vol","type":"Number","entity_name":"WeatherStation1","entity_type":"Type2"},{"object_id":"v","name":"extravol","type":"Number","entity_name":"WeatherStation1","entity_type":"Type2"}]
+    //logger.debug(context, 'generateNewCEsNgsi2 newEntities %j', newEntities);
+    // newEntities [{"entity_name":"WeatherStation1","entity_type":"Type1"},{"entity_name":"WeatherStation1","entity_type":"Type2"}]
+    for (let i = 0; i < newEntities.length; i++) {
+        //logger.debug(context, 'generateNewCEsNgsi2 current newEntities: %j', newEntities[i]);
+        newEntityAttributeNames = _.pluck(
+            multiEntityAttributes.filter(filterByEntityNameandType(newEntities[i])),
+            'name'
+        );
+        //logger.debug(context, 'generateNewCEsNgsi2 newEntityAttributeNames: %j', newEntityAttributeNames);
+        newEntityAttributeObjectIds = _.pluck(
+            multiEntityAttributes.filter(filterByEntityNameandType(newEntities[i])),
+            'object_id'
+        );
+        //logger.debug(context, 'generateNewCEsNgsi2 newEntityAttributeObjectIds: %j', newEntityAttributeObjectIds);
+        //newEntityAttributes = filterByAttributeObjectIds(entity, newEntityAttributeNames, newEntityAttributeObjectIds);
+        newEntityAttributes = filterNew(entity, multiEntityAttributes, newEntities[i].entity_name, newEntities[i].entity_type);
+        //logger.debug(context, 'generateNewCEsNgsi2 newEntityAttributes: %j', newEntityAttributes);
+        newEntityAttributes.type = newEntities[i].entity_type;
+        newEntityAttributes.id = newEntities[i].entity_name;
+        result.push(newEntityAttributes);
+    }
+    logger.debug(context, 'generateNewCEsNgsi2 result entities %j', result);
+    return result;
+}
+
+function extractNewEntities(multiEntityAttributes, defaultType) {
+    let newEntitieswithDuplicates = multiEntityAttributes.map((elem) => {
+        return { entity_name: elem.entity_name, entity_type: elem.entity_type || defaultType };
+    });
+    let auxOverwriteTree = {};
+    for (let entityItem in newEntitieswithDuplicates) {
+        if (!auxOverwriteTree[newEntitieswithDuplicates[entityItem].entity_name]) {
+            auxOverwriteTree[newEntitieswithDuplicates[entityItem].entity_name] = {};
+        }
+        auxOverwriteTree[newEntitieswithDuplicates[entityItem].entity_name][
+            newEntitieswithDuplicates[entityItem].entity_type
+        ] = null;
+    }
+    let flatNewEntities = [];
+    for (let entityItem in auxOverwriteTree) {
+        for (let typeItem in auxOverwriteTree[entityItem]) {
+            flatNewEntities.push({ entity_name: entityItem, entity_type: typeItem });
+        }
+    }
+    return flatNewEntities;
+}
+/**
+ * Propagates the same timestamp used in entity to entities. This is needed given that timestamp processing
+ * plugin runs before multientity plugin, so we could have issues as the one described here:
+ * https://github.com/telefonicaid/iotagent-node-lib/issues/748
+ *
+ * Note that this kind of timestamp propagation only works for NGSIv2. That is intentional: NGSIv1 is
+ * deprecated so we don't want to spend effort on it.
+ *
+ * @param entity entity which is the source of timestamp
+ * @param entities array to adjust
+ *
+ */
+function propagateTimestamp(entity, entities) {
+    const ts = entity[constants.TIMESTAMP_ATTRIBUTE];
+    if (!ts) {
+        return;
+    }
+
+    entities.map(function (en) {
+        let att;
+        // Set timestamp metadata in attributes (except TimeInstant attribute itself)
+        for (att in en && att !== constants.TIMESTAMP_ATTRIBUTE) {
+            if (en.hasOwnProperty(att) && att !== 'id' && att !== 'type') {
+                if (!en[att].metadata) {
+                    en[att].metadata = {};
+                }
+                en[att].metadata[constants.TIMESTAMP_ATTRIBUTE] = ts;
+            }
+        }
+        // Set timestamp attribute inm the entity itself
+        en[constants.TIMESTAMP_ATTRIBUTE] = ts;
+    });
+}
+
+function updateAttribute(entity, typeInformation, callback) {
+    let parser = legacyParser;
+    if (checkJexl(typeInformation)) {
+        parser = jexlParser;
+    }
+    const attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
+    const ctx = parser.extractContext(attsArray);
+
+    let entities = [entity];
+    if (typeInformation.active) {
+        const multiEntityAttributes = typeInformation.active.filter(hasEntityName);
+        for (let i in multiEntityAttributes) {
+            if (parser.contextAvailable(multiEntityAttributes[i].entity_name, ctx)) {
+                let entityName = parser.applyExpression(multiEntityAttributes[i].entity_name, ctx, typeInformation);
+                // An entity_name could not be null, but a result or expression could be null
+                if (entityName !== null) {
+                    multiEntityAttributes[i].entity_name = entityName;
+                }
+            }
+        }
+        const newEntities = extractNewEntities(multiEntityAttributes, typeInformation.type);
+
+        if (multiEntityAttributes.length > 0) {
+            let resultAttributes = filterOutMultientitiesNgsi2(entity, multiEntityAttributes);
+            logger.debug(context, ' filterOutMultientitiesNgsi2 resultAttributes: %j', resultAttributes);
+            const newCes = generateNewCEsNgsi2(entity, newEntities, multiEntityAttributes);
+            entities = [resultAttributes].concat(newCes);
+            logger.debug(context, 'all entities: %j', entities);
+            propagateTimestamp(entity, entities);
+        } else {
+            entities = entity;
+        }
+    }
+    callback(null, entities, typeInformation);
+}
+
+exports.update = updateAttribute;

package/lib/plugins/pluginUtils.js

@@ -167,9 +167,25 @@ function identityFilter(entity, typeInformation, callback) {
     callback(null, entity, typeInformation);
 }
 
+/**
+ * Creates an array of attributes from an device including id, type, service and subservice
+ * @param       {Object}             device
+ * @return      {Object}             Array of id, type, service and subservice extracted from device
+ */
+function getIdTypeServSubServiceFromDevice(typeInformation) {
+    let attrList = [
+        { name: 'id', type: 'String', value: typeInformation.id },
+        { name: 'type', type: 'String', value: typeInformation.type },
+        { name: 'service', type: 'String', value: typeInformation.service },
+        { name: 'subservice', type: 'String', value: typeInformation.subservice }
+    ];
+    return attrList;
+}
+
 exports.createProcessAttribute = createProcessAttribute;
 exports.createUpdateFilter = createUpdateFilter;
 exports.createQueryFilter = createQueryFilter;
 exports.identityFilter = identityFilter;
 exports.createNgsi2Entity = createNgsi2Entity;
 exports.extractAttributesArrayFromNgsi2Entity = extractAttributesArrayFromNgsi2Entity;
+exports.getIdTypeServSubServiceFromDevice = getIdTypeServSubServiceFromDevice;

package/lib/services/commands/commandService.js

@@ -29,10 +29,12 @@ const config = require('../../commonConfig');
 const constants = require('../../constants');
 const ngsiService = require('../ngsi/ngsiService');
 const deviceService = require('../devices/deviceService');
+const pluginUtils = require('../../plugins/pluginUtils');
 let daemonId;
 const context = {
     op: 'IoTAgentNGSI.CommandService'
 };
+const expressionPlugin = require('../../plugins/expressionPlugin');
 
 function listCommands(service, subservice, deviceId, callback) {
     logger.debug(context, 'Listing all commands for device [%s]', deviceId);
@@ -41,11 +43,35 @@ function listCommands(service, subservice, deviceId, callback) {
 }
 
 function addCommand(service, subservice, deviceId, command, callback) {
-    logger.debug(context, 'Adding command [%s] to the queue for device [%s]', command.name, deviceId);
-
+    logger.debug(context, 'Adding command [%j] to the queue for device [%s]', command, deviceId);
     config.getCommandRegistry().add(service, subservice, deviceId, command, callback);
 }
 
+function addCommandDevice(service, subservice, device, command, callback) {
+    logger.debug(context, 'Adding command [%j] to the queue for device [%j]', command, device);
+    let deviceCmd;
+    if (device && device.commands) {
+        deviceCmd = device.commands.find((c) => c.name === command.name);
+    }
+    if (deviceCmd && deviceCmd.expression) {
+        let parser = expressionPlugin;
+        // The context for the JEXL expression should be the ID, TYPE, S, SS
+        let attrList = pluginUtils.getIdTypeServSubServiceFromDevice(device);
+        attrList = device.staticAttributes ? attrList.concat(device.staticAttributes) : attrList.concat([]);
+        let ctxt = parser.extractContext(attrList, device);
+        logger.debug(context, 'attrList [%j] for device %j', attrList, device);
+        // expression result will be the full command payload
+        let cmdValueRes = null;
+        try {
+            cmdValueRes = parser.applyExpression(deviceCmd.expression, ctxt, device);
+        } catch (e) {
+            // nothing to do
+        }
+        command.value = cmdValueRes ? cmdValueRes : deviceCmd.expression;
+    }
+    config.getCommandRegistry().add(service, subservice, device.id, command, callback);
+}
+
 function updateCommand(service, subservice, deviceId, name, value, callback) {
     logger.debug(context, 'Updating command [%s] for device [%s] with value [%s]', name, deviceId, value);
 
@@ -147,6 +173,7 @@ function stopExpirationDaemon(callback) {
 
 exports.list = intoTrans(context, listCommands);
 exports.add = addCommand;
+exports.addCmd = addCommandDevice;
 exports.update = updateCommand;
 exports.remove = removeCommand;
 exports.start = startExpirationDaemon;

package/lib/services/common/iotManagerService.js

@@ -60,7 +60,8 @@ function register(callback) {
             explicitAttrs: service.explicitAttrs,
             expressionLanguage: service.expressionLanguage,
             defaultEntityNameConjunction: service.defaultEntityNameConjunction,
-            ngsiVersion: service.ngsiVersion
+            ngsiVersion: service.ngsiVersion,
+            entityNameExp: service.entityNameExp
         };
     }
 

package/lib/services/devices/deviceRegistryMemory.js

@@ -149,13 +149,19 @@ function getDevice(id, service, subservice, callback) {
     }
 }
 
-function getByName(name, service, subservice, callback) {
+function getByNameAndType(name, type, service, subservice, callback) {
     const devices = _.values(registeredDevices[service]);
     let device;
 
     for (let i = 0; i < devices.length; i++) {
         if (devices[i].name === name) {
-            device = devices[i];
+            if (type) {
+                if (devices[i].type === type) {
+                    device = devices[i];
+                }
+            } else {
+                device = devices[i];
+            }
         }
     }
 
@@ -166,6 +172,10 @@ function getByName(name, service, subservice, callback) {
     }
 }
 
+function getByName(name, service, subservice, callback) {
+    getByNameAndType(name, null, service, subservice, callback);
+}
+
 function update(device, callback) {
     registeredDevices[device.service][device.id] = deepClone(device);
     callback(null, device);
@@ -208,4 +218,5 @@ exports.list = listDevices;
 exports.get = getDevice;
 exports.getSilently = getDevice;
 exports.getByName = getByName;
+exports.getByNameAndType = getByNameAndType;
 exports.clear = clear;

package/lib/services/devices/deviceRegistryMongoDB.js

@@ -243,15 +243,18 @@ function getDevice(id, service, subservice, callback) {
     });
 }
 
-function getByName(name, service, servicepath, callback) {
+function getByNameAndType(name, type, service, servicepath, callback) {
     context = fillService(context, { service, subservice: servicepath });
-    logger.debug(context, 'Looking for device with name [%s].', name);
-
-    const query = Device.model.findOne({
-        name,
-        service,
+    let optionsQuery = {
+        name: name,
+        service: service,
         subservice: servicepath
-    });
+    };
+    if (type) {
+        optionsQuery.type = type;
+    }
+    logger.debug(context, 'Looking for device with [%j].', optionsQuery);
+    const query = Device.model.findOne(optionsQuery);
 
     query.select({ __v: 0 });
 
@@ -270,6 +273,10 @@ function getByName(name, service, servicepath, callback) {
     });
 }
 
+function getByName(name, service, servicepath, callback) {
+    getByNameAndType(name, null, service, servicepath, callback);
+}
+
 /**
  * Updates the given device into the database.
  * updated.
@@ -361,4 +368,5 @@ exports.list = alarmsInt(constants.MONGO_ALARM, listDevices);
 exports.get = alarmsInt(constants.MONGO_ALARM, getDevice);
 exports.getSilently = getDevice;
 exports.getByName = alarmsInt(constants.MONGO_ALARM, getByName);
+exports.getByNameAndType = alarmsInt(constants.MONGO_ALARM, getByNameAndType);
 exports.clear = alarmsInt(constants.MONGO_ALARM, clear);

package/lib/services/devices/deviceService.js

@@ -38,6 +38,8 @@ const logger = require('logops');
 const config = require('../../commonConfig');
 const registrationUtils = require('./registrationUtils');
 const subscriptions = require('../ngsi/subscriptionService');
+const expressionPlugin = require('./../../plugins/expressionPlugin');
+const pluginUtils = require('./../../plugins/pluginUtils');
 const _ = require('underscore');
 const context = {
     op: 'IoTAgentNGSI.DeviceService'
@@ -214,7 +216,13 @@ function findConfigurationGroup(deviceObj, callback) {
     } else {
         config
             .getGroupRegistry()
-            .findTypeSilently(deviceObj.service, deviceObj.subservice, deviceObj.type, deviceObj.apikey, handlerGroupFindByType);
+            .findTypeSilently(
+                deviceObj.service,
+                deviceObj.subservice,
+                deviceObj.type,
+                deviceObj.apikey,
+                handlerGroupFindByType
+            );
     }
 }
 
@@ -274,22 +282,32 @@ function registerDevice(deviceObj, callback) {
         }
 
         if (!deviceData.name) {
-            let conjunction;
-            if (configuration && configuration.defaultEntityNameConjunction !== undefined) {
-                conjunction = configuration.defaultEntityNameConjunction;
+            if (configuration && configuration.entityNameExp !== undefined) {
+                // Add device ID, TYPE, S, SS to the context for the JEXL expression
+                let attrList = pluginUtils.getIdTypeServSubServiceFromDevice(deviceData);
+                attrList = deviceData.staticAttributes ? attrList.concat(deviceData.staticAttributes) : attrList;
+                let ctxt = expressionPlugin.extractContext(attrList, deviceData);
+                let entityName = expressionPlugin.applyExpression(configuration.entityNameExp, ctxt, deviceData);
+                deviceData.name = entityName ? entityName : configuration.entityNameExp;
             } else {
-                conjunction = config.getConfig().defaultEntityNameConjunction;
-            }
-            deviceData.name = deviceData.type + conjunction + deviceData.id;
-            if (config.checkNgsiLD(configuration)) {
-                deviceData.name = 'urn:ngsi-ld:' + deviceData.type + conjunction + deviceData.id;
+                let conjunction;
+                if (configuration && configuration.defaultEntityNameConjunction !== undefined) {
+                    conjunction = configuration.defaultEntityNameConjunction;
+                } else {
+                    conjunction = config.getConfig().defaultEntityNameConjunction;
+                }
+                deviceData.name = deviceData.type + conjunction + deviceData.id;
+
+                if (config.checkNgsiLD(configuration)) {
+                    deviceData.name = 'urn:ngsi-ld:' + deviceData.type + conjunction + deviceData.id;
+                }
+                logger.debug(
+                    context,
+                    'Device name not found, falling back to deviceType%sdeviceId [%s]',
+                    conjunction,
+                    deviceData.name
+                );
             }
-            logger.debug(
-                context,
-                'Device name not found, falling back to deviceType%sdeviceId [%s]',
-                conjunction,
-                deviceData.name
-            );
         }
 
         if (!configuration && config.getConfig().types[deviceData.type]) {
@@ -513,6 +531,18 @@ function getDeviceByName(deviceName, service, subservice, callback) {
     config.getRegistry().getByName(deviceName, service, subservice, callback);
 }
 
+/**
+ * Retrieve a device from the registry based on its entity name and type
+ *
+ * @param {String} deviceName       Name of the entity associated to a device.
+ * @param {String} deviceType       Type of the entity associated to a device.
+ * @param {String} service          Service the device belongs to.
+ * @param {String} subservice       Division inside the service.
+ */
+function getDeviceByNameAndType(deviceName, deviceType, service, subservice, callback) {
+    config.getRegistry().getByNameAndType(deviceName, deviceType, service, subservice, callback);
+}
+
 /**
  * Retrieve a device from the registry based on the value of a given attribute.
  *
@@ -581,7 +611,12 @@ function findOrCreate(deviceId, group, callback) {
                     callback(error, device, group);
                 });
             } else {
-                logger.info(context, 'Device %j not provisioned due autoprovision is disabled by its conf %j', newDevice, group);
+                logger.info(
+                    context,
+                    'Device %j not provisioned due autoprovision is disabled by its conf %j',
+                    newDevice,
+                    group
+                );
                 callback(new errors.DeviceNotFound(deviceId));
             }
         } else {
@@ -632,6 +667,7 @@ exports.getDevice = intoTrans(context, checkRegistry)(getDevice);
 exports.getDeviceSilently = intoTrans(context, checkRegistry)(getDeviceSilently);
 exports.getDevicesByAttribute = intoTrans(context, checkRegistry)(getDevicesByAttribute);
 exports.getDeviceByName = intoTrans(context, checkRegistry)(getDeviceByName);
+exports.getDeviceByNameAndType = intoTrans(context, checkRegistry)(getDeviceByNameAndType);
 exports.register = intoTrans(context, registerDevice);
 exports.updateRegister = intoTrans(context, updateRegisterDevice);
 exports.unregister = intoTrans(context, unregisterDevice);