@frangoteam/fuxa-min 1.1.19

package/runtime/project/prjstorage.js

@@ -0,0 +1,222 @@
+/**
+ *  Module to manage the project datastore in a database
+ *  Table: 'general', 'views', 'devices', 'chart' 
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+var sqlite3 = require('sqlite3').verbose();
+
+var settings        // Application settings
+var logger;         // Application logger
+var db_prj;         // Database of project
+
+/**
+ * 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, 'project.fuxap.db');
+        var dbfileExist = fs.existsSync(dbfile);
+        db_prj = new sqlite3.Database(dbfile, function (err) {
+            if (err) {
+                logger.error(`prjstorage.bind failed! ${err}`);
+                reject();
+            }
+            logger.info(`prjstorage.connected-to ${dbfile} database`, true);
+        });
+        // prepare query
+        var sql = "CREATE TABLE if not exists general (name TEXT PRIMARY KEY, value TEXT);";
+        sql += "CREATE TABLE if not exists views (name TEXT PRIMARY KEY, value TEXT);";
+        sql += "CREATE TABLE if not exists devices (name TEXT PRIMARY KEY, value TEXT, connection TEXT, cntid TEXT, cntpwd TEXT);";
+        sql += "CREATE TABLE if not exists devicesSecurity (name TEXT PRIMARY KEY, value TEXT);";
+        sql += "CREATE TABLE if not exists texts (name TEXT PRIMARY KEY, value TEXT);";
+        sql += "CREATE TABLE if not exists alarms (name TEXT PRIMARY KEY, value TEXT);";
+        sql += "CREATE TABLE if not exists notifications (name TEXT PRIMARY KEY, value TEXT);";
+        sql += "CREATE TABLE if not exists scripts (name TEXT PRIMARY KEY, value TEXT);";
+        sql += "CREATE TABLE if not exists reports (name TEXT PRIMARY KEY, value TEXT);";
+        db_prj.exec(sql, function (err) {
+            if (err) {
+                logger.error(`prjstorage.bind failed! ${err}`);
+                reject();
+            } else {
+                resolve(dbfileExist);
+            }
+        });  
+    });
+} 
+
+/**
+ * Set default project value in database
+ */
+function setDefault() {
+    return new Promise(function (resolve, reject) {
+        var scs = [];
+        scs.push({ table: TableType.GENERAL, name: 'version', value: '1.00' });
+        scs.push({ table: TableType.DEVICES, name: 'server', value: { 'id': '0', 'name': 'FUXA Server', 'type': 'FuxaServer', 'property': {} } });
+        setSections(scs).then(() => {
+            resolve();
+        }).catch(function (err) {
+            reject(err);
+        });
+    });
+}
+
+/**
+ * Insert the list of values in database tables, if exist replace the value of name(key)
+ * The section contains the name of table, name(key) and value
+ * @param {*} sections 
+ */
+function setSections(sections) {
+    return new Promise(function (resolve, reject) {
+        // prepare query
+        var sql = "";
+        for(var i = 0; i < sections.length; i++) {
+            var value = JSON.stringify(sections[i].value).replace(/\'/g,"''");
+            sql += "INSERT OR REPLACE INTO " + sections[i].table + " (name, value) VALUES('" + sections[i].name + "','"+ value + "');";
+        }
+        db_prj.exec(sql, function (err) {
+            if (err) {
+                logger.error(`prjstorage.set failed! ${err}`);
+                reject();
+            } else {
+                resolve();
+            }
+        });          
+    });
+}
+
+/**
+ * Insert the values in database table, if exist replace the value of name(key)
+ * The section contains the name of table, name(key) and value
+ * @param {*} section
+ */
+function setSection(section) {
+    return new Promise(function (resolve, reject) {
+        var value = JSON.stringify(section.value).replace(/\'/g,"''");
+        var sql = "INSERT OR REPLACE INTO " + section.table + " (name, value) VALUES('" + section.name + "','"+ value + "');";
+        db_prj.exec(sql, function (err) {
+            if (err) {
+                logger.error(`prjstorage.set failed! ${err}`);
+                reject();
+            } else {
+                resolve();
+            }
+        });          
+    });
+}
+
+/**
+ * Return all values of table with this name
+ * If name is null return all values in table
+ * @param {*} table 
+ * @param {*} name 
+ */
+function getSection(table, name) {
+    return new Promise(function (resolve, reject) {
+        var sql = "SELECT name, value FROM " + table;
+        if (name) {
+            sql += " WHERE name = '" + name + "'";
+        }
+        db_prj.all(sql, function (err, rows) {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(rows);
+            }
+        });
+    });
+}
+
+/**
+ * Delete the values in database table
+ * The section contains the name of table, name(key)
+ * @param {*} section 
+ */
+function deleteSection(section) {
+    return new Promise(function (resolve, reject) {
+        var sql = "DELETE FROM " + section.table + " WHERE name = '" + section.name + "'";
+        db_prj.run(sql, function (err, rows) {
+            if (err) {
+                reject(err);
+            } else {
+                resolve();
+            }
+        });
+    });
+}
+
+/**
+ * Close the database
+ */
+function close() {
+    if (db_prj) {
+        db_prj.close();
+    }
+}
+
+/**
+ * Clear all table in database
+ */
+function clearAll() {
+    return new Promise(function (resolve, reject) {
+        // prepare query
+        var sql = "DELETE FROM general;";
+        sql += "DELETE FROM views;";
+        sql += "DELETE FROM devices;";
+        sql += "DELETE FROM texts;";
+        sql += "DELETE FROM alarms;";
+        sql += "DELETE FROM notifications;";
+        sql += "DELETE FROM scripts;";
+        sql += "DELETE FROM reports;";
+        db_prj.exec(sql, function (err) {
+            if (err) {
+                logger.error(`prjstorage.clear failed! ${err}`);
+                reject();
+            } else {
+                resolve(true);
+            }
+        });  
+    });
+}
+
+/**
+ * Database Table
+ */
+const TableType = {
+    GENERAL: 'general',
+    DEVICES: 'devices',
+    VIEWS: 'views',
+    DEVICESSECURITY: 'devicesSecurity',
+    TEXTS: 'texts',
+    ALARMS: 'alarms',
+    NOTIFICATIONS: 'notifications',
+    SCRIPTS: 'scripts',
+    REPORTS: 'reports',
+}
+
+module.exports = {
+    init: init,
+    close: close,
+    clearAll: clearAll,
+    getSection: getSection,
+    setSections: setSections,
+    setSection: setSection,
+    deleteSection: deleteSection,
+    setDefault: setDefault,
+    TableType: TableType,
+};

package/runtime/scripts/index.js

@@ -0,0 +1,313 @@
+/*
+* Script manager: check and run scheduled script, run script call from frontend
+*/
+
+'use strict';
+
+const MyScriptModule = require('./msm');
+const nodeSchedule = require('node-schedule');
+
+var SCRIPT_CHECK_STATUS_INTERVAL = 1000;
+
+function ScriptsManager(_runtime) {    
+    var runtime = _runtime;
+    var events = runtime.events;        // Events to commit change to runtime
+    var settings = runtime.settings;    // Settings
+    var logger = runtime.logger;        // Logger
+    var scriptsCheckStatus = null;      // TimerInterval to check scripts manager status
+    var working = false;                // Working flag to manage overloading of check notificator status
+    var status = ScriptsStatusEnum.INIT;// Current status (StateMachine)
+    var lastCheck = 0;                  // Timestamp to check intervall only in IDLE
+    var schedulingMap = {};             // Mapped script mit scheduling
+    var scriptModule = MyScriptModule.create(events, logger);
+
+    /**
+     * Start TimerInterval to check Scripts
+     */
+    this.start = function () {
+        return new Promise(function (resolve, reject) {
+            logger.info('scripts.start-checkstatus', true);
+            scriptsCheckStatus = setInterval(function () {
+                _checkStatus();
+            }, SCRIPT_CHECK_STATUS_INTERVAL);
+        });
+    }
+
+    /**
+     * Stop StateMachine, break TimerInterval (_checkStatus)
+     */
+    this.stop = function () {
+        return new Promise(function (resolve, reject) {
+            logger.info('scripts.stop-checkstatus!', true);
+            if (scriptsCheckStatus) {
+                clearInterval(scriptsCheckStatus);
+                scriptsCheckStatus = null;
+                status = ScriptsStatusEnum.INIT;
+                working = false;
+            }
+            resolve();
+        });
+    }
+
+    this.reset = function () {
+        // this.clear();
+        status = ScriptsStatusEnum.LOAD;
+    }
+
+    this.updateScript = function (script) {
+        this.reset();
+    }
+
+    this.removeScript = function (script) {
+        this.reset();
+    }
+    
+    /**
+     * Run script, <script> {id, name, parameters: <ScriptParam> {name, type: <ScriptParamType>[tagid, value], value: any} }
+     * @returns 
+     */
+    this.runScript = function (script) {
+        return new Promise(async function (resolve, reject) {
+            try {
+                var result;
+                if (script.test) {
+                    result = await scriptModule.runTestScript(script);
+                } else {
+                    logger.info(`Run script ${script.name}`);
+                    result = scriptModule.runScript(script);
+                }
+                resolve(result || `Script OK: ${script.name}`);
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+
+    this.isAuthorised = function (_script, groups) {
+        try {
+            const st = scriptModule.getScript(_script);
+            var admin = (groups === -1 || groups === 255) ? true : false;
+            if (admin || (st && (!st.permission || st.permission & groups))) {
+                return true;
+            }
+        } catch (err) {
+            logger.error(err);
+        }
+        return false;
+    }
+
+    this.sysFunctionExist = (functionName) => {
+        const sysFncs = _getSystemFunctions();
+        return !!sysFncs[functionName];
+    }
+
+    this.runSysFunction = (functionName, params) => {
+        return scriptModule.runSysFunction(functionName, params);
+    }
+
+    /**
+     * Check the Scripts state machine
+     */
+    var _checkStatus = function () {
+        if (status === ScriptsStatusEnum.INIT) {
+            if (_checkWorking(true)) {
+                _init().then(function () {
+                    status = ScriptsStatusEnum.LOAD;
+                    _checkWorking(false);
+                }).catch(function (err) {
+                    _checkWorking(false);
+                });
+            }
+        } else if (status === ScriptsStatusEnum.LOAD) {
+            if (_checkWorking(true)) {
+                _loadProperty().then(function () {
+                    _checkWorking(false);
+                    status = ScriptsStatusEnum.IDLE;
+                }).catch(function (err) {
+                    _checkWorking(false);
+                });
+            }
+        } else if (status === ScriptsStatusEnum.IDLE) {
+            const time = new Date().getTime();
+            Object.keys(schedulingMap).forEach((name) => {
+                const script = schedulingMap[name];
+                if (script.isToRun(time)) {
+                    try {
+                        scriptModule.runScriptWithoutParameter(script);
+                        script.lastRun = time;
+                    } catch (err) {
+                        if (err.message) {
+                            logger.error(err.message);
+                        } else {
+                            logger.error(err);
+                        }
+                    }
+                }
+            });
+        }
+    }
+
+    /**
+     * Init Scripts manager
+     */
+    var _init = function () {
+        return new Promise(function (resolve, reject) {
+            try {
+                scriptModule.init(_getSystemFunctions());
+                resolve();
+            } catch (err) {
+                logger.error(err);
+            }
+        });
+    }
+
+    var _checkWorking = function (check) {
+        if (check && working) {
+            logger.warn('scripts manager working (check) overload!');
+            return false;
+        }
+        working = check;
+        return true;
+    }
+
+    /**
+     * Load Scripts property in local for check
+     */
+    var _loadProperty = function () {
+        return new Promise(function (resolve, reject) {
+            schedulingMap = {};
+            try {
+                nodeSchedule.gracefulShutdown();
+            } catch (e) {
+                logger.error(e);
+            }
+            runtime.project.getScripts().then((scripts) => {
+                if (scripts) {
+                    var lr = scriptModule.loadScripts(scripts);
+                    Object.values(scripts).forEach((script) => {
+                        if (script.scheduling) {
+                            const scriptSchedule = new ScriptSchedule(script);
+                            if (script.scheduling.interval && script.mode != 'CLIENT') {
+                                schedulingMap[script.name] = scriptSchedule;
+                            } else if (script.scheduling.mode === ScriptSchedulingMode.scheduling) {
+                                try {
+                                    scriptSchedule.getScheduleRules().forEach((scheduleRule) => {
+                                        logger.info(`Load script-schedule ${script.name} - ${JSON.stringify(scheduleRule)}`);
+                                        nodeSchedule.scheduleJob(scheduleRule, function() {
+                                            scriptModule.runScriptWithoutParameter(script);
+                                        });
+                                    });
+                                } catch (er) {
+                                    logger.error(er);
+                                }
+                            }
+                        }
+                    });
+                    resolve(lr.messages);
+                } else {
+                    resolve();
+                }
+            }).catch(function (err) {
+                reject(err);
+            });
+        });
+    }
+
+    var _getSystemFunctions = function () {
+        var sysFncs = {};
+        sysFncs['$getTag'] = runtime.devices.getTagValue;
+        sysFncs['$setTag'] = runtime.devices.setTagValue;
+        sysFncs['$getTagId'] = runtime.devices.getTagId;
+        sysFncs['$setView'] = _setCommandView;
+        sysFncs['$enableDevice'] = runtime.devices.enableDevice;
+        sysFncs['$getTagDaqSettings'] = runtime.devices.getTagDaqSettings;
+        sysFncs['$setTagDaqSettings'] = runtime.devices.setTagDaqSettings;
+        return sysFncs;
+    }
+
+    var _setCommandView = function (view, force) {
+        let command = { command: ScriptCommandEnum.SETVIEW, params: [view, force] };
+        runtime.scriptSendCommand(command);
+    }
+}
+
+module.exports = {
+    create: function (runtime) {
+        return new ScriptsManager(runtime);
+    }
+}
+
+/**
+ * State of Scripts manager
+ */
+const ScriptsStatusEnum = {
+    INIT: 'init',
+    LOAD: 'load',
+    IDLE: 'idle',
+}
+
+function ScriptSchedule(script) {
+    this.id = script.id;
+    this.name = script.name;
+    this.scheduling = script.scheduling;
+    this.lastRun = 0;
+    this.created = new Date().getTime();
+
+    this.isToRun = function(time) {
+        if (this.scheduling.mode === ScriptSchedulingMode.start) {
+            return !this.lastRun && (time - this.created > this.scheduling.interval * 1000);
+        } else if (this.scheduling.mode !== ScriptSchedulingMode.scheduling) {
+            return (time - this.lastRun > this.scheduling.interval * 1000);
+        }
+    }
+
+    this.getScheduleRules = function() {
+        let result = [];
+        if (this.scheduling.schedules) {
+            this.scheduling.schedules.forEach(schedule => {
+
+                if (schedule.type === SchedulerType.date && schedule.date) {
+                    var date = new Date(schedule.date);
+                    if (schedule.time) {
+                        const [hour, minute, seconds] = schedule.time.split(':');
+                        if (hour) date.setHours(hour);
+                        if (minute) date.setMinutes(minute);
+                        if (seconds) date.setSeconds(seconds);
+                    }
+                    result.push(date);
+                } else {
+                    const rule = new nodeSchedule.RecurrenceRule();
+                    if (schedule.hour) rule.hour = schedule.hour;
+                    if (schedule.minute) rule.minute = schedule.minute;
+                    if (schedule.days) {
+                        rule.dayOfWeek = [];
+                        if (schedule.days.includes('sun')) rule.dayOfWeek.push(0);
+                        if (schedule.days.includes('mon')) rule.dayOfWeek.push(1);
+                        if (schedule.days.includes('tue')) rule.dayOfWeek.push(2);
+                        if (schedule.days.includes('wed')) rule.dayOfWeek.push(3);
+                        if (schedule.days.includes('thu')) rule.dayOfWeek.push(4);
+                        if (schedule.days.includes('fri')) rule.dayOfWeek.push(5);
+                        if (schedule.days.includes('sat')) rule.dayOfWeek.push(6);
+                    }
+                    result.push(rule);
+                }
+            });
+        }
+        return result;
+    }
+}
+
+const ScriptCommandEnum = {
+    SETVIEW: 'SETVIEW',
+}
+
+const ScriptSchedulingMode = {
+    interval: 'interval',
+    start: 'start',
+    scheduling: 'scheduling',
+}
+
+const SchedulerType = {
+    weekly: 0,
+    date: 1,
+}

package/runtime/scripts/msm.js

@@ -0,0 +1,146 @@
+
+/*
+* My Script Module: script container, scripts defined in frontend (string code) are to load as function
+*/
+
+'use strict';
+const path = require('path');
+
+var Module = module.constructor;
+
+// const eventsIncludes = 'var events = require("../events").create();';
+const requireInclude = `const path = require('path');`;
+const eventsIncludes = 'var events; var id; var console = { log: function (msg) { if (events) events.emit(\'script-console\', { msg: msg, type: \'log\', id: id });}};';
+// const eventsIncludes = 'var events = require("../events").create();';// var console = { log: function (msg) { if (events) events.emit(\'script-console\', { msg: msg, type: \'log\' });}}';
+const initEvents = { name: 'init', code: 'events = _events; id = _id', parameters: [{ name: '_events' }, { name: '_id' }] };
+// const setSystemFunctions = { name: 'setSysFunctions', code: 'Object.keys(systemFunctions).forEach(k => {  });', parameters: [{ name: '_sysfncs' }] };
+// const consoleLog = { name: 'console', code: 'log: function (msg) { if (events) events.emit(\'script-console\', { msg: msg, type: \'log\' });}', parameters: [] };
+// tempScripts['console.error'] = 'function (msg) { events.emit(\'device-status:changed\', { msg: msg, type: \'error\' }); }';
+
+function MyScriptsModule(_events, _logger) {
+    var events = _events;
+    var logger = _logger;
+    var module = new Module();
+    var scriptsMap = {};
+    var systemFunctions = {};
+    var scriptsModule;
+
+    this.init = function (sysfncs) {
+        systemFunctions = sysfncs;
+        Object.keys(systemFunctions).forEach(k => {
+            global[k] = systemFunctions[k];
+        });
+    }
+
+    this.loadScripts = function (_scripts) {
+        let result = _scriptsToModule(_scripts);
+        scriptsModule = result.module;
+        scriptsMap = result.scriptsMap;
+        return result;
+    }
+
+    this.runTestScript = function (_script) {
+        // clone scripts and add or replace script to test
+        var tempScripts = JSON.parse(JSON.stringify(scriptsMap));
+        tempScripts[_script.name] = _script;
+        tempScripts[initEvents.name] = initEvents;
+
+        var result = _scriptsToModule(tempScripts, eventsIncludes);
+        if (result.module) {
+            var paramsValue = _script.parameters.map(p => p.value || p);
+            result.module[initEvents.name](events, _script.outputId);
+            return result.module[_script.name](...paramsValue);
+        }
+        throw new Error(result);
+    }
+
+    this.runScript = function (_script) {
+        if (scriptsModule) {
+            var paramsValue = _script.parameters.map(p => p.value || p);
+            if (!_script.name) {
+                _script = Object.values(scriptsMap).find(s => s.id === _script.id);
+            }
+            try {
+                return scriptsModule[_script.name](...paramsValue);
+            } catch (err) {
+                console.error(err);
+                return err;
+            }
+        }
+    }
+
+    this.runScriptWithoutParameter = function (_script) {
+        if (scriptsModule) {
+            if (!_script.name) {
+                _script = Object.values(scriptsMap).find(s => s.id === _script.id);
+            }
+            try {
+                return scriptsModule[_script.name]();
+            } catch (err) {
+                console.error(err);
+                return err;
+            }
+        }
+    }
+
+    this.runSysFunction = function (functionName, params) {
+        return global[functionName](...params);
+    }
+
+    this.getScript = function (_script) {
+        return Object.values(scriptsMap).find(s => s.id === _script.id);
+    }
+
+    var _scriptsToModule = function (_scripts, _includes) {
+        let result = { module: null, messages: [], scriptsMap: {} };
+        try {
+            let functions = '';
+            let toexport = '';
+            Object.values(_scripts).forEach((script) => {
+                try {
+                    if (script.code) {
+                        var params = '';
+                        for (let i = 0; i < script.parameters.length; i++) {
+                            if (params.length) params += ',';
+                            params += `${script.parameters[i].name}`;
+                        }
+                        functions += `async function ${script.name} (${params}) { try { ${script.code} } catch (fuxaError) { console.log(fuxaError); return JSON.stringify(fuxaError); } }`;
+                        toexport += `${script.name}: ${script.name}, `;
+                        result.scriptsMap[script.name] = script;
+                    } else {
+                        logger.warn(`load.script ${script.name} without code!`);
+                        result.messages.push(`load.script ${script.name} without code!`);
+                    }
+                } catch(e) {
+                    logger.error(`load.script ${script.name} error: ${(e.stack) ? e.stack : e}`);
+                    result.messages.push(`load.script ${script.name} error!`);
+                }
+            });
+            var code = '';
+            if (_includes) {
+                code = `${_includes}`;
+            }
+            var code = `${requireInclude} ${code} ${functions} module.exports = { ${toexport} };`;
+            var filename = path.resolve(__dirname, 'msm-scripts.js');
+            result.module = _requireFromString(code, filename);
+        } catch(ex) {
+            logger.error(`load.script error: ${(ex.stack) ? ex.stack : ex}`);
+            return ex;
+        }
+        return result;
+    }
+
+    var _requireFromString = function (src, filename) {
+        delete require.cache[filename];
+        var Module = module.constructor;
+        var m = new Module();
+        m._compile(src, filename);
+        return m.exports;
+    }
+}
+
+module.exports = {
+    create: function (events, logger) {
+        return new MyScriptsModule(events, logger);
+    }
+};