nodejs-poolcontroller 7.6.1 → 8.0.0

package/web/services/state/State.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
@@ -22,14 +23,64 @@ import { sys } from "../../../controller/Equipment";
 import { utils } from '../../../controller/Constants';
 import { logger } from "../../../logger/Logger";
 import { DataLogger } from "../../../logger/DataLogger";
+import { conn } from "../../../controller/comms/Comms";
+import { config } from "../../../config/Config";
 
 import { ServiceParameterError } from "../../../controller/Errors";
 
 export class StateRoute {
     public static initRoutes(app: express.Application) {
+        app.get('/state/rs485Port/:id', async (req, res, next) => {
+            try {
+                let portId = parseInt(req.params.id, 10);
+                if (isNaN(portId)) throw new ServiceParameterError(`RS485 port id not supplied`, '/state/rs485Port/:id', 'portId', req.params.id);
+                let cfg = config.getSection(portId === 0 ? 'controller.comms' : `controller.comms${portId}`);
+                if (typeof cfg === 'undefined') throw new ServiceParameterError(`RS485 port id not found`, '/state/rs485Port/:id', 'portId', req.params.id);
+                let port = conn.findPortById(portId);
+                let sport: any = {
+                    portId: portId,
+                    enabled: cfg.enabled || false,
+                    netConnect: cfg.netConnect,
+                    reconnects: 0,
+                    inactivityRetry: cfg.inactivityRetry,
+                    isOpen: false,
+                    mock: cfg.mock || false
+                }
+                if (cfg.netConnect) sport.netConnect = { host: cfg.netHost, port: cfg.netPort }
+                else if (typeof cfg.type !== 'undefined' && cfg.type === 'screenlogic'){
+                    sport.screenlogic = cfg.screenlogic;
+                }
+                else sport.settings = extend(true, { name: cfg.rs485Port }, cfg.portSettings);
+                if (typeof port !== 'undefined' && port.type !== 'screenlogic') {
+                    let stats = port.stats;
+                    sport.reconnects = port.reconnects;
+                    sport.isOpen = port.isOpen;
+                    sport.received = {
+                        bytes: stats.bytesReceived,
+                        success: stats.recSuccess,
+                        failed: stats.recFailed,
+                        collisions: stats.recCollisions,
+                        rewinds: stats.recFRewinds,
+                        failureRate: stats.recFailureRate
+                    };
+                    sport.sent = {
+                        bytes: stats.bytesSent,
+                        success: stats.sndSuccess,
+                        aborted: stats.sndAborted,
+                        retries: stats.sndRetries,
+                        failureRate: stats.sndFailureRate
+                    }
+                }
+                res.status(200).send(sport);
+            }
+            catch (err) { next(err); }
+        });
         app.get('/state/chemController/:id', (req, res) => {
             res.status(200).send(state.chemControllers.getItemById(parseInt(req.params.id, 10)).getExtended());
         });
+        app.get('/state/chemDoser/:id', (req, res) => {
+            res.status(200).send(state.chemDosers.getItemById(parseInt(req.params.id, 10)).getExtended());
+        });
         app.put('/state/chemController', async (req, res, next) => {
             try {
                 let schem = await sys.board.chemControllers.setChemControllerStateAsync(req.body);
@@ -37,6 +88,13 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
+        app.put('/state/chemDoser', async (req, res, next) => {
+            try {
+                let schem = await sys.board.chemDosers.setChemDoserStateAsync(req.body);
+                return res.status(200).send(schem.getExtended());
+            }
+            catch (err) { next(err); }
+        });
         app.put('/state/chemController/manualDose', async (req, res, next) => {
             try {
                 let schem = await sys.board.chemControllers.manualDoseAsync(req.body);
@@ -44,6 +102,14 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
+        app.put('/state/chemDoser/manualDose', async (req, res, next) => {
+            try {
+                let schem = await sys.board.chemDosers.manualDoseAsync(req.body);
+                return res.status(200).send(schem.getExtended());
+            }
+            catch (err) { next(err); }
+        });
+
         app.put('/state/chemController/manualMix', async (req, res, next) => {
             try {
                 logger.debug(`Starting manual mix`);
@@ -53,6 +119,13 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
+        app.put('/state/chemDoser/manualMix', async (req, res, next) => {
+            try {
+                let schem = await sys.board.chemDosers.manualMixAsync(req.body);
+                return res.status(200).send(schem.getExtended());
+            }
+            catch (err) { next(err); }
+        });
         app.get('/state/chemController/:id/doseHistory', (req, res) => {
             let schem = state.chemControllers.getItemById(parseInt(req.params.id));
             let hist = { ph: [], orp: [] };
@@ -62,6 +135,11 @@ export class StateRoute {
                 hist.orp.push(schem.orp.doseHistory[i]);
             return res.status(200).send(hist);
         });
+        app.get('/state/chemDoser/:id/doseHistory', (req, res) => {
+            let schem = state.chemDosers.getItemById(parseInt(req.params.id));
+            return res.status(200).send(schem.doseHistory);
+        });
+
         app.put('/state/chemController/:id/doseHistory/orp/clear', async (req, res, next) => {
             try {
                 let schem = state.chemControllers.getItemById(parseInt(req.params.id));
@@ -71,6 +149,16 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
+        app.put('/state/chemDoser/:id/doseHistory/clear', async (req, res, next) => {
+            try {
+                let schem = state.chemDosers.getItemById(parseInt(req.params.id));
+                schem.doseHistory = [];
+                schem.calcDoseHistory();
+                return res.status(200).send(schem.doseHistory);
+            }
+            catch (err) { next(err); }
+        });
+
         app.put('/state/chemController/:id/doseHistory/ph/clear', async (req, res, next) => {
             try {
                 let schem = state.chemControllers.getItemById(parseInt(req.params.id));
@@ -95,6 +183,21 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
+        app.get('/state/chemDoser/:id/doseLog', async (req, res, next) => {
+            try {
+                let schem = state.chemDosers.getItemById(parseInt(req.params.id));
+                let filter = req.body || {};
+                let dh = await DataLogger.readFromEndAsync(`chemDosage_Peristalic.log`, ChemicalDoseState, (lineNumber: number, entry: ChemicalDoseState, arr: ChemicalDoseState[]): boolean => {
+                    if (entry.id !== schem.id) return false;
+                    if (typeof filter.lines !== 'undefined' && filter.lines <= arr.length) return false;
+                    if (typeof filter.date !== 'undefined' && entry.end < filter.date) return false;
+                    return true;
+                });
+                return res.status(200).send(dh);
+            }
+            catch (err) { next(err); }
+        });
+
         app.search('/state/chemController/:id/doseLog/ph', async (req, res, next) => {
             try {
                 let schem = state.chemControllers.getItemById(parseInt(req.params.id));
@@ -144,6 +247,13 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
+        app.put('/state/chemDoser/cancelDosing', async (req, res, next) => {
+            try {
+                let schem = await sys.board.chemDosers.cancelDosingAsync(req.body);
+                return res.status(200).send(schem.getExtended());
+            }
+            catch (err) { next(err); }
+        });
         app.put('/state/chemController/cancelMixing', async (req, res, next) => {
             try {
                 let schem = await sys.board.chemControllers.cancelMixingAsync(req.body);
@@ -151,6 +261,13 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
+        app.put('/state/chemDoser/cancelMixing', async (req, res, next) => {
+            try {
+                let schem = await sys.board.chemDosers.cancelMixingAsync(req.body);
+                return res.status(200).send(schem.getExtended());
+            }
+            catch (err) { next(err); }
+        });
 
         app.get('/state/chlorinator/:id', (req, res) => {
             res.status(200).send(state.chlorinators.getItemById(parseInt(req.params.id, 10), false).getExtended());
@@ -161,6 +278,9 @@ export class StateRoute {
         app.get('/state/feature/:id', (req, res) => {
             res.status(200).send(state.features.getItemById(parseInt(req.params.id, 10)).get());
         });
+        app.get('/state/schedule/:id', (req, res) => {
+            res.status(200).send(state.schedules.getItemById(parseInt(req.params.id, 10)).get());
+        });
         app.get('/state/circuitGroup/:id', (req, res) => {
             res.status(200).send(state.circuitGroups.getItemById(parseInt(req.params.id, 10)).get());
         });
@@ -230,6 +350,13 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
+        app.put('/state/light/:id/colorSync', async (req, res, next) => {
+            try {
+                let slight = await sys.board.circuits.runLightCommandAsync({ id: parseInt(req.params.id, 10), command: 'colorsync' });
+                return res.status(200).send(slight.get(true));
+            }
+            catch (err) { next(err); }
+        });
         app.put('/state/light/:id/colorHold', async (req, res, next) => {
             try {
                 let slight = await sys.board.circuits.runLightCommandAsync({ id: parseInt(req.params.id, 10), command: 'colorhold' });
@@ -303,6 +430,7 @@ export class StateRoute {
             // RKS: 06-24-20 -- Changed this so that users can send in the body id, circuit id, or the name.
             // RKS: 05-14-21 -- Added cooling setpoints for the body.
             try {
+                
                 let body = sys.bodies.findByObject(req.body);
                 if (typeof body === 'undefined') return next(new ServiceParameterError(`Cannot set body setPoint.  You must supply a valid id, circuit, name, or type for the body`, 'body', 'id', req.body.id));
                 if (typeof req.body.coolSetpoint !== 'undefined' && !isNaN(parseInt(req.body.coolSetpoint, 10)))
@@ -367,6 +495,13 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
+        app.put('/state/manualOperationPriority', async (req, res, next) => {
+            try {
+                let cstate = await sys.board.system.setManualOperationPriority(parseInt(req.body.id, 10));
+                return res.status(200).send(cstate.get(true));
+            }
+            catch (err) { next(err); }
+        });
         app.put('/state/lightGroup/runCommand', async (req, res, next) => {
             try {
                 let sgroup = await sys.board.circuits.runLightGroupCommandAsync(req.body);
@@ -416,8 +551,24 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
-
-
+        app.put('/state/panelMode', async (req, res, next) => {
+            try {
+                await sys.board.system.setPanelModeAsync(req.body);
+                return res.status(200).send(state.controllerState);
+            } catch (err) { next(err); }
+        });
+        app.put('/state/toggleServiceMode', async (req, res, next) => {
+            try {
+                let data = extend({}, req.body);
+                if (state.mode === 0) {
+                    if (typeof data.timeout !== 'undefined' && !isNaN(data.timeout)) data.mode = 'timeout';
+                    else data.mode = 'service';
+                    await sys.board.system.setPanelModeAsync(req.body);
+                }
+                else sys.board.system.setPanelModeAsync({ mode: 'auto' });
+                return res.status(200).send(state.controllerState);
+            } catch (err) { next(err); }
+        });
         app.get('/state/emitAll', (req, res) => {
             res.status(200).send(state.emitAllEquipmentChanges());
         });

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,12 +187,12 @@ 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 {
                 data = JSON.parse(data);
-                let id = data.parseInt(data.id, 10);
+                let id = parseInt(data.id, 10);
                 if (!isNaN(id) && (typeof data.isOn !== 'undefined' || typeof data.state !== 'undefined')) {
                     await sys.board.circuits.setCircuitStateAsync(id, utils.makeBool(data.isOn || typeof data.state));
                 }
@@ -184,35 +202,68 @@ export class StateSocket {
         sock.on('/feature', async (data: any) => {
             try {
                 data = JSON.parse(data);
-                let id = data.parseInt(data.id, 10);
+                let id = parseInt(data.id, 10);
                 if (!isNaN(id) && (typeof data.isOn !== 'undefined' || typeof data.state !== 'undefined')) {
                     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 {
                 data = JSON.parse(data);
-                let id = data.parseInt(data.id, 10);
+                let id = parseInt(data.id, 10);
                 if (!isNaN(id) && (typeof data.isOn !== 'undefined' || typeof data.state !== 'undefined')) {
                     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 {
                 data = JSON.parse(data);
-                let id = data.parseInt(data.id, 10);
+                let id = parseInt(data.id, 10);
                 if (!isNaN(id) && (typeof data.isOn !== 'undefined' || typeof data.state !== 'undefined')) {
                     await sys.board.circuits.setLightGroupStateAsync(id, utils.makeBool(data.isOn || typeof data.state));
                 }
                 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());