iotagent-node-lib 4.6.0 → 4.7.0

package/lib/services/commands/commandRegistryMongoDB.js

@@ -22,7 +22,7 @@
  */
 
 const logger = require('logops');
-const dbService = require('../../model/dbConn');
+const mongoose = require('mongoose');
 const intoTrans = require('../common/domain').intoTrans;
 const errors = require('../../errors');
 const Command = require('../../model/Command');
@@ -45,24 +45,26 @@ function findCommand(service, subservice, deviceId, name, callback) {
 
     query.select({ __v: 0 });
 
-    query.exec(function handleGet(error, data) {
-        if (error) {
+    query
+        .exec({})
+        .then((data) => {
+            if (data) {
+                callback(null, data);
+            } else {
+                logger.debug(
+                    context,
+                    'Command for DeviceID [%j] with name [%j] not found with [%j]',
+                    deviceId,
+                    name,
+                    queryObj
+                );
+                callback(new errors.CommandNotFound(name, queryObj));
+            }
+        })
+        .catch((error) => {
             logger.debug(context, 'Internal MongoDB Error getting command: %s', error);
-
             callback(new errors.InternalDbError(error));
-        } else if (data) {
-            callback(null, data);
-        } else {
-            logger.debug(
-                context,
-                'Command for DeviceID [%j] with name [%j] not found with [%j]',
-                deviceId,
-                name,
-                queryObj
-            );
-            callback(new errors.CommandNotFound(name, queryObj));
-        }
-    });
+        });
 }
 
 function updateCommand(service, subservice, deviceId, command, callback) {
@@ -72,9 +74,14 @@ function updateCommand(service, subservice, deviceId, command, callback) {
         } else {
             commandDAO.value = command.value;
 
-            commandDAO.save(function (error) {
-                callback(error, commandDAO.toObject());
-            });
+            commandDAO
+                .save({})
+                .then((commandDAOs) => {
+                    callback(null, commandDAOs.toObject());
+                })
+                .catch((error) => {
+                    callback(error);
+                });
         }
     });
 }
@@ -94,15 +101,15 @@ function createCommand(service, subservice, deviceId, command, callback) {
 
     logger.debug(context, 'Storing command for deviceId [%s] with name [%s]', deviceId, command.name);
 
-    commandObj.save(function saveHandler(error, commandDAO) {
-        if (error) {
+    commandObj
+        .save({})
+        .then((commandDAO) => {
+            callback(null, commandDAO.toObject());
+        })
+        .catch((error) => {
             logger.debug(context, 'Error storing command information: %s', error);
-
             callback(new errors.InternalDbError(error));
-        } else {
-            callback(null, commandDAO.toObject());
-        }
-    });
+        });
 }
 
 function addCommand(service, subservice, deviceId, command, callback) {
@@ -129,16 +136,33 @@ function listCommands(service, subservice, deviceId, callback) {
     condition.deviceId = deviceId;
 
     const query = Command.model.find(condition).sort();
-
-    async.series(
-        [query.exec.bind(query), Command.model.countDocuments.bind(Command.model, condition)],
-        function (error, results) {
-            callback(error, {
-                count: results[1],
-                commands: results[0].map(toObjectFn)
+    const queryCount = Command.model.countDocuments(condition);
+    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],
+            commands: results[0].map(toObjectFn)
+        });
+    });
 }
 
 function remove(service, subservice, deviceId, name, callback) {
@@ -155,26 +179,29 @@ function remove(service, subservice, deviceId, name, callback) {
         if (error) {
             callback(error);
         } else {
-            Command.model.deleteOne({ _id: command._id }, function (error, commandResult) {
-                if (error) {
+            const query = Command.model.deleteOne({ _id: command._id });
+            query
+                .exec({})
+                .then((commandResult) => {
+                    if (commandResult && commandResult.result && commandResult.result.n === 1) {
+                        logger.debug(context, 'Command [%s] successfully removed.', name);
+
+                        callback(null, commandResult);
+                    } else {
+                        const deviceInfo = {
+                            service,
+                            subservice,
+                            deviceId,
+                            name
+                        };
+                        logger.debug(context, 'Command [%s] not found for removal with %j', name, deviceInfo);
+                        callback(new errors.CommandNotFound(name, deviceInfo));
+                    }
+                })
+                .catch((error) => {
                     logger.debug(context, 'Internal MongoDB Error getting command: %s', error);
-
                     callback(new errors.InternalDbError(error));
-                } else if (commandResult && commandResult.result && commandResult.result.n === 1) {
-                    logger.debug(context, 'Command [%s] successfully removed.', name);
-
-                    callback(null, commandResult);
-                } else {
-                    const deviceInfo = {
-                        service,
-                        subservice,
-                        deviceId,
-                        name
-                    };
-                    logger.debug(context, 'Command [%s] not found for removal with %j', name, deviceInfo);
-                    callback(new errors.CommandNotFound(name, deviceInfo));
-                }
-            });
+                });
         }
     });
 }
@@ -190,35 +217,48 @@ function listToObject(commandList) {
 }
 
 function removeFromDate(creationDate, callback) {
-    const query = { creationDate: { $lt: creationDate } };
+    const condition = { creationDate: { $lt: creationDate } };
 
     if (Command.model) {
-        Command.model.find(query).exec(function (error, commandList) {
-            if (!error && commandList && commandList.length > 0) {
-                Command.model.deleteOne(query, function (error) {
-                    if (error) {
-                        logger.debug(context, 'Internal MongoDB Error removing expired commands: %s', error);
-
-                        callback(new errors.InternalDbError(error));
-                    } else {
-                        logger.debug(
-                            context,
-                            'Expired commands successfully removed from MongoDB for date [%s]',
-                            creationDate
-                        );
-
-                        callback(null, listToObject(commandList));
-                    }
-                });
-            }
-        });
+        const query = Command.model.find(condition);
+        query
+            .exec({})
+            .then((commandList) => {
+                if (commandList && commandList.length > 0) {
+                    const queryDel = Command.model.deleteOne(condition);
+                    queryDel
+                        .exec({})
+                        .then(() => {
+                            logger.debug(
+                                context,
+                                'Expired commands successfully removed from MongoDB for date [%s]',
+                                creationDate
+                            );
+                            callback(null, listToObject(commandList));
+                        })
+                        .catch((error) => {
+                            logger.debug(context, 'Internal MongoDB Error removing expired commands: %s', error);
+                            callback(new errors.InternalDbError(error));
+                        });
+                }
+            })
+            .catch((error) => {
+                logger.debug(context, 'Internal MongoDB Error looking for expired commands: %s', error);
+            });
     } else {
         callback(null, []);
     }
 }
 
 function clear(callback) {
-    dbService.db.db.dropDatabase(callback);
+    mongoose.connection
+        .dropDatabase()
+        .then(() => {
+            callback(null);
+        })
+        .catch((error) => {
+            callback(error);
+        });
 }
 
 function init(newConfig, callback) {

package/lib/services/common/iotManagerService.js

@@ -63,7 +63,9 @@ function register(callback) {
             entityNameExp: service.entityNameExp,
             payloadType: service.payloadType,
             endpoint: service.endpoint,
-            transport: service.transport
+            transport: service.transport,
+            useCBflowControl: service.useCBflowControl,
+            storeLastMeasure: service.storeLastMeasure
         };
     }
 

package/lib/services/devices/deviceRegistryMemory.js

@@ -210,8 +210,44 @@ function getDevicesByAttribute(name, value, service, subservice, callback) {
     }
 }
 
+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) {
+                    if (data) {
+                        if (fieldName === 'lastMeasure') {
+                            data.lastMeasure = { timestamp: new Date().toISOString(), measure: fieldValue };
+                        } else {
+                            data[fieldName] = fieldValue;
+                        }
+                    }
+                    if (callback) {
+                        callback(null, data);
+                    }
+                } else {
+                    callback(error, null);
+                }
+            }
+        );
+    } else {
+        callback(null, null);
+    }
+}
+
 exports.getDevicesByAttribute = getDevicesByAttribute;
 exports.store = storeDevice;
+exports.storeDeviceField = storeDeviceField;
 exports.update = update;
 exports.remove = removeDevice;
 exports.list = listDevices;

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,8 +81,12 @@ 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);
 
@@ -108,10 +96,7 @@ function storeDevice(newDevice, callback) {
 
                 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);