nodejs-poolcontroller 7.6.1 → 8.0.0

package/web/interfaces/ruleInterface.ts

@@ -0,0 +1,87 @@
+/*  nodejs-poolController.  An application to control pool equipment.
+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
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+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 { webApp } from "../../web/Server";
+import extend=require("extend");
+import { logger } from "../../logger/Logger";
+import { PoolSystem, sys } from "../../controller/Equipment";
+import { State, state } from "../../controller/State";
+import { InterfaceContext, InterfaceEvent, BaseInterfaceBindings } from "./baseInterface";
+
+export class RuleInterfaceBindings extends BaseInterfaceBindings {
+    constructor(cfg) { super(cfg);}
+    declare events: RuleInterfaceEvent[];
+    public bindProcessor(evt: RuleInterfaceEvent) {
+        if (evt.processorBound) return;
+        if (typeof evt.fnProcessor === 'undefined') {
+            let fnBody = Array.isArray(evt.processor) ? evt.processor.join('\n') : evt.processor;
+            if (typeof fnBody !== 'undefined' && fnBody !== '') {
+                //let AsyncFunction = Object.getPrototypeOf(async => () => { }).constructor;
+                let AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+                try {
+                    evt.fnProcessor = new AsyncFunction('rule', 'options', 'vars', 'logger', 'webApp', 'sys', 'state', 'data', fnBody) as (rule: RuleInterfaceEvent, vars: any, sys: PoolSystem, state: State, data: any) => void;
+                } catch (err) { logger.error(`Error compiling rule event processor: ${err} -- ${fnBody}`); }
+            }
+        }
+        evt.processorBound = true;
+    }
+    public executeProcessor(eventName: string, evt: RuleInterfaceEvent, ...data: any) {
+        this.bindProcessor(evt);
+        let vars = this.bindVarTokens(evt, eventName, data);
+        let opts = extend(true, this.cfg.options, this.context.options, evt.options);
+        if (typeof evt.fnProcessor !== undefined) evt.fnProcessor(evt, opts, vars, logger, webApp, sys, state, data);
+    }
+    public bindEvent(evt: string, ...data: any) {
+        // Find the binding by first looking for the specific event name.  
+        // If that doesn't exist then look for the "*" (all events).
+        if (typeof this.events !== 'undefined') {
+            let evts = this.events.filter(elem => elem.name === evt);
+            // If we don't have an explicitly defined event then see if there is a default.
+            if (evts.length === 0) {
+                let e = this.events.find(elem => elem.name === '*');
+                evts = e ? [e] : [];
+            }
+            if (evts.length > 0) {
+                let toks = {};
+                for (let i = 0; i < evts.length; i++) {
+                    let e = evts[i];
+                    if (typeof e.enabled !== 'undefined' && !e.enabled) continue;
+                    // Figure out whether we need to check the filter.
+                    if (typeof e.filter !== 'undefined') {
+                        this.buildTokens(e.filter, evt, toks, e, data[0]);
+                        if (eval(this.replaceTokens(e.filter, toks)) === false) continue;
+                    }
+                    // Look for the processor.
+                    this.executeProcessor(evt, e, ...data);
+                }
+            }
+        }
+    }
+}
+class RuleInterfaceEvent extends InterfaceEvent {
+    event: string;
+    description: string;
+    fnProcessor: (rule: RuleInterfaceEvent, options:any, vars: any, logger: any, webApp: any, sys: PoolSystem, state: State, data: any) => void;
+    processorBound: boolean = false;
+}
+export interface IRuleInterfaceEvent {
+    event: string,
+    description: string,
+    processor?: string
+}
+
+

package/web/services/config/Config.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
@@ -15,11 +16,11 @@ 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 fs from "fs";
+import * as path from "path";
 import * as express from "express";
 import * as extend from 'extend';
 import * as multer from 'multer';
-import * as path from "path";
-import { sys, LightGroup, ControllerType, Pump, Valve, Body, General, Circuit, ICircuit, Feature, CircuitGroup, CustomNameCollection, Schedule, Chlorinator, Heater } from "../../../controller/Equipment";
+import { sys, LightGroup, ControllerType, Pump, Valve, Body, General, Circuit, ICircuit, Feature, CircuitGroup, CustomNameCollection, Schedule, Chlorinator, Heater, Screenlogic } from "../../../controller/Equipment";
 import { config } from "../../../config/Config";
 import { logger } from "../../../logger/Logger";
 import { utils } from "../../../controller/Constants";
@@ -29,6 +30,8 @@ import { stopPacketCaptureAsync, startPacketCapture } from '../../../app';
 import { conn } from "../../../controller/comms/Comms";
 import { webApp, BackupFile, RestoreFile } from "../../Server";
 import { release } from "os";
+import { ScreenLogicComms, sl } from "../../../controller/comms/ScreenLogic";
+import { screenlogic } from "node-screenlogic";
 
 export class ConfigRoute {
     public static initRoutes(app: express.Application) {
@@ -62,12 +65,49 @@ export class ConfigRoute {
             };
             return res.status(200).send(opts);
         });
-        app.get('/config/options/rs485', (req, res) => {
-            let opts = {
-                port: config.getSection('controller.comms', { enabled: false, netConnect: false }),
-                stats: conn.buffer.counter
-            };
-            return res.status(200).send(opts);
+        app.get('/config/options/rs485', async (req, res, next) => {
+            try {
+                let opts = { ports: [], local: [], screenlogic: {} }
+                let cfg = config.getSection('controller');
+                for (let section in cfg) {
+                    if (section.startsWith('comms')) {
+                        let cport = extend(true, { enabled: false, netConnect: false, mock: false }, cfg[section]);
+                        let port = conn.findPortById(cport.portId || 0);
+                        if (typeof cport.type === 'undefined'){
+                            cport.type = cport.netConnect ? 'netConnect' : cport.mockPort || cport.mock ? 'mock' : 'local'
+                        }
+                        if (typeof port !== 'undefined') cport.stats = port.stats;
+                        if (port.portId === 0 && port.type === 'screenlogic') {
+                            cport.screenlogic.stats = sl.stats;
+                        }
+                        opts.ports.push(cport);
+                    }
+                    // if (section.startsWith('screenlogic')){
+                    //     let screenlogic = cfg[section];
+                    //     screenlogic.types =  [{ val: 'local', name: 'Local', desc: 'Local Screenlogic' }, { val: 'remote', name: 'Remote', desc: 'Remote Screenlogic' }];
+                    //     screenlogic.stats = sl.stats;
+                    //     opts.screenlogic = screenlogic;
+                    // }
+                }
+                opts.local = await conn.getLocalPortsAsync() || [];
+                return res.status(200).send(opts);
+            } catch (err) { next(err); }
+        });
+        // app.get('/config/options/screenlogic', async (req, res, next) => {
+        //     try {
+        //         let cfg = config.getSection('controller.screenlogic');
+        //         let data = {
+        //             cfg,
+        //             types: [{ val: 'local', name: 'Local', desc: 'Local Screenlogic' }, { val: 'remote', name: 'Remote', desc: 'Remote Screenlogic' }]
+        //         }
+        //         return res.status(200).send(data);
+        //     } catch (err) { next(err); }
+        // });
+        app.get('/config/options/screenlogic/search', async (req, res, next) => {
+            try {
+                let localUnits = await ScreenLogicComms.searchAsync();
+                return res.status(200).send(localUnits);
+            } catch (err) { next(err); }
         });
         app.get('/config/options/circuits', async (req, res, next) => {
             try {
@@ -156,7 +196,8 @@ export class ConfigRoute {
                     circuits: sys.board.circuits.getCircuitReferences(true, true, true, true),
                     bodies: sys.board.valueMaps.pumpBodies.toArray(),
                     pumps: sys.pumps.get(),
-                    servers: await sys.ncp.getREMServers()
+                    servers: await sys.ncp.getREMServers(),
+                    rs485ports: await conn.listInstalledPorts()
                 };
                 // RKS: Why do we need the circuit names?  We have the circuits.  Is this so
                 // that we can name the pump.  I thought that *Touch uses the pump type as the name
@@ -203,7 +244,8 @@ export class ConfigRoute {
                     heaterTypes: sys.board.valueMaps.heaterTypes.toArray(),
                     heatModes: sys.board.valueMaps.heatModes.toArray(),
                     coolDownDelay: sys.general.options.cooldownDelay,
-                    servers: []
+                    servers: [],
+                    rs485ports: await conn.listInstalledPorts()
                 };
                 // We only need the servers data when the controller is a Nixie controller.  We don't need to
                 // wait for this information if we are dealing with an OCP.
@@ -258,12 +300,34 @@ export class ConfigRoute {
                     warnings,
                     // waterFlow: sys.board.valueMaps.chemControllerWaterFlow.toArray(), // remove
                     controllers: sys.chemControllers.get(),
-                    maxChemControllers: sys.equipment.maxChemControllers
+                    maxChemControllers: sys.equipment.maxChemControllers,
+                    doserTypes: sys.board.valueMaps.chemDoserTypes.toArray()
                 };
                 return res.status(200).send(opts);
             }
             catch (err) { next(err); }
         });
+        app.get('/config/options/chemDosers', async (req, res, next) => {
+            try {
+                let remServers = await sys.ncp.getREMServers();
+                let opts = {
+                    bodies: sys.board.bodies.getBodyAssociations(),
+                    tempUnits: sys.board.valueMaps.tempUnits.toArray(),
+                    status: sys.board.valueMaps.chemDoserStatus.toArray(),
+                    pumpTypes: sys.board.valueMaps.chemPumpTypes.toArray(),
+                    volumeUnits: sys.board.valueMaps.volumeUnits.toArray(),
+                    flowSensorTypes: sys.board.valueMaps.flowSensorTypes.toArray(),
+                    remServers,
+                    dosingStatus: sys.board.valueMaps.chemDoserDosingStatus.toArray(),
+                    dosers: sys.chemDosers.get(),
+                    doserTypes: sys.board.valueMaps.chemDoserTypes.toArray(),
+                    maxChemDosers: sys.equipment.maxChemDosers
+                };
+                return res.status(200).send(opts);
+            }
+            catch (err) { next(err); }
+        });
+
         app.get('/config/options/rem', async (req, res, next) => {
             try {
                 let opts = {
@@ -283,16 +347,32 @@ export class ConfigRoute {
                 return res.status(200).send(opts);
             } catch (err) { next(err); }
         });
-        app.get('/config/options/chlorinators', (req, res) => {
-            let opts = {
-                types: sys.board.valueMaps.chlorinatorType.toArray(),
-                bodies: sys.board.bodies.getBodyAssociations(),
-                chlorinators: sys.chlorinators.get(),
-                maxChlorinators: sys.equipment.maxChlorinators,
-                models: sys.board.valueMaps.chlorinatorModel.toArray(),
-                equipmentMasters: sys.board.valueMaps.equipmentMaster.toArray()
-            };
-            return res.status(200).send(opts);
+        app.get('/config/options/anslq25ControllerType', async (req, res, next) => {
+            try {
+                let opts = {
+                    // controllerType: typeof sys.anslq25.controllerType === 'undefined' ? '' : sys.anslq25.controllerType,
+                    // model: typeof sys.anslq25.model === 'undefined' ? '' : sys.anslq25.model,
+                    // equipment: sys.equipment.get(),
+                    ...sys.anslq25.get(true),
+                    controllerTypes: sys.getAvailableControllerTypes(['easytouch', 'intellitouch', 'intellicenter']),
+                    rs485ports: await conn.listInstalledPorts()
+                }
+                return res.status(200).send(opts);
+            } catch (err) { next(err); }
+        });
+        app.get('/config/options/chlorinators', async (req, res, next) => {
+            try {
+                let opts = {
+                    types: sys.board.valueMaps.chlorinatorType.toArray(),
+                    bodies: sys.board.bodies.getBodyAssociations(),
+                    chlorinators: sys.chlorinators.get(),
+                    maxChlorinators: sys.equipment.maxChlorinators,
+                    models: sys.board.valueMaps.chlorinatorModel.toArray(),
+                    equipmentMasters: sys.board.valueMaps.equipmentMaster.toArray(),
+                    rs485ports: await conn.listInstalledPorts()
+                };
+                return res.status(200).send(opts);
+            } catch (err) { next(err); }
         });
         app.get('/config/options/dateTime', (req, res) => {
             let opts = {
@@ -310,25 +390,6 @@ export class ConfigRoute {
             let opts = config.getSection();
             return res.status(200).send(opts);
         });
-        app.get('/app/options/interfaces', (req, res) => {
-            // todo: move bytevaluemaps out to a proper location; add additional definitions
-            let opts = {
-                interfaces: config.getSection('web.interfaces'),
-                types: [
-                    { name: 'rest', desc: 'Rest' },
-                    { name: 'http', desc: 'Http' },
-                    { name: 'rem', desc: 'Relay Equipment Manager' },
-                    { name: 'mqtt', desc: 'MQTT' },
-                    { name: 'influx', desc: 'InfluxDB' }
-                ],
-                protocols: [
-                    { val: 0, name: 'http://', desc: 'http://' },
-                    { val: 1, name: 'https://', desc: 'https://' },
-                    { val: 2, name: 'mqtt://', desc: 'mqtt://' }
-                ]
-            }
-            return res.status(200).send(opts);
-        });
         app.get('/config/options/tempSensors', (req, res) => {
             let opts = {
                 tempUnits: sys.board.valueMaps.tempUnits.toArray(),
@@ -386,6 +447,13 @@ export class ConfigRoute {
                 return res.status(200).send(controller.get(true));
             } catch (err) { next(err); }
         });
+        app.put('/config/anslq25ControllerType', async (req, res, next) => {
+            try {
+                // sys.anslq25ControllerType
+                await sys.anslq25Board.setAnslq25Async(req.body);
+                return res.status(200).send(sys.anslq25.get(true));
+            } catch (err) { next(err); }
+        });
         app.delete('/config/filter', async (req, res, next) => {
             try {
                 let sfilter = await sys.board.filters.deleteFilterAsync(req.body);
@@ -507,6 +575,18 @@ export class ConfigRoute {
             }
             catch (err) { next(err); }
         });
+        // RKS: 05-20-22 This is a remnant of the old web ui.  It is not called and the setType method needed to go away.
+        //app.delete('/config/pump/:pumpId', async (req, res, next) => {
+        //    try {
+        //        let pump = sys.pumps.getItemById(parseInt(req.params.pumpId, 10));
+        //        await sys.board.pumps.deletePumpAsync()
+        //        if (pump.type === 0) {
+        //            return res.status(500).send(`Pump ${pump.id} not active`);
+        //        }
+        //        pump.setType(0);
+        //        return res.status(200).send('OK');
+        //    } catch (err) { next(err); }
+        //});
         app.delete('/config/pump', async (req, res, next) => {
             try {
                 let pump = await sys.board.pumps.deletePumpAsync(req.body);
@@ -624,14 +704,6 @@ export class ConfigRoute {
                 next(err);
             }
         });
-        app.delete('/config/pump/:pumpId', (req, res) => {
-            let pump = sys.pumps.getItemById(parseInt(req.params.pumpId, 10));
-            if (pump.type === 0) {
-                return res.status(500).send(`Pump ${pump.id} not active`);
-            }
-            pump.setType(0);
-            return res.status(200).send('OK');
-        });
         app.put('/config/dateTime', async (req, res, next) => {
             try {
                 let time = await sys.updateControllerDateTimeAsync(req.body);
@@ -692,6 +764,28 @@ export class ConfigRoute {
             }
             catch (err) { next(err); }
         });
+        app.put('/config/chemDoser', async (req, res, next) => {
+            try {
+                let doser = await sys.board.chemDosers.setChemDoserAsync(req.body);
+                return res.status(200).send(doser.get());
+            }
+            catch (err) { next(err); }
+
+        });
+        app.put('/config/chemController/calibrateDose', async (req, res, next) => {
+            try {
+                let schem = await sys.board.chemControllers.calibrateDoseAsync(req.body);
+                return res.status(200).send(schem.getExtended());
+            }
+            catch (err) { next(err); }
+        });
+        app.put('/config/chemDoser/calibrateDose', async (req, res, next) => {
+            try {
+                let schem = await sys.board.chemDosers.calibrateDoseAsync(req.body);
+                return res.status(200).send(schem.getExtended());
+            }
+            catch (err) { next(err); }
+        });
         app.put('/config/chemController/feed', async (req, res, next) => {
             try {
                 let chem = await sys.board.chemControllers.setChemControllerAsync(req.body);
@@ -705,8 +799,16 @@ export class ConfigRoute {
                 return res.status(200).send(chem.get());
             }
             catch (err) { next(err); }
+        });
+        app.delete('/config/chemDoser', async (req, res, next) => {
+            try {
+                let doser = await sys.board.chemDosers.deleteChemDoserAsync(req.body);
+                return res.status(200).send(doser.get());
+            }
+            catch (err) { next(err); }
 
         });
+
         /*         app.get('/config/intellibrite', (req, res) => {
                     return res.status(200).send(sys.intellibrite.getExtended());
                 });
@@ -756,6 +858,20 @@ export class ConfigRoute {
             }
             catch (err) { next(err); }
         });
+        // app.put('/app/screenlogic', async (req, res, next) => {
+        //     try {
+        //         let screenlogic = await sl.setScreenlogicAsync(req.body);
+        //         return res.status(200).send(screenlogic);
+        //     }
+        //     catch (err) { next(err); }
+        // });
+        app.delete('/app/rs485Port', async (req, res, next) => {
+            try {
+                let port = await conn.deleteAuxPort(req.body);
+                return res.status(200).send(port);
+            }
+            catch (err) { next(err); }
+        });
         app.get('/app/config/startPacketCapture', (req, res) => {
             startPacketCapture(true);
             return res.status(200).send('OK');
@@ -888,5 +1004,17 @@ export class ConfigRoute {
                 return res.status(200).send(results);
             } catch (err) { next(err); }
         });
+        app.put('/app/anslq25', async(req, res, next) => {
+            try {
+                await sys.anslq25Board.setAnslq25Async(req.body);
+                return res.status(200).send(sys.anslq25.get(true));
+            } catch (err) { next(err); }
+        });
+        app.delete('/app/anslq25', async(req, res, next) => {
+            try {
+                await sys.anslq25Board.deleteAnslq25Async(req.body);
+                return res.status(200).send(sys.anslq25.get(true));
+            } catch (err) { next(err); }
+        });
     }
 }

package/web/services/config/ConfigSocket.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