iotagent-node-lib 4.6.0 → 4.8.0

package/lib/services/devices/deviceRegistryMongoDB.js

@@ -22,7 +22,7 @@
  */
 
 const logger = require('logops');
-const dbService = require('../../model/dbConn');
+const mongoose = require('mongoose');
 const config = require('../../commonConfig');
 const fillService = require('./../common/domain').fillService;
 const alarmsInt = require('../common/alarmManagement').intercept;
@@ -57,27 +57,11 @@ const attributeList = [
     'explicitAttrs',
     'ngsiVersion',
     'subscriptions',
-    'payloadType'
+    'payloadType',
+    'useCBflowControl',
+    'storeLastMeasure'
 ];
 
-/**
- * Generates a handler for the save device operations. The handler will take the customary error and the saved device
- * as the parameters (and pass the serialized DAO as the callback value).
- *
- * @return {Function}       The generated handler.
- */
-function saveDeviceHandler(callback) {
-    return function saveHandler(error, deviceDAO) {
-        if (error) {
-            logger.debug(fillService(context, deviceDAO), 'Error storing device information: %s', error);
-
-            callback(new errors.InternalDbError(error));
-        } else {
-            callback(null, deviceDAO.toObject());
-        }
-    };
-}
-
 /**
  * Create a new register for a device. The device object should contain the id, type and registrationId
  *
@@ -97,21 +81,22 @@ function storeDevice(newDevice, callback) {
 
     logger.debug(context, 'Storing device with id [%s] and type [%s]', newDevice.id, newDevice.type);
 
-    deviceObj.save(function saveHandler(error, deviceDAO) {
-        if (error) {
+    deviceObj
+        .save({})
+        .then((deviceDAO) => {
+            callback(null, deviceDAO.toObject());
+        })
+        .catch((error) => {
             if (error.code === 11000) {
                 logger.debug(context, 'Tried to insert a device with duplicate ID in the database: %s', error);
 
-                callback(new errors.DuplicateDeviceId(newDevice));
+                callback(new errors.DuplicateDeviceId(newDevice), newDevice);
             } else {
                 logger.debug(context, 'Error storing device information: %s', error);
 
                 callback(new errors.InternalDbError(error));
             }
-        } else {
-            callback(null, deviceDAO.toObject());
-        }
-    });
+        });
 }
 
 /**
@@ -132,17 +117,17 @@ function removeDevice(id, apikey, service, subservice, callback) {
     }
     logger.debug(context, 'Removing device with id [%s]', id);
 
-    Device.model.deleteOne(condition, function (error) {
-        if (error) {
-            logger.debug(context, 'Internal MongoDB Error getting device: %s', error);
-
-            callback(new errors.InternalDbError(error));
-        } else {
+    const query = Device.model.deleteOne(condition);
+    query
+        .exec({})
+        .then(() => {
             logger.debug(context, 'Device [%s] successfully removed.', id);
-
             callback(null);
-        }
-    });
+        })
+        .catch((error) => {
+            logger.debug(context, 'Internal MongoDB Error getting device: %s', error);
+            callback(new errors.InternalDbError(error));
+        });
 }
 
 /**
@@ -170,7 +155,7 @@ function listDevices(type, service, subservice, limit, offset, callback) {
     }
 
     const query = Device.model.find(condition).sort();
-
+    const queryCount = Device.model.countDocuments(condition);
     if (limit) {
         query.limit(parseInt(limit, 10));
     }
@@ -179,36 +164,55 @@ function listDevices(type, service, subservice, limit, offset, callback) {
         query.skip(parseInt(offset, 10));
     }
 
-    async.series(
-        [query.exec.bind(query), Device.model.countDocuments.bind(Device.model, condition)],
-        function (error, results) {
-            callback(error, {
-                count: results[1],
-                devices: results[0]
+    function funcQuery(cb) {
+        query
+            .exec({})
+            .then((res) => {
+                cb(null, res);
+            })
+            .catch((error) => {
+                cb(error);
             });
-        }
-    );
+    }
+    function funcQueryCount(cb) {
+        queryCount
+            .exec({})
+            .then((res) => {
+                cb(null, res);
+            })
+            .catch((error) => {
+                cb(error);
+            });
+    }
+    async.series([funcQuery, funcQueryCount], function (error, results) {
+        callback(error, {
+            count: results[1],
+            devices: results[0]
+        });
+    });
 }
 
 function findOneInMongoDB(queryParams, id, callback) {
     const query = Device.model.findOne(queryParams);
     query.select({ __v: 0 });
-
-    query.lean().exec(function handleGet(error, data) {
-        if (error) {
+    query.lean();
+
+    query
+        .exec({})
+        .then((data) => {
+            if (data) {
+                context = fillService(context, data);
+                logger.debug(context, 'Device data found: %j', data);
+                callback(null, data);
+            } else {
+                logger.debug(context, 'Device [%s] not found.', id);
+                callback(new errors.DeviceNotFound(id, queryParams));
+            }
+        })
+        .catch((error) => {
             logger.debug(context, 'Internal MongoDB Error getting device: %s', error);
-
             callback(new errors.InternalDbError(error));
-        } else if (data) {
-            context = fillService(context, data);
-            logger.debug(context, 'Device data found: %j', data);
-            callback(null, data);
-        } else {
-            logger.debug(context, 'Device [%s] not found.', id);
-
-            callback(new errors.DeviceNotFound(id, queryParams));
-        }
-    });
+        });
 }
 
 /**
@@ -220,7 +224,7 @@ function findOneInMongoDB(queryParams, id, callback) {
  * @param {String} subservice   Division inside the service (optional).
  */
 function getDeviceById(id, apikey, service, subservice, callback) {
-    let queryParams = {
+    const queryParams = {
         id,
         service,
         subservice
@@ -252,9 +256,9 @@ function getDevice(id, apikey, service, subservice, callback) {
 
 function getByNameAndType(name, type, service, servicepath, callback) {
     context = fillService(context, { service, subservice: servicepath });
-    let optionsQuery = {
-        name: name,
-        service: service,
+    const optionsQuery = {
+        name,
+        service,
         subservice: servicepath
     };
     if (type) {
@@ -264,20 +268,23 @@ function getByNameAndType(name, type, service, servicepath, callback) {
     const query = Device.model.findOne(optionsQuery);
 
     query.select({ __v: 0 });
-
-    query.lean().exec(function handleGet(error, data) {
-        if (error) {
+    query.lean();
+    query
+        .exec({})
+        .then((data) => {
+            if (data) {
+                context = fillService(context, data);
+                logger.debug(context, 'Device data found: %j', data);
+                callback(null, data);
+            } else {
+                logger.debug(context, 'Device [%s] not found.', name);
+                callback(new errors.DeviceNotFound(name, optionsQuery));
+            }
+        })
+        .catch((error) => {
             logger.debug(context, 'Internal MongoDB Error getting device: %s', error);
-
             callback(new errors.InternalDbError(error));
-        } else if (data) {
-            callback(null, data);
-        } else {
-            logger.debug(context, 'Device [%s] not found.', name);
-
-            callback(new errors.DeviceNotFound(name, optionsQuery));
-        }
-    });
+        });
 }
 
 function getByName(name, service, servicepath, callback) {
@@ -314,11 +321,22 @@ function update(previousDevice, device, callback) {
             data.timestamp = device.timestamp;
             data.subscriptions = device.subscriptions;
             data.payloadType = device.payloadType;
+            data.useCBflowControl = device.useCBflowControl;
+            data.storeLastMeasure = device.storeLastMeasure;
+            data.lastMeasure = device.lastMeasure;
 
             /* eslint-disable-next-line  new-cap */
             const deviceObj = new Device.model(data);
             deviceObj.isNew = false;
-            deviceObj.save(saveDeviceHandler(callback));
+            deviceObj
+                .save({})
+                .then((deviceDAO) => {
+                    callback(null, deviceDAO.toObject());
+                })
+                .catch((error) => {
+                    logger.debug(fillService(context, device), 'Error storing device information: %s', error);
+                    callback(new errors.InternalDbError(error));
+                });
         }
     });
 }
@@ -327,7 +345,14 @@ function update(previousDevice, device, callback) {
  * Cleans all the information in the database, leaving it in a clean state.
  */
 function clear(callback) {
-    dbService.db.db.dropDatabase(callback);
+    mongoose.connection
+        .dropDatabase()
+        .then(() => {
+            callback(null);
+        })
+        .catch((error) => {
+            callback(error);
+        });
 }
 
 function itemToObject(i) {
@@ -355,24 +380,72 @@ function getDevicesByAttribute(name, value, service, subservice, callback) {
 
     const query = Device.model.find(filter);
     query.select({ __v: 0 });
-
-    query.exec(function handleGet(error, devices) {
-        if (error) {
+    query.lean();
+    query
+        .exec({})
+        .then((devices) => {
+            if (devices) {
+                callback(null, devices.map(itemToObject));
+            } else {
+                logger.debug(context, 'Device [%s] not found.', name);
+                callback(new errors.DeviceNotFound(name, filter));
+            }
+        })
+        .catch((error) => {
             logger.debug(context, 'Internal MongoDB Error getting device: %s', error);
-
             callback(new errors.InternalDbError(error));
-        } else if (devices) {
-            callback(null, devices.map(itemToObject));
-        } else {
-            logger.debug(context, 'Device [%s] not found.', name);
+        });
+}
 
-            callback(new errors.DeviceNotFound(name, filter));
-        }
-    });
+function storeDeviceField(fieldName, fieldValue, typeInformation, callback) {
+    if (
+        typeInformation &&
+        typeInformation.id &&
+        typeInformation.apikey &&
+        typeInformation.service &&
+        typeInformation.subservice
+    ) {
+        getDevice(
+            typeInformation.id,
+            typeInformation.apikey,
+            typeInformation.service,
+            typeInformation.subservice,
+            function (error, data) {
+                if (error) {
+                    callback(error);
+                } else {
+                    if (fieldName === 'lastMeasure') {
+                        data.lastMeasure = { timestamp: new Date().toISOString(), measure: fieldValue };
+                    } else {
+                        data[fieldName] = fieldValue;
+                    }
+                    /* eslint-disable-next-line  new-cap */
+                    const deviceObj = new Device.model(data);
+                    deviceObj.isNew = false;
+                    deviceObj
+                        .save({})
+                        .then((deviceDao) => {
+                            callback(null, deviceDao.toObject());
+                        })
+                        .catch((error) => {
+                            logger.debug(
+                                fillService(context, deviceObj),
+                                'Error storing device information: %s',
+                                error
+                            );
+                            callback(new errors.InternalDbError(error));
+                        });
+                }
+            }
+        );
+    } else {
+        callback(null, null);
+    }
 }
 
 exports.getDevicesByAttribute = alarmsInt(constants.MONGO_ALARM, getDevicesByAttribute);
 exports.store = alarmsInt(constants.MONGO_ALARM, storeDevice);
+exports.storeDeviceField = alarmsInt(constants.MONGO_ALARM, storeDeviceField);
 exports.update = alarmsInt(constants.MONGO_ALARM, update);
 exports.remove = alarmsInt(constants.MONGO_ALARM, removeDevice);
 exports.list = alarmsInt(constants.MONGO_ALARM, listDevices);

package/lib/services/devices/deviceService.js

@@ -40,6 +40,8 @@ const registrationUtils = require('./registrationUtils');
 const subscriptions = require('../ngsi/subscriptionService');
 const expressionPlugin = require('./../../plugins/expressionPlugin');
 const pluginUtils = require('./../../plugins/pluginUtils');
+const alarms = require('../common/alarmManagement');
+const constants = require('../../constants');
 const _ = require('underscore');
 const context = {
     op: 'IoTAgentNGSI.DeviceService'
@@ -179,6 +181,12 @@ function mergeDeviceWithConfiguration(fields, defaults, deviceData, configuratio
     if (configuration && configuration.payloadType !== undefined && deviceData.payloadType === undefined) {
         deviceData.payloadType = configuration.payloadType;
     }
+    if (configuration && configuration.useCBflowControl !== undefined && deviceData.useCBflowControl === undefined) {
+        deviceData.useCBflowControl = configuration.useCBflowControl;
+    }
+    if (configuration && configuration.storeLastMeasure !== undefined && deviceData.storeLastMeasure === undefined) {
+        deviceData.storeLastMeasure = configuration.storeLastMeasure;
+    }
     logger.debug(context, 'deviceData after merge with conf: %j', deviceData);
     callback(null, deviceData);
 }
@@ -244,7 +252,7 @@ function registerDevice(deviceObj, callback) {
             /* eslint-disable-next-line no-unused-vars */
             function (error, device) {
                 if (!error) {
-                    innerCb(new errors.DuplicateDeviceId(deviceObj));
+                    innerCb(new errors.DuplicateDeviceId(deviceObj), device);
                 } else {
                     innerCb();
                 }
@@ -277,7 +285,20 @@ function registerDevice(deviceObj, callback) {
                 deviceData.ngsiVersion = configuration.ngsiVersion;
             }
         }
-
+        // Set polling and transport for autoprovisioned devices
+        if (!deviceData.transport && config.getConfig().defaultTransport) {
+            deviceData.transport =
+                configuration && configuration.transport
+                    ? configuration.transport
+                    : config.getConfig().defaultTransport;
+        }
+        if (deviceData.transport === 'HTTP') {
+            if (deviceData.endpoint) {
+                deviceData.polling = false;
+            } else {
+                deviceData.polling = !(configuration && configuration.endpoint);
+            }
+        }
         if (!deviceData.name) {
             let entityName = null;
             if (configuration && configuration.entityNameExp !== undefined && configuration.entityNameExp !== '') {
@@ -285,7 +306,7 @@ function registerDevice(deviceObj, callback) {
                 let attrList = pluginUtils.getIdTypeServSubServiceFromDevice(deviceData);
                 attrList = deviceData.staticAttributes ? attrList.concat(deviceData.staticAttributes) : attrList;
                 attrList = configuration.staticAttributes ? attrList.concat(configuration.staticAttributes) : attrList;
-                let ctxt = expressionPlugin.extractContext(attrList);
+                const ctxt = expressionPlugin.extractContext(attrList);
                 try {
                     entityName = expressionPlugin.applyExpression(configuration.entityNameExp, ctxt, deviceData);
                 } catch (e) {
@@ -357,6 +378,12 @@ function registerDevice(deviceObj, callback) {
                     if ('apikey' in deviceData && deviceData.apikey !== undefined) {
                         deviceObj.apikey = deviceData.apikey;
                     }
+                    if ('transport' in deviceData && deviceData.transport !== undefined) {
+                        deviceObj.transport = deviceData.transport;
+                    }
+                    if ('polling' in deviceData && deviceData.polling !== undefined) {
+                        deviceObj.polling = deviceData.polling;
+                    }
                     logger.debug(context, 'Storing device :\n%s', JSON.stringify(deviceObj, null, 4));
                     config.getRegistry().store(deviceObj, callback);
                 }
@@ -616,7 +643,7 @@ function findOrCreate(deviceId, apikey, group, callback) {
         } else if (error.name === 'DEVICE_NOT_FOUND') {
             const newDevice = {
                 id: deviceId,
-                apikey: apikey,
+                apikey,
                 service: group.service,
                 subservice: group.subservice,
                 type: group.type
@@ -639,7 +666,14 @@ function findOrCreate(deviceId, apikey, group, callback) {
             if (group.autoprovision === undefined || group.autoprovision === true) {
                 logger.debug(context, 'Registering autoprovision of Device %j for its conf %j', newDevice, group);
                 registerDevice(newDevice, function (error, device) {
-                    callback(error, device, group);
+                    if (error && error.name === 'DUPLICATE_DEVICE_ID') {
+                        alarms.release(constants.MONGO_ALARM, error);
+                        logger.warn(context, 'Error %j already registered autoprovisioned device: %j ', error, device);
+                        callback(null, device, group);
+                    } else {
+                        logger.debug(context, 'registered autoprovisioned device: %j ', device);
+                        callback(error, device, group);
+                    }
                 });
             } else {
                 logger.info(
@@ -692,6 +726,10 @@ function retrieveDevice(deviceId, apiKey, callback) {
     }
 }
 
+function storeDeviceField(fieldName, fieldValue, typeInformation, callback) {
+    config.getRegistry().storeDeviceField(fieldName, fieldValue, typeInformation, callback);
+}
+
 exports.listDevices = intoTrans(context, checkRegistry)(listDevices);
 exports.listDevicesWithType = intoTrans(context, checkRegistry)(listDevicesWithType);
 exports.getDevice = intoTrans(context, checkRegistry)(getDevice);
@@ -708,4 +746,5 @@ exports.retrieveDevice = intoTrans(context, checkRegistry)(retrieveDevice);
 exports.mergeDeviceWithConfiguration = mergeDeviceWithConfiguration;
 exports.findOrCreate = findOrCreate;
 exports.findConfigurationGroup = findConfigurationGroup;
+exports.storeDeviceField = storeDeviceField;
 exports.init = init;

package/lib/services/devices/devices-NGSI-v2.js

@@ -285,7 +285,12 @@ function updateRegisterDeviceNgsi2(deviceObj, previousDevice, entityInfoUpdated,
             if ('transport' in newDevice && newDevice.transport !== undefined) {
                 oldDevice.transport = newDevice.transport;
             }
-
+            if ('useCBflowControl' in newDevice && newDevice.useCBflowControl !== undefined) {
+                oldDevice.useCBflowControl = newDevice.useCBflowControl;
+            }
+            if ('storeLastMeasure' in newDevice && newDevice.storeLastMeasure !== undefined) {
+                oldDevice.storeLastMeasure = newDevice.storeLastMeasure;
+            }
             callback(null, oldDevice);
         } else {
             callback(new errors.DeviceNotFound(newDevice.id, newDevice));