@frangoteam/fuxa-min 1.1.19

package/runtime/storage/tdengine/index.js

@@ -0,0 +1,106 @@
+'use strict'
+
+let {options, connect} = require("@tdengine/rest");
+let utils = require('../../utils');
+
+function TDengine(_settings, _log, _currentStorage) {
+    let settings = _settings;               // Application settings
+    const logger = _log;                      // Application logger
+    const currentStorage = _currentStorage;  // Database to set the last value (current)
+    const database = settings.daqstore.database || 'fuxa';
+    let conn;
+
+    this.setCall = function (_fncGetProp) {
+        fncGetTagProp = _fncGetProp;
+        return this.addDaqValues;
+    }
+    var fncGetTagProp = null;
+
+    this.init = async function () {
+        let connOpt = Object.assign({}, options, settings.daqstore)
+        connOpt.user = settings.daqstore.credentials.username;
+        connOpt.passwd = settings.daqstore.credentials.password;
+        conn = connect(connOpt);
+        //create database
+        const cursor = conn.cursor();
+        try {
+            //TODO add retention
+            let res = await cursor.query(`CREATE DATABASE IF NOT EXISTS ${database} `);
+            res = await cursor.query(`CREATE STABLE IF NOT EXISTS ${database}.meters (dt TIMESTAMP,tag_id VARCHAR(200), tag_value BINARY(20)) TAGS (device_id VARCHAR(200),device_name BINARY(256) )`);
+
+        } catch (error) {
+            console.error(error);
+        }
+
+    }
+
+    this.addDaqValues = function (tagsValues, deviceName, deviceId) {
+        var dataToRestore = [];
+        const cursor = conn.cursor();
+        for (const tagid in tagsValues) {
+            let tag = tagsValues[tagid];
+            if (!tag.daq || utils.isNullOrUndefined(tag.value) || Number.isNaN(tag.value)) {
+                if (tag.daq.restored) {
+                    dataToRestore.push({id: tag.id, deviceId: deviceId, value: tag.value});
+                }
+                if (!tag.daq.enabled) {
+                    continue;
+                }
+            }
+            let insertSql = `INSERT INTO ${database}.\`${deviceId}\` USING ${database}.meters TAGS('${deviceId}','${deviceName}')
+                             VALUES (NOW, '${tagid}', '${tag.value}')`;
+            //async
+
+            cursor.query(insertSql).then((rst) => {
+                //logger.info("addDaqValues",rst)
+                if (0 !== rst.getErrCode()) {
+                    logger.error(`daq addValue error[${rst.getErrCode()}]: ${rst.getErrStr()}`);
+                }
+            }).catch((err) => {
+                logger.error(`daq addValue error ${err}`);
+            })
+        }
+
+        if (dataToRestore.length && currentStorage) {
+            currentStorage.setValues(dataToRestore);
+        }
+    }
+
+    this.getDaqValue = function (tagid, fromts, tots) {
+        return new Promise(function (resolve, reject) {
+            const cursor = conn.cursor()
+            let data =[]
+            cursor.query(`SELECT CAST(dt as BIGINT) as dt, tag_value
+                          FROM ${database}.meters
+                          WHERE dt >= ${fromts}
+                            and dt < ${tots} `).then((result) => {
+                // logger.debug(result)
+                result.getData().forEach((row) =>{
+                    data.push({dt: row[0],value: row[1]})
+                })
+                resolve(data)
+            }).catch((error) => {
+                logger.error(`TDengine-getDaqValue failed! ${error}`)
+                reject(error)
+            })
+        })
+    }
+
+    this.close = function () {
+        //do noting
+    }
+
+    this.getDaqMap = function (tagid) {
+        var dummy = {};
+        dummy[tagid] = true;
+        return dummy;
+    }
+
+    this.init().then(() => logger.info("TDengine connected"))
+}
+
+module.exports = {
+    create: function (data, logger, currentStorage) {
+        return new TDengine(data, logger, currentStorage);
+    }
+};

package/runtime/users/index.js

@@ -0,0 +1,123 @@
+/*
+* Users manager: read, write, add, remove, ... and save 
+*/
+
+'use strict';
+
+const usrstorage = require('./usrstorage');
+
+const version = '1.00';
+var settings;                   // Application settings
+var logger;                     // Application logger
+
+/**
+ * Init Users resource
+ * @param {*} _settings 
+ * @param {*} log 
+ */
+function init(_settings, log) {
+    settings = _settings;
+    logger = log;
+
+    // Init Users database
+    return new Promise(function (resolve, reject) {
+        usrstorage.init(settings, logger).then(result => {
+            logger.info('users.usrstorage-init successful!', true);
+            if (result) {
+                resolve();
+            } else {
+                usrstorage.setDefault().then(result => {
+                    logger.info('users.usrstorage-set-default successful!', true);
+                    resolve();
+                }).catch(function (err) {
+                    logger.error(`users.usrstorage.set-default failed! ${err}`);
+                    resolve();
+                });
+            }
+        }).catch(function (err) {
+            logger.error(`users.usrstorage-init failed ${err}`);
+            reject(err);
+        });
+    });
+}
+
+/**
+ * Get the users list
+ */
+function getUsers(user) {
+    return new Promise(function (resolve, reject) {
+        usrstorage.getUsers(user).then(drows => {
+            if (drows.length > 0) {
+                resolve(drows);
+            } else {
+                resolve();
+            }
+        }).catch(function (err) {
+            logger.error(`users.usrstorage-get-users-list failed! ${err}`);
+            reject(err);
+        });
+    });
+}
+
+/**
+ * Set the user
+ */
+function setUsers(query) {
+    return new Promise(function (resolve, reject) {
+        if (query.username) {
+            usrstorage.setUser(query.username, query.fullname, query.password, query.groups, query.info).then(() => {
+                resolve();
+            }).catch(function (err) {
+                logger.error(`users.usrstorage-set-users-list failed! ${err}`);
+                reject(err);
+            });
+        } else {
+            reject();
+        }
+    });
+}
+
+/**
+ * Remove the user
+ */
+function removeUsers(username) {
+    return new Promise(function (resolve, reject) {
+        if (username) {
+            usrstorage.removeUser(username).then(() => {
+                resolve();
+            }).catch(function (err) {
+                logger.error(`users.usrstorage-remove-users failed! ${err}`);
+                reject(err);
+            });
+        } else {
+            reject();
+        }
+    });
+}
+
+
+/**
+ * Find the user
+ */
+function findOne(user) {
+    return new Promise(function (resolve, reject) {
+        usrstorage.getUsers(user).then(drows => {
+            if (drows.length > 0) {
+                resolve(drows);
+            } else {
+                resolve();
+            }
+        }).catch(function (err) {
+            logger.error(`users.usrstorage-find-user failed! ${err}`);
+            reject(err);
+        });
+    });
+}
+
+module.exports = {
+    init: init,
+    getUsers: getUsers,
+    setUsers: setUsers,
+    removeUsers: removeUsers,
+    findOne: findOne
+};

package/runtime/users/usrstorage.js

@@ -0,0 +1,201 @@
+/**
+ *  Module to manage the users in a database
+ *  Table: 'users' 
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+var sqlite3 = require('sqlite3').verbose();
+const bcrypt = require('bcryptjs');
+
+var settings        // Application settings
+var logger;         // Application logger
+var db_usr;         // Database of users
+
+/**
+ * Init and bind the database resource
+ * @param {*} _settings 
+ * @param {*} _log 
+ */
+function init(_settings, _log) {
+    settings = _settings;
+    logger = _log;
+
+    return _bind();
+}
+
+/**
+ * Bind the database resource by create the table if not exist
+ */
+function _bind() {
+    return new Promise(function (resolve, reject) {
+        var dbfile = path.join(settings.workDir, 'users.fuxap.db');
+        var dbfileExist = fs.existsSync(dbfile);
+        db_usr = new sqlite3.Database(dbfile, function (err) {
+            if (err) {
+                logger.error(`usrstorage.bind failed! ${err}`);
+                reject();
+            }
+            logger.info(`usrstorage.connected ${dbfile} database`, true);
+        });
+        // prepare query
+        var sql = "CREATE TABLE if not exists users (username TEXT PRIMARY KEY, fullname TEXT, password TEXT, groups INTEGER, info TEXT);";
+        db_usr.exec(sql, function (err) {
+            if (err) {
+                logger.error(`usrstorage.bind failed! ${err}`);
+                reject();
+            } else {
+                const columnsToAdd = [{ name: 'fullname', type: 'TEXT' },
+                { name: 'info', type: 'TEXT' }];
+                _checkUpdate(columnsToAdd).then(() => {
+                    resolve(dbfileExist);
+                }).catch(() => {
+                    resolve(dbfileExist);
+                });
+            }
+        });
+    });
+}
+
+function _checkUpdate(columnsToAdd) {
+    return new Promise(function (resolve, reject) {
+
+        const addColumn = (column, callback) => {
+            const { name, type } = column;
+            const addColumnQuery = `ALTER TABLE users ADD COLUMN ${name} ${type};`;
+
+            db_usr.run(addColumnQuery, err => {
+                if (err) {
+                    if (!err.message.includes('duplicate column name')) {
+                        logger.error(`usrstorage._checkUpdate error! ${err}`);
+                    }
+                }
+                callback();
+            });
+        };
+
+        const addColumnsInSerie = index => {
+            if (index < columnsToAdd.length) {
+                addColumn(columnsToAdd[index], () => {
+                    addColumnsInSerie(index + 1);
+                });
+            } else {
+                resolve();
+            }
+        };
+        addColumnsInSerie(0);
+    });
+}
+
+/**
+ * Set default users value in database (administrator)
+ */
+function setDefault() {
+    return new Promise(function (resolve, reject) {
+        // prepare query
+        var sql = "";
+        sql += "INSERT OR REPLACE INTO users (username, fullname, password, groups) VALUES('admin', 'Administrator Account', '" + bcrypt.hashSync('123456', 10) + "','-1');";
+        db_usr.exec(sql, function (err) {
+            if (err) {
+                logger.error(`usrstorage.set failed! ${err}`);
+                reject();
+            } else {
+                resolve();
+            }
+        });
+    });
+}
+
+/**
+ * Return the Users list
+ */
+function getUsers(user) {
+    return new Promise(function (resolve, reject) {
+        var sql = "SELECT username, fullname, groups, info FROM users";
+        if (user && user.username) {
+            sql = "SELECT username, fullname, password, groups, info FROM users WHERE username = '" + user.username + "'";
+        }
+        db_usr.all(sql, function (err, rows) {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(rows);
+            }
+        });
+    });
+}
+
+/**
+ * Set user value in database
+ */
+function setUser(usr, fullname, pwd, groups, info) {
+    return new Promise(function (resolve, reject) {
+        // prepare query
+        var exist = false;
+        getUsers({ username: usr }).then(function (data) {
+            if (data && data.length) {
+                exist = true;
+            }
+            var sql = "";
+            if (pwd) {
+                sql = "INSERT OR REPLACE INTO users (username, fullname, password, groups, info) VALUES('" + usr + "','" + fullname + "','" + bcrypt.hashSync(pwd, 10) + "','" + groups + "','" + info + "');";
+                if (exist) {
+                    sql = "UPDATE users SET password = '" + bcrypt.hashSync(pwd, 10) + "', info = '" + info + "', groups = '" + groups + "', fullname = '" + fullname + "' WHERE username = '" + usr + "';";
+                }
+            } else {
+                sql = "INSERT OR REPLACE INTO users (username, fullname, groups, info) VALUES('" + usr + "','" + fullname + "','" + groups + "','" + info + "');";
+                if (exist) {
+                    sql = "UPDATE users SET groups = '" + groups + "', info = '" + info + "', fullname = '" + fullname + "' WHERE username = '" + usr + "';";
+                }
+            }
+            db_usr.exec(sql, function (err) {
+                if (err) {
+                    logger.error(`usrstorage.set failed! ${err}`);
+                    reject();
+                } else {
+                    resolve();
+                }
+            });
+        }).catch(function (err) {
+            reject();
+        });
+    });
+}
+
+/**
+ * Remove user from database
+ */
+function removeUser(usr) {
+    return new Promise(function (resolve, reject) {
+        // prepare query
+        var sql = "DELETE FROM users WHERE username = '" + usr + "'";
+        db_usr.exec(sql, function (err) {
+            if (err) {
+                logger.error(`usrstorage.remove failed! ${err}`);
+                reject();
+            } else {
+                resolve();
+            }
+        });
+    });
+}
+
+/**
+ * Close the database
+ */
+function close() {
+    if (db_usr) {
+        db_usr.close();
+    }
+}
+
+module.exports = {
+    init: init,
+    close: close,
+    setDefault: setDefault,
+    getUsers: getUsers,
+    setUser: setUser,
+    removeUser: removeUser
+};

package/runtime/utils.js

@@ -0,0 +1,284 @@
+const os = require('os');
+const ip = require('ip');
+
+'use strict';
+var utils = module.exports = {
+
+    SMALLEST_NEGATIVE_INTEGER: -9007199254740991,
+
+    domStringSplitter: function (src, tagsplitter, first) {
+        var result = { before: '', tagcontent: '', after: '' };
+        var tagStart = '<' + tagsplitter.toLowerCase();
+        var tagEnd = '</' + tagsplitter.toLowerCase(); 
+        var text = src.toLowerCase();
+        var start = text.indexOf(tagStart, first);
+        var end = text.indexOf(tagEnd, start);
+        result.before = src.slice(0, start);
+        result.tagcontent = src.slice(start, end);
+        result.after = src.slice(end);
+        return result;
+    },
+
+    domStringSetAttribute: function (src, tags, attribute) {
+        var result = src;
+        for (var i = 0; i < tags.length; i++) {
+            var text = result.toLowerCase();
+            var tagStart = '<' + tags[i].toLowerCase();
+            var pos = 0;
+            var temp  = '';
+            while((pos = text.indexOf(tagStart, pos)) !== -1) {
+                pos += tagStart.length + 1;
+                temp += src.slice(0, pos) + attribute + ' ' + src.slice(pos);
+            }
+            if (temp.length) {
+                result = temp;
+            }
+        }
+        return result;
+    },
+
+    /**
+    * Return available interface to use
+    */
+    getHostInterfaces: function() {
+        return new Promise(function (resolve, reject) {
+            try {
+                let nics = [];
+                const osNics = os.networkInterfaces();
+                nics.push({ name: 'Default' });
+                Object.keys(osNics).forEach((ifname) => {
+                    osNics[ifname].forEach((iface) => {
+                        if (iface.interal === true) return;
+                        if (iface.family !== 'IPv4') return;
+                        nics.push({
+                            name: ifname,
+                            address: iface.address,
+                            broadcast: ip.subnet(iface.address, iface.netmask).broadcastAddress
+                        });
+                    });
+                });
+                resolve(nics);
+            } catch (err) {
+                reject('gethostinterfaces-error: ' + err);
+            }
+        });
+    },
+
+    endTime: function (startTime) {
+        var endTime = new Date();
+        return endTime - startTime;
+    },
+
+    isEmptyObject: function (value) {
+        return value && Object.keys(value).length === 0 && value.constructor === Object;
+    },
+
+    isObject(value) {
+        var type = typeof value;
+        return !!value && (type == 'object' || type == 'function');
+    },
+
+    isBoolean(value) {
+        return (typeof value === 'boolean');
+    },
+
+    isPlainObject(value) {
+        var Ctor;
+        if (!(isObjectLike(value) && objToString.call(value) == objectTag && !isHostObject(value) && !isArguments(value)) ||
+            (!hasOwnProperty.call(value, 'constructor') && (Ctor = value.constructor, typeof Ctor == 'function' && !(Ctor instanceof Ctor)))) {
+          return false;
+        }
+        var result;
+        if (lodash.support.ownLast) {
+          baseForIn(value, function(subValue, key, object) {
+            result = hasOwnProperty.call(object, key);
+            return false;
+          });
+          return result !== false;
+        }
+        baseForIn(value, function(subValue, key) {
+          result = key;
+        });
+        return result === undefined || hasOwnProperty.call(value, result);
+    },
+
+    isNullOrUndefined: function (ele) {
+        return (ele === null || ele === undefined) ? true : false;
+    },
+
+    JsonTryToParse(value) {
+        try {
+            if (value) {
+                return JSON.parse(value);
+            }    
+        } catch { }
+    },
+
+    mergeObjectsValues: function (obj1, obj2) {
+        if (typeof obj1 === 'object' && typeof obj2 === 'object') {
+            for (let key in obj2) {
+                if (obj1.hasOwnProperty(key)) {
+                    obj1[key] = obj2[key];
+                }
+            }
+        }    
+        return obj1;
+    },
+
+    dayOfYear: function (date) {
+        if (date) {
+            return Math.floor((date - new Date(date.getFullYear(), 0, 0)) / 1000 / 60 / 60 / 24);
+        }
+        return -1;
+    },
+
+    getDate: function (dt) {
+        var yyyy = dt.getFullYear();
+        var mm = dt.getMonth() + 1;
+        var dd = dt.getDate();
+        if (dd < 10) {
+            dd = '0' + dd;
+        }
+        if (mm < 10) {
+            mm = '0' + mm;
+        }
+        var HH = dt.getHours();
+        var MM = dt.getMinutes();
+        var SS = dt.getSeconds();
+        if (HH < 10) {
+            HH = '0' + HH;
+        }
+        if (MM < 10) {
+            MM = '0' + MM;
+        }
+        if (SS < 10) {
+            SS = '0' + SS;
+        }
+        return `${yyyy}-${mm}-${dd}_${HH}-${MM}-${SS}`;
+    },
+
+    getFormatDate: function (dt, format) {
+        var yyyy = dt.getFullYear();
+        var mm = dt.getMonth() + 1;
+        var dd = dt.getDate();
+        if (dd < 10) {
+            dd = '0' + dd;
+        }
+        if (mm < 10) {
+            mm = '0' + mm;
+        }
+        var HH = dt.getHours();
+        var MM = dt.getMinutes();
+        var SS = dt.getSeconds();
+        if (HH < 10) {
+            HH = '0' + HH;
+        }
+        if (MM < 10) {
+            MM = '0' + MM;
+        }
+        if (SS < 10) {
+            SS = '0' + SS;
+        }
+        if (format === 'ymd') {
+            return `${yyyy}/${mm}/${dd}/ ${HH}:${MM}:${SS}`;
+        }
+        return `${dd}/${mm}/${yyyy} ${HH}:${MM}:${SS}`;
+    },
+
+    isNumber: function(n, v = {value: null}) {
+        if (typeof n === 'number') {
+            v.value = n;
+            return true;
+        } else {
+            var num = Number(n);
+            if (isNaN(num)) {
+                return false;
+            }
+            num = parseFloat(n);
+            if (isNaN(num)) {
+                return false;
+            }
+            v.value = num;
+            return true;
+        }
+    },
+
+    isFloat: function (n) {
+        return Number(n) === n && n % 1 !== 0;
+    },
+
+    parseFloat: function (value, decimals) {
+        if (this.isFloat(value)) {
+            return parseFloat(value.toFixed(decimals));
+        } else {
+            return parseFloat(value);
+        }
+    },
+
+    isValidRange: function (min, max) {
+        if (this.isNumber(min) && this.isNumber(max)) {
+            return true;
+        }
+        return false;
+    },
+
+    chunkArray: function (array, chunkSize) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += chunkSize) {
+          chunks.push(array.slice(i, i + chunkSize));
+        }
+        return chunks;
+    },
+
+    extractArray: function (object) {
+        let index = 0;
+        const array = [];
+        
+        while (object[index] !== undefined) {
+            array.push(object[index]);
+            index++;
+        }
+        return array;
+    },
+
+    getNetworkInterfaces: function () {
+        const interfaces = os.networkInterfaces();
+        var result = [];
+        Object.keys(interfaces).forEach((interfaceName) => {
+            interfaces[interfaceName].forEach((iface) => {
+                if (iface.interal === true) return;
+                if (iface.family !== 'IPv4') return;
+                result.push(iface.address);
+            });
+        });
+        return result;
+    },
+
+    getRetentionLimit: function(retention) {
+        var dayToAdd = 0;
+        if (retention === 'day1') {
+            dayToAdd = 1;
+        } else if (retention === 'days2') {
+            dayToAdd = 2;
+        } else if (retention === 'days3') {
+            dayToAdd = 3;
+        } else if (retention === 'days7') {
+            dayToAdd = 7;
+        } else if (retention === 'days14') {
+            dayToAdd = 14;
+        } else if (retention === 'days30') {
+            dayToAdd = 30;
+        } else if (retention === 'days90') {
+            dayToAdd = 90;
+        } else if (retention === 'year1') {
+            dayToAdd = 365;
+        } else if (retention === 'year3') {
+            dayToAdd = 365 * 3;
+        } else if (retention === 'year5') {
+            dayToAdd = 365 * 5;
+        }
+        const date = new Date();
+        date.setDate(date.getDate() - dayToAdd);
+        return date;
+    }
+}