nodejs-poolcontroller 7.7.0 → 8.0.0

package/web/services/state/StateSocket.ts

@@ -1,5 +1,6 @@
 /*  nodejs-poolController.  An application to control pool equipment.
-Copyright (C) 2016, 2017, 2018, 2019, 2020.  Russell Goldin, tagyoureit.  russ.goldin@gmail.com
+Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022.  
+Russell Goldin, tagyoureit.  russ.goldin@gmail.com
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as
@@ -28,7 +29,7 @@ export class StateSocket {
                 await state.circuits.toggleCircuitStateAsync(parseInt(data.id, 10));
                 // return res.status(200).send(cstate);
             }
-            catch (err) {logger.error(err);}
+            catch (err) {logger.error(`Socket processing error /state/circuit/toggleState: ${err.message}`);}
         });  
         sock.on('/state/body/heatMode', async (data: any) => {
             // RKS: 06-24-20 -- Changed this so that users can send in the body id, circuit id, or the name.
@@ -52,7 +53,8 @@ export class StateSocket {
                 }
                 await sys.board.bodies.setHeatModeAsync(body, mode);
                 // return res.status(200).send(tbody);
-            } catch (err) { logger.error(err); }
+            }
+            catch (err) { logger.error(`Socket processing error /state/body/heatmode: ${err.message}`); }
         });
         sock.on('/state/body/setPoint', async (data: any) => {
             // RKS: 06-24-20 -- Changed this so that users can send in the body id, circuit id, or the name.
@@ -65,14 +67,14 @@ export class StateSocket {
                 }
                 await sys.board.bodies.setHeatSetpointAsync(body, parseInt(data.setPoint, 10));
                 // return res.status(200).send(tbody);
-            } catch (err) { logger.error(err); }
+            } catch (err) { logger.error(`Socket processing error /state/body/setPoint: ${err.message}`); }
         });
         sock.on('/temps', async (data: any) => {
             try {
                 data = JSON.parse(data);
                 await sys.board.system.setTempsAsync(data).catch(err => logger.error(err));
             }
-            catch (err) { logger.error(err); }
+            catch (err) { logger.error(`Socket processing error /temps: ${err.message}`); }
         });
         
         sock.on('/chlorinator', async (data: any) => {
@@ -98,7 +100,7 @@ export class StateSocket {
                     schlor.emitEquipmentChange();
                 }
             }
-            catch (err) { logger.error(err); }
+            catch (err) { logger.error(`Socket processing error /chlorinator: ${err.message}`); }
         });
         sock.on('/filter', async (data: any) => {
             try {
@@ -112,9 +114,7 @@ export class StateSocket {
                         await sys.board.filters.setFilterPressure(filter.id, data.pressure, data.pressureUnits || pu.name);
                     sfilter.emitEquipmentChange();
                 }
-
-                
-            } catch (err) { logger.error(err); }
+            } catch (err) { logger.error(`Socket processing error /filter: ${err.message}`); }
         });
         sock.on('/chemController', async (data: any) => {
             try {
@@ -160,7 +160,25 @@ export class StateSocket {
                         if (!isNaN(parseFloat(data.orpTank.capacity))) scontroller.orp.tank.capacity = controller.orp.tank.capacity = parseFloat(data.orpTank.capacity);
                         if (typeof data.orpTank.units === 'string') scontroller.orp.tank.units = controller.orp.tank.units = data.orpTank.units;
                     }
+                    if (typeof data.acidPump !== 'undefined' || typeof data.orpPump !== 'undefined') {
+                        let chem = typeof data.acidPump !== 'undefined' ? controller.ph : controller.orp;
+                        let schem = typeof data.acidPump !== 'undefined' ? scontroller.ph : scontroller.orp;
+                        let vals = typeof data.acidPump !== 'undefined' ? data.acidPump : data.orpPump;
+                        let pump = chem.pump;
+                        switch (sys.board.valueMaps.chemPumpTypes.getName(pump.type)) {
+                            case 'ezo-pmp':
+                                if (typeof vals.dispense !== 'undefined') {
+                                    pump.ratedFlow = typeof vals.dispense.ratedFlow === 'number' ? vals.dispense.ratedFlow : pump.ratedFlow;
+                                }
+                                if (typeof vals.tank !== 'undefined') {
+                                    if (!isNaN(parseFloat(vals.tank.level))) schem.tank.level = parseFloat(vals.tank.level);
+                                    if (!isNaN(parseFloat(vals.tank.capacity))) schem.tank.capacity = chem.tank.capacity = parseFloat(vals.tank.capacity);
+                                    if (typeof vals.tank.units === 'string') schem.tank.units = chem.tank.units = vals.tank.units;
+                                }
+                                break;
+                        }
 
+                    }
                     // Need to build this out to include the type of controller.  If this is REM Chem we
                     // will send the whole rest of the nut over to it.  Intellichem will only let us
                     // set specific values.
@@ -169,7 +187,7 @@ export class StateSocket {
                     }
                 }
             }
-            catch (err) { logger.error(err); }
+            catch (err) { logger.error(`Socket processing error /chemController: ${err.message}`); }
         });
         sock.on('/circuit', async (data: any) => {
             try {
@@ -189,7 +207,7 @@ export class StateSocket {
                     await sys.board.features.setFeatureStateAsync(id, utils.makeBool(data.isOn || typeof data.state));
                 }
             }
-            catch (err) { logger.error(err); }
+            catch (err) { logger.error(`Socket processing error /feature: ${err.message}`); }
         });
         sock.on('/circuitGroup', async (data: any) => {
             try {
@@ -199,7 +217,7 @@ export class StateSocket {
                     await sys.board.circuits.setCircuitGroupStateAsync(id, utils.makeBool(data.isOn || typeof data.state));
                 }
             }
-            catch (err) { logger.error(err); }
+            catch (err) { logger.error(`Socket processing error /circuitGroup: ${err.message}`); }
         });
         sock.on('/lightGroup', async (data: any) => {
             try {
@@ -210,9 +228,42 @@ export class StateSocket {
                 }
                 if (!isNaN(id) && typeof data.theme !== 'undefined') await sys.board.circuits.setLightGroupThemeAsync(id, data.theme);
             }
-            catch (err) { logger.error(err); }
+            catch (err) { logger.error(`Socket processing error /lightGroup: ${err.message}`); }
+        });
+        sock.on('/panelMode', async (data: any) => {
+            try {
+                data = JSON.parse(data);
+                let obj = {};
+                if (typeof data.isOn !== 'undefined' && !utils.makeBool(data.isOn)) return; // This is just in case it is sent by REM for a toggle button.
+                if (typeof data.timeout !== 'undefined' && !isNaN(data.timeout) && data.timeout) {
+                    switch (data.timeUnits.toLowerCase()) {
+                        case 'min':
+                        case 'mins':
+                        case 'm':
+                        case 'minute':
+                        case 'minutes':
+                            data.timeout = data.timeout * 60;
+                            break;
+                        case 'hr':
+                        case 'hrs':
+                        case 'h':
+                        case 'hour':
+                            data.timeout = data.timeout * 3600;
+                            break;
+                    }
+                }
+                if (typeof data.mode === 'undefined' || data.mode === 'toggle') {
+                    if (state.mode === 0) {
+                        if (typeof data.timeout !== 'undefined' && !isNaN(data.timeout) && data.timeout)
+                            data.mode = 'timeout';
+                        else data.mode = 'service';
+                        await sys.board.system.setPanelModeAsync(data);
+                    }
+                    else sys.board.system.setPanelModeAsync({ mode: 'auto' });
+                }
+                else await sys.board.system.setPanelModeAsync(data);
+            } catch (err) { logger.error(`Socket processing error /panelMode: ${err.message}`); }
         });
-
         /*
         app.get('/state/chemController/:id', (req, res) => {
             res.status(200).send(state.chemControllers.getItemById(parseInt(req.params.id, 10)).getExtended());

package/web/services/utilities/Utilities.ts

@@ -1,5 +1,6 @@
 /*  nodejs-poolController.  An application to control pool equipment.
-Copyright (C) 2016, 2017, 2018, 2019, 2020.  Russell Goldin, tagyoureit.  russ.goldin@gmail.com
+Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022.  
+Russell Goldin, tagyoureit.  russ.goldin@gmail.com
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as
@@ -14,11 +15,19 @@ GNU Affero General Public License for more details.
 You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
+import * as path from "path";
+import * as fs from "fs";
+import * as multer from 'multer';
 import * as express from 'express';
 import { SsdpServer} from '../../Server';
 import { state } from "../../../controller/State";
 import { sys } from "../../../controller/Equipment";
 import { webApp } from "../../Server";
+import { config } from "../../../config/Config";
+import { logger } from "../../../logger/Logger";
+import { ServiceParameterError, ServiceProcessError } from "../../../controller/Errors";
+import { BindingsFile } from "../../interfaces/baseInterface";
+import { Utils, utils } from "../../../controller/Constants";
 const extend = require("extend");
 export class UtilitiesRoute {
 
@@ -41,5 +50,184 @@ export class UtilitiesRoute {
             }
             return res.status(200).send(arr);
         });
+        app.put('/app/interfaces/add', async (req, res, next) => {
+            try {
+                let faces = config.getSection('web.interfaces');
+                let opts: any = {};
+                switch (req.body.type) {
+                    case 'rule':
+                        opts = {};
+                        break;
+                    case 'rem':
+                        opts = {
+                            options: { protocol: 'http://', host: '', port: 8080, headers: { "content-type": "application/json" } },
+                            socket: {
+                                transports: ['websocket'], allowEIO3: true, upgrade: false,
+                                reconnectionDelay: 2000, reconnection: true, reconnectionDelayMax: 20000
+                            }
+                        }
+                        break;
+                    case 'http':
+                    case 'rest':
+                        opts = {
+                            options: { protocol: 'http://', host: '', port: 80 }
+                        }
+                        break;
+                    case 'influx':
+                    case 'influxdb':
+                        opts = {
+                            options: {
+                                version: 1,
+                                protocol: 'http',
+                                database: 'pool',
+                                port: 8601,
+                                retentionPolicy: 'autogen'
+                            }
+                        }
+                        break;
+                    case 'influxdb2':
+                        opts = {
+                            options: {
+                                version: 2,
+                                protocol: 'http',
+                                port: 9999,
+                                database: 'pool',
+                                bucket: '57ec4eed2d90a50b',
+                                token: '...LuyM84JJx93Qvc7tfaXPbI_mFFjRBjaA==',
+                                org: 'njsPC-org'
+                            }
+                        }
+                        break;
+                    case 'mqtt':
+                        opts = {
+                            options: {
+                                protocol: 'mqtt://', host: '', port: 1883, username: '', password: '',
+                                selfSignedCertificate: false,
+                                rootTopic: "pool/@bind=(state.equipment.model).replace(' ','-').replace(' / ','').toLowerCase();",
+                                retain: true, qos: 0, changesOnly: true
+                            }
+                        }
+                        break;
+                    default:
+                        return Promise.reject(new ServiceParameterError(`An invalid type was specified ${req.body.type}`, 'PUT: /app/interfaces/add', 'type', req.body.type));
+                }
+                opts.uuid = utils.uuid();
+                opts.isCustom = true;
+                // Now lets create a name for the element.  This would have been much easier if it were an array but alas we are stuck.
+                let name = req.body.name.replace(/^[^a-zA-Z_$]|[^0-9a-zA-Z_$]/g, '_');
+                if (name.length === 0) return Promise.reject(new ServiceParameterError(`An invalid name was specified ${req.body.name}`, 'PUT: /app/interfaces/add', 'name', req.body.name));
+                if (name.charAt(0) >= '0' && name.charAt(0) <= '9') name = 'i' + name;
+                let fnEnsureUnique = (name, ord?: number): string => {
+                    let isUnique = true;
+                    for (let fname in faces) {
+                        if (fname === (typeof ord !== 'undefined' ? `${name}_${ord}` : name)) {
+                            isUnique = false;
+                            break;
+                        }
+                    }
+                    if (!isUnique) name = fnEnsureUnique(name, typeof ord === 'undefined' ? 0 : ord++);
+                    return typeof ord !== 'undefined' ? `${name}_${ord}` : name;
+                }
+                name = fnEnsureUnique(name);
+                opts = extend(true, {}, opts, req.body);
+                config.setSection(`web.interfaces.${name}`, opts);
+                res.status(200).send({ id: name, opts: opts });
+            } catch (err) { next(err); }
+        });
+        app.delete('/app/interface', async (req, res, next) => {
+            try {
+                let faces = config.getSection('web.interfaces');
+                let deleted;
+                for (let fname in faces) {
+                    let iface = faces[fname];
+                    if (typeof req.body.id !== 'undefined') {
+                        if (fname === req.body.id) {
+                            deleted = iface;
+                            iface.enabled = false;
+                            await webApp.updateServerInterface(iface);
+                            config.removeSection(`web.interfaces.${fname}`);
+                        }
+                    }
+                    else if (typeof req.body.uuid !== 'undefined') {
+                        if (req.body.uuid.toLowerCase() === iface.uuid.toLowerCase()) {
+                            deleted = iface;
+                            iface.enabled = false;
+                            await webApp.updateServerInterface(iface);
+                            config.removeSection(`web.interfaces.${fname}`);
+                        }
+                    }
+                }
+                return res.status(200).send(deleted);
+            } catch (err) { next(err); }
+        });
+        app.get('/app/options/interfaces', async (req, res, next) => {
+            try {
+                // todo: move bytevaluemaps out to a proper location; add additional definitions
+                let opts = {
+                    interfaces: config.getSection('web.interfaces'),
+                    types: [
+                        { name: 'rule', desc: 'Rule', hasBindings: true, hasUrl: false },
+                        { name: 'rest', desc: 'Rest', hasBindings: true },
+                        { name: 'http', desc: 'Http', hasBindings: true },
+                        { name: 'rem', desc: 'Relay Equipment Manager', hasBindings: false },
+                        { name: 'mqtt', desc: 'MQTT', hasBindings: true },
+                        { name: 'influx', desc: 'InfluxDB', hasBindings: true },
+                        { name: 'influxdb2', desc: 'InfluxDB2', hasBindings: true}
+                    ],
+                    protocols: [
+                        { val: 0, name: 'http://', desc: 'http://' },
+                        { val: 1, name: 'https://', desc: 'https://' },
+                        { val: 2, name: 'mqtt://', desc: 'mqtt://' }
+                    ],
+                    files: []
+                }
+                // Read all the files in the custom bindings directory.
+                let cpath = path.posix.join(process.cwd(), '/web/bindings/custom/');
+                let files = fs.readdirSync(cpath);
+                for (let i = 0; i < files.length; i++) {
+                    if (path.extname(files[i]) === '.json') {
+                        let bf = await BindingsFile.fromFile(path.posix.join(process.cwd(), 'web/bindings/'), `custom/${files[i]}`);
+                        if (typeof bf !== 'undefined') opts.files.push(bf.options);
+                    }
+                }
+                return res.status(200).send(opts);
+            } catch (err) { next(err); }
+        });
+        app.post('/app/interfaceBindings/file', async (req, res, next) => {
+            try {
+                let file = multer({
+                    limits: { fileSize: 1000000 },
+                    storage: multer.memoryStorage()
+                }).single('bindingsFile');
+                file(req, res, async (err) => {
+                    try {
+                        if (err) { next(err); }
+                        else {
+                            // Validate the incoming data and save it off only if it is valid.
+                            let bf = await BindingsFile.fromBuffer(req.file.originalname, req.file.buffer);
+                            if (typeof bf === 'undefined') {
+                                err = new ServiceProcessError(`Invalid bindings file: ${req.file.originalname}`, 'POST: app/bindings/file', 'extractBindingOptions');
+                                next(err);
+                            }
+                            else {
+                                if (fs.existsSync(bf.filePath))
+                                    return next(new ServiceProcessError(`File already exists ${req.file.originalname}`, 'POST: app/bindings/file', 'writeFile'));
+                                else {
+                                    try {
+                                        fs.writeFileSync(bf.filePath, req.file.buffer);
+                                    } catch (e) { logger.error(`Error writing bindings file ${e.message}`); }
+                                }
+                                return res.status(200).send(bf);
+                            }
+                        }
+                    } catch (e) {
+                        err = new ServiceProcessError(`Error uploading file: ${e.message}`, 'POST: app/backup/file', 'uploadFile');
+                        next(err);
+                        logger.error(e);
+                    }
+                });
+            } catch (err) { next(err); }
+        });
+
     }
 }