iotagent-node-lib 2.15.1 → 2.19.0

package/lib/plugins/multiEntity.js

@@ -41,20 +41,19 @@ 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'
+        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'
+        typeInformation.expressionLanguage &&
+        typeInformation.expressionLanguage === 'jexl'
     ) {
         return true;
     }
@@ -65,19 +64,6 @@ function hasEntityName(item) {
     return item.entity_name;
 }
 
-/**
- * Return a list of all the attributes that don't have a multientity option. It considers NGSIv1.
- *
- * @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 filterOutMultientitiesNgsi1(originalAttrs, meAttributes) {
-    return originalAttrs.filter(function (item) {
-        return !_.contains(meAttributes, item.name);
-    });
-}
-
 /**
  * Return a list of all the attributes that don't have a multientity option. It considers NGSIv2.
  *
@@ -87,8 +73,8 @@ function filterOutMultientitiesNgsi1(originalAttrs, meAttributes) {
  */
 function filterOutMultientitiesNgsi2(originalAttrs, meAttributes) {
     const result = {};
-    const meNamesList = _.pluck( meAttributes, 'name');
-    const meObjectsList = _.pluck( meAttributes, 'object_id');
+    const meNamesList = _.pluck(meAttributes, 'name');
+    const meObjectsList = _.pluck(meAttributes, 'object_id');
     let toBeFilteredByObj = [];
 
     for (const att in originalAttrs) {
@@ -96,11 +82,14 @@ function filterOutMultientitiesNgsi2(originalAttrs, meAttributes) {
             if (!_.contains(meNamesList, att)) {
                 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);
+            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);
             }
         }
     }
@@ -114,85 +103,30 @@ function filterOutMultientitiesNgsi2(originalAttrs, meAttributes) {
     return result;
 }
 
-/**
- * Generate new Context Elements for each new Entity, with the attributes of the original entity matching its
- * entity_name. It considers Ngsiv1.
- *
- * @param {Object} entity                   The original entity
- * @param {Array} newEntities               List of the new entities that will be generated
- * @param {Array} entityTypes               Map of the types for each entity ID
- * @param {Object} typeInformation          Object with all the data about the device type
- * @param {Array} multiEntityAttributes     List of attributes with multientity option
- * @return {Array}                          List of the new Context Entities
- */
-function generateNewCEsNgsi1(entity, newEntities, entityTypes, typeInformation, multiEntityAttributes) {
-    const result = [];
-    let newEntityAttributes;
-    let newEntityAttributeNames;
-    let entityName;
-    let parser = legacyParser;
-    if (checkJexl(typeInformation)) {
-        parser = jexlParser;
-    }
-    function filterByEntityName(entityName) {
-        return function (item) {
-            return item.entity_name === entityName;
-        };
-    }
-
-    function filterByAttributeNames(item) {
-        return _.contains(newEntityAttributeNames, item.name);
-    }
-
-    const ctx = parser.extractContext(entity.contextElements[0].attributes);
-
-    for (let i = 0; i < newEntities.length; i++) {
-        newEntityAttributeNames = _.pluck(multiEntityAttributes.filter(filterByEntityName(newEntities[i])), 'name');
-
-        newEntityAttributes = entity.contextElements[0].attributes.filter(filterByAttributeNames);
-        // Fix duplicated attributes in entity
-        newEntityAttributes = _.uniq(newEntityAttributes, JSON.stringify);
-        entityName = parser.applyExpression(newEntities[i], ctx, typeInformation);
-
-        result.push({
-            type: entityTypes[newEntities[i]],
-            isPattern: 'false',
-            id: entityName,
-            attributes: newEntityAttributes
-        });
-    }
-
-    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} entityTypes               Map of the types for each entity ID
- * @param {Object} typeInformation          Object with all the data about the device type
  * @param {Array} multiEntityAttributes     List of attributes with multientity option
  * @return {Array}                          List of the new Context Entities
  */
-function generateNewCEsNgsi2(entity, newEntities, entityTypes, typeInformation, multiEntityAttributes) {
+function generateNewCEsNgsi2(entity, newEntities, multiEntityAttributes) {
     const result = [];
     let newEntityAttributes;
     let newEntityAttributeNames;
     let newEntityAttributeObjectIds;
-    let entityName;
-    let parser = legacyParser;
-    if (checkJexl(typeInformation)) {
-        parser = jexlParser;
-    }
-    function filterByEntityName(entityName) {
+    function filterByEntityNameandType(entityNameType) {
         return function (item) {
-            return item.entity_name === entityName;
+            return (
+                item.entity_name === entityNameType.entity_name &&
+                (!item.entity_type || item.entity_type === entityNameType.entity_type)
+            );
         };
     }
 
-    function filterByAttributeObjectIds() {
+    function filterByAttributeObjectIds(entity, newEntityAttributeNames, newEntityAttributeObjectIds) {
         const result = {};
         for (const att in entity) {
             if (entity.hasOwnProperty(att)) {
@@ -218,37 +152,44 @@ function generateNewCEsNgsi2(entity, newEntities, entityTypes, typeInformation,
         return result;
     }
 
-    const attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
-    const ctx = parser.extractContext(attsArray);
-
     for (let i = 0; i < newEntities.length; i++) {
-        newEntityAttributeNames = _.pluck(multiEntityAttributes.filter(filterByEntityName(newEntities[i])), 'name');
+        newEntityAttributeNames = _.pluck(
+            multiEntityAttributes.filter(filterByEntityNameandType(newEntities[i])),
+            'name'
+        );
         newEntityAttributeObjectIds = _.pluck(
-            multiEntityAttributes.filter(filterByEntityName(newEntities[i])),
+            multiEntityAttributes.filter(filterByEntityNameandType(newEntities[i])),
             'object_id'
         );
-        newEntityAttributes = filterByAttributeObjectIds();
-        entityName = parser.applyExpression(newEntities[i], ctx, typeInformation);
-
-        newEntityAttributes.type = entityTypes[newEntities[i]];
-        newEntityAttributes.id = entityName;
-
+        newEntityAttributes = filterByAttributeObjectIds(entity, newEntityAttributeNames, newEntityAttributeObjectIds);
+        newEntityAttributes.type = newEntities[i].entity_type;
+        newEntityAttributes.id = newEntities[i].entity_name;
         result.push(newEntityAttributes);
     }
-
     return result;
 }
 
-function extractTypes(attributeList, defaultType) {
-    const typeMap = {};
-
-    for (let i = 0; i < attributeList.length; i++) {
-        typeMap[attributeList[i].entity_name] = attributeList[i].entity_type || defaultType;
+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;
     }
-
-    return typeMap;
+    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:
@@ -283,44 +224,32 @@ function propagateTimestamp(entity, entities) {
     });
 }
 
-function updateAttributeNgsi1(entity, typeInformation, callback) {
-    if (typeInformation.active) {
-        const multiEntityAttributes = typeInformation.active.filter(hasEntityName);
-        const newEntities = _.uniq(_.pluck(multiEntityAttributes, 'entity_name'));
-        const attributesList = _.pluck(multiEntityAttributes, 'name');
-        const entityTypes = extractTypes(multiEntityAttributes, entity.contextElements[0].type);
-        const resultAttributes = filterOutMultientitiesNgsi1(entity.contextElements[0].attributes, attributesList);
-
-        entity.contextElements = entity.contextElements.concat(
-            generateNewCEsNgsi1(entity, newEntities, entityTypes, typeInformation, multiEntityAttributes)
-        );
-
-        entity.contextElements[0].attributes = resultAttributes;
+function updateAttribute(entity, typeInformation, callback) {
+    let parser = legacyParser;
+    if (checkJexl(typeInformation)) {
+        parser = jexlParser;
     }
+    const attsArray = utils.extractAttributesArrayFromNgsi2Entity(entity);
+    const ctx = parser.extractContext(attsArray);
 
-    callback(null, entity, typeInformation);
-}
-
-function updateAttributeNgsi2(entity, typeInformation, callback) {
-    let entities = [];
-    entities.push(entity);
+    let entities = [entity];
     if (typeInformation.active) {
         const multiEntityAttributes = typeInformation.active.filter(hasEntityName);
-        const newEntities = _.uniq(_.pluck(multiEntityAttributes, 'entity_name'));
-        const entityTypes = extractTypes(multiEntityAttributes, typeInformation.type);
-        let resultAttributes;
+        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) {
-            resultAttributes = filterOutMultientitiesNgsi2(entity, multiEntityAttributes);
-            const newCes = generateNewCEsNgsi2(
-                entity,
-                newEntities,
-                entityTypes,
-                typeInformation,
-                multiEntityAttributes
-            );
-            entities = entities.concat(newCes);
-            entities[0] = resultAttributes;
+            let resultAttributes = filterOutMultientitiesNgsi2(entity, multiEntityAttributes);
+            const newCes = generateNewCEsNgsi2(entity, newEntities, multiEntityAttributes);
+            entities = [resultAttributes].concat(newCes);
             propagateTimestamp(entity, entities);
         } else {
             entities = entity;
@@ -329,12 +258,4 @@ function updateAttributeNgsi2(entity, typeInformation, callback) {
     callback(null, entities, typeInformation);
 }
 
-function updateAttribute(entity, typeInformation, callback) {
-    if (config.isCurrentNgsi()) {
-        updateAttributeNgsi2(entity, typeInformation, callback);
-    } else {
-        updateAttributeNgsi1(entity, typeInformation, callback);
-    }
-}
-
 exports.update = updateAttribute;

package/lib/plugins/pluginUtils.js

@@ -23,8 +23,6 @@
  * Modified by: Daniel Calvo - ATOS Research & Innovation
  */
 
-const config = require('../commonConfig');
-
 /**
  * Creates an array of attributes from an entity
  * @param       {Object}             entity
@@ -66,8 +64,6 @@ function extractAttributesArrayFromNgsi2Entity(entity) {
  */
 function createNgsi2Entity(id, type, attsArray, withObjectId) {
     const entity = {};
-    entity.id = id;
-    entity.type = type;
     for (let i = 0; i < attsArray.length; i++) {
         /*jshint camelcase: false */
         if (entity[attsArray[i].name] && withObjectId && attsArray[i].object_id) {
@@ -93,7 +89,8 @@ function createNgsi2Entity(id, type, attsArray, withObjectId) {
             }
         }
     }
-
+    entity.id = id;
+    entity.type = type;
     return entity;
 }
 
@@ -102,24 +99,15 @@ function createProcessAttribute(fn, attributeType) {
         if (attribute.type && attribute.type === attributeType) {
             attribute.value = fn(attribute.value);
         }
-        if (config.isCurrentNgsi()) {
-            // This code is backwards compatible to process metadata in the older NGSIv1-style (array)
-            // as well as supporting the newer NGSIv2-style (object). The redundant Array Check can be
-            // therefore be removed if/when NGSIv1 support is removed from the library.
-            if (Array.isArray(attribute.metadata)) {
-                attribute.metadata = attribute.metadata.map(createProcessAttribute(fn, attributeType));
-            } else if (attribute.metadata) {
-                Object.keys(attribute.metadata).forEach(function (key) {
-                    const entry = attribute.metadata[key];
-                    if (entry.type === 'DateTime') {
-                        entry.value = fn(entry.value);
-                    }
-                });
-            }
-        } else if (attribute.metadatas) {
-            attribute.metadatas = attribute.metadatas.map(createProcessAttribute(fn, attributeType));
-        }
 
+        if (attribute.metadata) {
+            Object.keys(attribute.metadata).forEach(function (key) {
+                const entry = attribute.metadata[key];
+                if (entry.type === 'DateTime') {
+                    entry.value = fn(entry.value);
+                }
+            });
+        }
         return attribute;
     };
 }
@@ -135,12 +123,6 @@ function createProcessAttribute(fn, attributeType) {
 
 function createUpdateFilter(fn, attributeType) {
     return function update(entity, typeInformation, callback) {
-        function processEntityUpdateNgsi1(entity) {
-            entity.attributes = entity.attributes.map(createProcessAttribute(fn, attributeType));
-
-            return entity;
-        }
-
         function processEntityUpdateNgsi2(entity) {
             let attsArray = extractAttributesArrayFromNgsi2Entity(entity);
             attsArray = attsArray.map(createProcessAttribute(fn, attributeType));
@@ -148,12 +130,7 @@ function createUpdateFilter(fn, attributeType) {
             return entity;
         }
 
-        if (config.isCurrentNgsi()) {
-            entity = processEntityUpdateNgsi2(entity);
-        } else {
-            entity.contextElements = entity.contextElements.map(processEntityUpdateNgsi1);
-        }
-
+        entity = processEntityUpdateNgsi2(entity);
         callback(null, entity, typeInformation);
     };
 }
@@ -168,14 +145,6 @@ function createUpdateFilter(fn, attributeType) {
  */
 function createQueryFilter(fn, attributeType) {
     return function query(entity, typeInformation, callback) {
-        function processEntityQueryNgsi1(entity) {
-            entity.contextElement.attributes = entity.contextElement.attributes.map(
-                createProcessAttribute(fn, attributeType)
-            );
-
-            return entity;
-        }
-
         function processEntityQueryNgsi2(entity) {
             let attsArray = extractAttributesArrayFromNgsi2Entity(entity);
             attsArray = attsArray.map(createProcessAttribute(fn, attributeType));
@@ -183,12 +152,7 @@ function createQueryFilter(fn, attributeType) {
             return entity;
         }
 
-        if (config.isCurrentNgsi()) {
-            entity = processEntityQueryNgsi2(entity);
-        } else {
-            entity.contextResponses = entity.contextResponses.map(processEntityQueryNgsi1);
-        }
-
+        entity = processEntityQueryNgsi2(entity);
         callback(null, entity, typeInformation);
     };
 }

package/lib/plugins/timestampProcessPlugin.js

@@ -31,7 +31,6 @@ const logger = require('logops');
 const context = {
     op: 'IoTAgentNGSI.TimestampProcessPlugin'
 };
-const config = require('../commonConfig');
 const utils = require('./pluginUtils');
 
 /**
@@ -84,57 +83,13 @@ function updatePluginNgsi2(entity, entityType, callback) {
     }
 }
 
-/**
- * Looks for Thinking Thing modules and parses them, updating the entity (NGSIv1) with the transformed value.
- *
- * @param {Object} entity           NGSI Entity as it would have been sent before the plugin.
- */
-function updatePluginNgsi1(entity, entityType, callback) {
-    let timestamp;
-
-    function insertMetadata(element) {
-        if (element.name !== constants.TIMESTAMP_ATTRIBUTE) {
-            element.metadatas = [
-                {
-                    name: constants.TIMESTAMP_ATTRIBUTE,
-                    type: constants.TIMESTAMP_TYPE,
-                    value: timestamp.value
-                }
-            ];
-        }
-
-        return element;
-    }
-
-    if (entity.contextElements && entity.contextElements[0] && entity.contextElements[0].attributes) {
-        for (const i in entity.contextElements[0].attributes) {
-            if (entity.contextElements[0].attributes[i].name === constants.TIMESTAMP_ATTRIBUTE) {
-                timestamp = entity.contextElements[0].attributes[i];
-            }
-        }
-
-        if (timestamp) {
-            entity.contextElements[0].attributes = entity.contextElements[0].attributes.map(insertMetadata);
-        }
-
-        callback(null, entity, entityType);
-    } else {
-        logger.error(context, 'Bad payload received while processing timestamps');
-        callback(new errors.WrongSyntax(entity));
-    }
-}
-
 /**
  * Looks for Thinking Thing modules and parses them, updating the entity with the transformed value.
  *
  * @param {Object} entity           NGSI Entity as it would have been sent before the plugin.
  */
 function updatePlugin(entity, entityType, callback) {
-    if (config.isCurrentNgsi()) {
-        updatePluginNgsi2(entity, entityType, callback);
-    } else {
-        updatePluginNgsi1(entity, entityType, callback);
-    }
+    updatePluginNgsi2(entity, entityType, callback);
 }
 
 exports.update = updatePlugin;

package/lib/request-shim.js

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2014 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
+ */
+
+const got = require('got');
+const logger = require('logops');
+const context = {
+    op: 'IoTAgentNGSI.Request'
+};
+
+/**
+ *  Transform the "request" options into "got" options and add additional "got" defaults
+ *
+ *  The following options are currently exposed:
+ *   - `method` - HTTP Method
+ *   - `searchParams` - query string params
+ *   - `qs` - alias for query string params
+ *   - `headers`
+ *   - `responseType` - either `text` or `json`. `json` is the default
+ *   - `json` - a supplied JSON object as the request body
+ *   - `body` - any ASCII text as  the request body
+ *   - `url` - the request URL
+ *   - `uri` - alternative alias for the request URL.
+ *
+ * @param {Object} options          Original definition of the request using the request library
+ * @return {Object}                 Updated definition of the request using the got library
+ *
+ */
+function getOptions(options) {
+    const httpOptions = {
+        method: options.method,
+        searchParams: options.searchParams || options.qs,
+        headers: options.headers,
+        throwHttpErrors: options.throwHttpErrors || false,
+        retry: options.retry || 0,
+        responseType: options.responseType || 'json'
+    };
+
+    // got library is not properly documented, so it is not clear which takes precedence
+    // among body, json and form (see https://stackoverflow.com/q/70754880/1485926).
+    // Thus, we are enforcing our own precedence with the "else if" chain below.
+    // Behaviour is consistent with the one described at usermanual.md#iotagentlibrequest
+
+    if (options.method === 'GET' || options.method === 'HEAD' || options.method === 'OPTIONS') {
+        // Do nothing - Never add a body
+    } else if (options.body) {
+        // body takes precedence over json or form
+        httpOptions.body = options.body;
+    } else if (options.json) {
+        // json takes precedence over form
+        httpOptions.json = options.json;
+    } else if (options.form) {
+        // Note that we don't consider 'form' part of the function API (check usermanual.md#iotagentlibrequest)
+        // but we are preparing the code anyway as a safe measure
+        httpOptions.form = options.form;
+    }
+
+    return httpOptions;
+}
+
+/*
+ *
+ *  Make a direct HTTP request using the underlying request library
+ *  (currently [got](https://github.com/sindresorhus/got)),
+ *
+ *  This function mimics the interface of the obsolete request library and switches
+ *  back from promises to callbacks to avoid re-writing large chunks of code.
+ *  This centralizes all HTTP requests in a single location and is useful
+ *  when creating agents which use an HTTP transport for their southbound
+ *  commands, and removes the need for the custom IoT Agent to import its own
+ *  additonal request library.
+ *
+ * @param {Object} options            Definition of the request .
+ * @param {Function} callback         The callback function.
+ *
+ */
+
+function request(options, callback) {
+    const httpOptions = getOptions(options);
+    logger.debug(context, 'Options: %s', JSON.stringify(options, null, 4));
+    got(options.url || options.uri, httpOptions)
+        .then((response) => {
+            logger.debug(context, 'Response %s', JSON.stringify(response.body, null, 4));
+            return callback(null, response, response.body);
+        })
+        .catch((error) => {
+            logger.debug(context, 'Error: %s', JSON.stringify(error, null, 4));
+            return callback(error);
+        });
+}
+
+module.exports = request;

package/lib/services/common/domain.js

@@ -195,11 +195,11 @@ function finishSouthboundTransaction(callback) {
  * @return {Object}             New context containing service information.
  */
 function fillService(context, data) {
-    if (data.service) {
+    if (data && data.service) {
         context.srv = data.service;
     }
 
-    if (data.subservice) {
+    if (data && data.subservice) {
         context.subsrv = data.subservice;
     }
 

package/lib/services/common/genericMiddleware.js

@@ -71,7 +71,7 @@ function traceRequest(req, res, next) {
 
 /* eslint-disable-next-line  no-unused-vars */
 function changeLogLevel(req, res, next) {
-    const levels = ['INFO', 'ERROR', 'FATAL', 'DEBUG', 'WARNING'];
+    const levels = ['INFO', 'ERROR', 'FATAL', 'DEBUG', 'WARN', 'WARNING'];
 
     if (!req.query.level) {
         res.status(400).json({
@@ -82,7 +82,11 @@ function changeLogLevel(req, res, next) {
             error: 'invalid log level'
         });
     } else {
-        logger.setLevel(req.query.level.toUpperCase());
+        let newLevel = req.query.level.toUpperCase();
+        if (newLevel === 'WARNING') {
+            newLevel = 'WARN';
+        }
+        logger.setLevel(newLevel);
         res.status(200).send('');
     }
 }

package/lib/services/common/iotManagerService.js

@@ -23,7 +23,7 @@
  * Modified by: Federico M. Facca - Martel Innovate
  */
 
-const request = require('request');
+const request = require('../../request-shim');
 const async = require('async');
 const errors = require('../../errors');
 const constants = require('../../constants');

package/lib/services/common/securityServiceKeystone.js

@@ -21,7 +21,7 @@
  * please contact with::daniel.moranjimenez@telefonica.com
  */
 
-const request = require('request');
+const request = require('../../request-shim');
 const errors = require('../../errors');
 const config = require('../../commonConfig');
 const intoTrans = require('../common/domain').intoTrans;

package/lib/services/common/securityServiceOAuth2.js

@@ -26,7 +26,7 @@
 
 /* eslint-disable consistent-return */
 
-const request = require('request');
+const request = require('../../request-shim');
 const queryString = require('query-string');
 const errors = require('../../errors');
 const config = require('../../commonConfig');
@@ -64,7 +64,8 @@ function auth(trust, callback) {
             'Content-Length': formData.length,
             'Content-Type': 'application/x-www-form-urlencoded'
         },
-        body: formData
+        body: formData,
+        responseType: 'text'
     };
 
     logger.debug(context, 'Authentication on the OAuth2 provider [%s]', url);