nodejs-poolcontroller 7.3.0 → 7.6.0

package/web/interfaces/influxInterface.ts

@@ -25,33 +25,46 @@ export class InfluxInterfaceBindings extends BaseInterfaceBindings {
         super(cfg);
     }
     private writeApi: WriteApi;
-    public context: InterfaceContext;
-    public cfg;
-    public events: InfluxInterfaceEvent[];
+    declare context: InterfaceContext;
+    declare cfg;
+    declare events: InfluxInterfaceEvent[];
     private init = () => {
         let baseOpts = extend(true, this.cfg.options, this.context.options);
+        let url = 'http://';
+        if (typeof baseOpts.protocol !== 'undefined' && baseOpts.protocol) url = baseOpts.protocol;
+        if (!url.endsWith('://')) url += '://';
+        url = `${url}${baseOpts.host}:${baseOpts.port}`;
+        let influxDB: InfluxDB;
+        let bucket;
+        let org;
         if (typeof baseOpts.host === 'undefined' || !baseOpts.host) {
             logger.warn(`Interface: ${this.cfg.name} has not resolved to a valid host.`);
             return;
         }
-        if (typeof baseOpts.database === 'undefined' || !baseOpts.database) {
-            logger.warn(`Interface: ${this.cfg.name} has not resolved to a valid database.`);
-            return;
+        if (baseOpts.version === 1) {
+            if (typeof baseOpts.database === 'undefined' || !baseOpts.database) {
+                logger.warn(`Interface: ${this.cfg.name} has not resolved to a valid database.`);
+                return;
+            }
+            bucket = `${baseOpts.database}/${baseOpts.retentionPolicy}`;
+            const clientOptions: ClientOptions = {
+                url,
+                token: `${baseOpts.username}:${baseOpts.password}`,
+            }
+            influxDB = new InfluxDB(clientOptions);
         }
-        // let opts = extend(true, baseOpts, e.options);
-        let url = 'http';
-        if (typeof baseOpts.protocol !== 'undefined' && baseOpts.protocol) url = baseOpts.protocol;
-        url = `${url}://${baseOpts.host}:${baseOpts.port}`;
-        // TODO: add username/password
-        const bucket = `${baseOpts.database}/${baseOpts.retentionPolicy}`;
-        const clientOptions: ClientOptions = {
-            url,
-            token: `${baseOpts.username}:${baseOpts.password}`,
+        else if (baseOpts.version === 2) {
+            org = baseOpts.org;
+            bucket = baseOpts.bucket;
+            const clientOptions: ClientOptions = {
+                url,
+                token: baseOpts.token,
+            }
+            influxDB = new InfluxDB(clientOptions);
         }
-        const influxDB = new InfluxDB(clientOptions);
-        this.writeApi = influxDB.getWriteApi('', bucket, 'ms' as WritePrecisionType);
-        
-       
+        this.writeApi = influxDB.getWriteApi(org, bucket, 'ms');
+
+
         // set global tags from context
         let baseTags = {}
         baseOpts.tags.forEach(tag => {
@@ -175,10 +188,14 @@ export class InfluxInterfaceBindings extends BaseInterfaceBindings {
                                 let sec = ts.getSeconds() - 1;
                                 ts.setSeconds(sec);
                                 point2.timestamp(ts);
+                                logger.silly(`Writing influx ${e.name} inverse data point ${point2.toString()})`)
                                 this.writeApi.writePoint(point2);
                             }
                             if (typeof point.toLineProtocol() !== 'undefined') {
+                                logger.silly(`Writing influx ${e.name} data point ${point.toString()}`)
                                 this.writeApi.writePoint(point);
+                                this.writeApi.flush()
+                                    .catch(error => { logger.error(error); });
                                 //logger.info(`INFLUX: ${point.toLineProtocol()}`)
                             }
                             else {

package/web/interfaces/mqttInterface.ts

@@ -36,7 +36,7 @@ export class MqttInterfaceBindings extends BaseInterfaceBindings {
     }
     private client: MqttClient;
     private topics: string[] = [];
-    public events: MqttInterfaceEvent[];
+    declare events: MqttInterfaceEvent[];
     private subscribed: boolean; // subscribed to events or not
     private sentInitialMessages = false;
     private init = () => {
@@ -370,7 +370,18 @@ export class MqttInterfaceBindings extends BaseInterfaceBindings {
                                     logger.error(new ServiceParameterError(`Cannot set body setPoint.  You must supply a valid id, circuit, name, or type for the body`, 'body', 'id', msg.id));
                                     return;
                                 }
-                                let tbody = await sys.board.bodies.setHeatSetpointAsync(body, parseInt(msg.setPoint, 10));
+                                if (typeof msg.setPoint !== 'undefined' || typeof msg.heatSetpoint !== 'undefined') {
+                                    let setPoint = parseInt(msg.setPoint, 10) || parseInt(msg.heatSetpoint, 10);
+                                    if (!isNaN(setPoint)) {
+                                        await sys.board.bodies.setHeatSetpointAsync(body, setPoint);
+                                    }
+                                }
+                                if (typeof msg.coolSetpoint !== 'undefined') {
+                                    let setPoint = parseInt(msg.coolSetpoint, 10);
+                                    if (!isNaN(setPoint)) {
+                                        await sys.board.bodies.setCoolSetpointAsync(body, setPoint);
+                                    }
+                                }
                             }
                         }
                         catch (err) { logger.error(err); }
@@ -412,7 +423,7 @@ export class MqttInterfaceBindings extends BaseInterfaceBindings {
                         break;
                     case 'settheme':
                         try {
-                            let theme = await state.circuits.setLightThemeAsync(parseInt(msg.id, 10), parseInt(msg.theme, 10));
+                            let theme = await state.circuits.setLightThemeAsync(parseInt(msg.id, 10), sys.board.valueMaps.lightThemes.encode(msg.theme));
                         }
                         catch (err) { logger.error(err); }
                         break;

package/web/services/config/Config.ts

@@ -14,16 +14,21 @@ 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 fs from "fs";
 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 { config } from "../../../config/Config";
 import { logger } from "../../../logger/Logger";
 import { utils } from "../../../controller/Constants";
+import { ServiceProcessError } from "../../../controller/Errors";
 import { state } from "../../../controller/State";
 import { stopPacketCaptureAsync, startPacketCapture } from '../../../app';
 import { conn } from "../../../controller/comms/Comms";
-import { webApp } from "../../Server";
+import { webApp, BackupFile, RestoreFile } from "../../Server";
+import { release } from "os";
 
 export class ConfigRoute {
     public static initRoutes(app: express.Application) {
@@ -52,7 +57,8 @@ export class ConfigRoute {
                 clockSources: sys.board.valueMaps.clockSources.toArray(),
                 clockModes: sys.board.valueMaps.clockModes.toArray(),
                 pool: sys.general.get(true),
-                sensors: sys.board.system.getSensors()
+                sensors: sys.board.system.getSensors(),
+                systemUnits: sys.board.valueMaps.systemUnits.toArray()
             };
             return res.status(200).send(opts);
         });
@@ -106,7 +112,7 @@ export class ConfigRoute {
                 invalidIds: sys.board.equipmentIds.invalidIds.get(),
                 equipmentIds: sys.equipment.equipmentIds.features,
                 equipmentNames: sys.board.circuits.getCircuitNames(),
-                functions: sys.board.valueMaps.featureFunctions.toArray(),
+                functions: sys.board.features.getFeatureFunctions(),
                 features: sys.features.get()
             };
             return res.status(200).send(opts);
@@ -115,7 +121,8 @@ export class ConfigRoute {
             let opts = {
                 maxBodies: sys.equipment.maxBodies,
                 bodyTypes: sys.board.valueMaps.bodies.toArray(),
-                bodies: sys.bodies.get()
+                bodies: sys.bodies.get(),
+                capacityUnits: sys.board.valueMaps.volumeUnits.toArray()
             };
             return res.status(200).send(opts);
         });
@@ -282,7 +289,8 @@ export class ConfigRoute {
                 bodies: sys.board.bodies.getBodyAssociations(),
                 chlorinators: sys.chlorinators.get(),
                 maxChlorinators: sys.equipment.maxChlorinators,
-                models: sys.board.valueMaps.chlorinatorModel.toArray()
+                models: sys.board.valueMaps.chlorinatorModel.toArray(),
+                equipmentMasters: sys.board.valueMaps.equipmentMaster.toArray()
             };
             return res.status(200).send(opts);
         });
@@ -307,13 +315,16 @@ export class ConfigRoute {
             let opts = {
                 interfaces: config.getSection('web.interfaces'),
                 types: [
-                    {name: 'rem', desc: 'Relay Equipment Manager'},
-                    {name: 'mqtt', desc: 'MQTT'}
+                    { 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://' },
+                    { val: 2, name: 'mqtt://', desc: 'mqtt://' }
                 ]
             }
             return res.status(200).send(opts);
@@ -332,6 +343,8 @@ export class ConfigRoute {
                     bodies: sys.board.bodies.getBodyAssociations(),
                     filters: sys.filters.get(),
                     areaUnits: sys.board.valueMaps.areaUnits.toArray(),
+                    pressureUnits: sys.board.valueMaps.pressureUnits.toArray(),
+                    circuits: sys.board.circuits.getCircuitReferences(true, true, true, false),
                     servers: []
                 };
                 if (sys.controllerType === ControllerType.Nixie) opts.servers = await sys.ncp.getREMServers();
@@ -340,14 +353,14 @@ export class ConfigRoute {
         });
         /******* END OF CONFIGURATION PICK LISTS/REFERENCES AND VALIDATION ***********/
         /******* ENDPOINTS FOR MODIFYING THE OUTDOOR CONTROL PANEL SETTINGS **********/
-        app.put('/config/rem', async (req, res, next)=>{
+        app.put('/config/rem', async (req, res, next) => {
             try {
                 // RSG: this is problematic because we now enable multiple rem type interfaces that may not be called REM. 
                 // This is now also a dupe of PUT /app/interface and should be consolidated
                 // config.setSection('web.interfaces.rem', req.body);
                 config.setInterface(req.body);
             }
-            catch (err) {next(err);}
+            catch (err) { next(err); }
         })
         app.put('/config/tempSensors', async (req, res, next) => {
             try {
@@ -362,7 +375,7 @@ export class ConfigRoute {
         });
         app.put('/config/filter', async (req, res, next) => {
             try {
-                let sfilter = sys.board.filters.setFilter(req.body);
+                let sfilter = await sys.board.filters.setFilterAsync(req.body);
                 return res.status(200).send(sfilter.get(true));
             }
             catch (err) { next(err); }
@@ -375,7 +388,7 @@ export class ConfigRoute {
         });
         app.delete('/config/filter', async (req, res, next) => {
             try {
-                let sfilter = sys.board.filters.deleteFilter(req.body);
+                let sfilter = await sys.board.filters.deleteFilterAsync(req.body);
                 return res.status(200).send(sfilter.get(true));
             }
             catch (err) { next(err); }
@@ -579,8 +592,8 @@ export class ConfigRoute {
             return res.status(200).send(circuitFunctions);
         });
         app.get('/config/features/functions', (req, res) => {
-            let circuitFunctions = sys.board.circuits.getCircuitFunctions();
-            return res.status(200).send(circuitFunctions);
+            let featureFunctions = sys.board.features.getFeatureFunctions();
+            return res.status(200).send(featureFunctions);
         });
         app.get('/config/circuit/:id', (req, res) => {
             // todo: need getInterfaceById.get() in case features are requested here
@@ -589,7 +602,7 @@ export class ConfigRoute {
         });
         app.get('/config/circuit/:id/lightThemes', (req, res) => {
             let circuit = sys.circuits.getInterfaceById(parseInt(req.params.id, 10));
-            let themes = typeof circuit !== 'undefined' && typeof circuit.getLightThemes === 'function' ? circuit.getLightThemes() : [];
+            let themes = typeof circuit !== 'undefined' && typeof circuit.getLightThemes === 'function' ? circuit.getLightThemes(circuit.type) : [];
             return res.status(200).send(themes);
         });
         app.get('/config/chlorinator/:id', (req, res) => {
@@ -727,7 +740,7 @@ export class ConfigRoute {
             // RSG: is this and /config/circuit/:id/lightThemes both needed?
 
             // if (sys.controllerType === ControllerType.IntelliCenter) {
-            let grp = sys.lightGroups.getItemById(parseInt(req.params.id, 10));
+            let grp = sys.lightGroups.getItemById(parseInt(req.body.id, 10));
             return res.status(200).send(grp.getLightThemes());
             // }
             // else
@@ -760,16 +773,16 @@ export class ConfigRoute {
             let grp = sys.circuitGroups.getItemById(parseInt(req.params.id, 10));
             return res.status(200).send(grp.getExtended());
         });
-/*         app.get('/config/chemController/search', async (req, res, next) => {
-            // Change the options for the pool.
-            try {
-                let result = await sys.board.virtualChemControllers.search();
-                return res.status(200).send(result);
-            }
-            catch (err) {
-                next(err);
-            }
-        }); */
+        /*         app.get('/config/chemController/search', async (req, res, next) => {
+                    // Change the options for the pool.
+                    try {
+                        let result = await sys.board.virtualChemControllers.search();
+                        return res.status(200).send(result);
+                    }
+                    catch (err) {
+                        next(err);
+                    }
+                }); */
         app.put('/config/chemController', async (req, res, next) => {
             try {
                 let chem = await sys.board.chemControllers.setChemControllerAsync(req.body);
@@ -792,17 +805,17 @@ export class ConfigRoute {
             catch (err) { next(err); }
 
         });
-/*         app.get('/config/intellibrite', (req, res) => {
-            return res.status(200).send(sys.intellibrite.getExtended());
-        });
-        app.get('/config/intellibrite/colors', (req, res) => {
-            return res.status(200).send(sys.board.valueMaps.lightColors.toArray());
-        });
-        app.put('/config/intellibrite/setColors', (req, res) => {
-            let grp = extend(true, { id: 0 }, req.body);
-            sys.board.circuits.setIntelliBriteColors(new LightGroup(grp));
-            return res.status(200).send('OK');
-        }); */
+        /*         app.get('/config/intellibrite', (req, res) => {
+                    return res.status(200).send(sys.intellibrite.getExtended());
+                });
+                app.get('/config/intellibrite/colors', (req, res) => {
+                    return res.status(200).send(sys.board.valueMaps.lightColors.toArray());
+                });
+                app.put('/config/intellibrite/setColors', (req, res) => {
+                    let grp = extend(true, { id: 0 }, req.body);
+                    sys.board.circuits.setIntelliBriteColors(new LightGroup(grp));
+                    return res.status(200).send('OK');
+                }); */
         app.get('/config', (req, res) => {
             return res.status(200).send(sys.getSection('all'));
         });
@@ -828,11 +841,11 @@ export class ConfigRoute {
             return res.status(200).send('OK');
         });
         app.put('/app/interface', async (req, res, next) => {
-           try{
-            await webApp.updateServerInterface(req.body);
-            return res.status(200).send('OK');
-        }
-        catch (err) {next(err);}
+            try {
+                let iface = await webApp.updateServerInterface(req.body);
+                return res.status(200).send(iface);
+            }
+            catch (err) { next(err); }
         });
         app.put('/app/rs485Port', async (req, res, next) => {
             try {
@@ -849,15 +862,129 @@ export class ConfigRoute {
             startPacketCapture(false);
             return res.status(200).send('OK');
         });
-        app.get('/app/config/stopPacketCapture', async (req, res,next) => {
+        app.get('/app/config/stopPacketCapture', async (req, res, next) => {
             try {
                 let file = await stopPacketCaptureAsync();
                 res.download(file);
             }
-            catch (err) {next(err);}
+            catch (err) { next(err); }
         });
         app.get('/app/config/:section', (req, res) => {
             return res.status(200).send(config.getSection(req.params.section));
         });
+        app.get('/app/config/options/backup', async (req, res, next) => {
+            try {
+                let opts = config.getSection('controller.backups', { automatic: false, interval: { days: 30, hours: 0 }, keepCount: 5, servers: [] });
+                let servers = await sys.ncp.getREMServers();
+                if (typeof servers !== 'undefined') {
+                    // Just in case somebody deletes the backup section and doesn't put it back properly.
+                    for (let i = 0; i < servers.length; i++) {
+                        let srv = servers[i];
+                        if (typeof opts.servers.find(elem => elem.uuid === srv.uuid) === 'undefined') opts.servers.push({ name: srv.name, uuid: srv.uuid, backup: false, host: srv.interface.options.host });
+                    }
+                    for (let i = opts.servers.length - 1; i >= 0; i--) {
+                        let srv = opts.servers[i];
+                        if (typeof servers.find(elem => elem.uuid === srv.uuid) === 'undefined') opts.servers.splice(i, 1);
+                    }
+                }
+                if (typeof opts.servers === 'undefined') opts.servers = [];
+                return res.status(200).send(opts);
+            } catch (err) { next(err); }
+        });
+        app.get('/app/config/options/restore', async (req, res, next) => {
+            try {
+                let opts = config.getSection('controller.backups', { automatic: false, interval: { days: 30, hours: 0 }, keepCount: 5, servers: [], backupFiles: [] });
+                let servers = await sys.ncp.getREMServers();
+                if (typeof servers !== 'undefined') {
+                    for (let i = 0; i < servers.length; i++) {
+                        let srv = servers[i];
+                        if (typeof opts.servers.find(elem => elem.uuid === srv.uuid) === 'undefined') opts.servers.push({ name: srv.name, uuid: srv.uuid, backup: false });
+                    }
+                    for (let i = opts.servers.length - 1; i >= 0; i--) {
+                        let srv = opts.servers[i];
+                        if (typeof servers.find(elem => elem.uuid === srv.uuid) === 'undefined') opts.servers.splice(i, 1);
+                    }
+                }
+                if (typeof opts.servers === 'undefined') opts.servers = [];
+                opts.backupFiles = await webApp.readBackupFiles();
+                return res.status(200).send(opts);
+            } catch (err) { next(err); }
+
+        });
+        app.put('/app/config/options/backup', async (req, res, next) => {
+            try {
+                config.setSection('controller.backups', req.body);
+                let opts = config.getSection('controller.backups', { automatic: false, interval: { days: 30, hours: 0 }, keepCount: 5, servers: [] });
+                webApp.autoBackup = utils.makeBool(opts.automatic);
+                await webApp.checkAutoBackup();
+                return res.status(200).send(opts);
+            } catch (err) { next(err); }
+
+        });
+        app.put('/app/config/createBackup', async (req, res, next) => {
+            try {
+                let ret = await webApp.backupServer(req.body);
+                res.download(ret.filePath);
+            }
+            catch (err) { next(err); }
+        });
+        app.delete('/app/backup/file', async (req, res, next) => {
+            try {
+                let opts = req.body;
+                fs.unlinkSync(opts.filePath);
+                return res.status(200).send(opts);
+            }
+            catch (err) { next(err); }
+        });
+        app.post('/app/backup/file', async (req, res, next) => {
+            try {
+                let file = multer({
+                    limits: { fileSize: 1000000  },
+                    storage: multer.memoryStorage()
+                }).single('backupFile');
+                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 BackupFile.fromBuffer(req.file.originalname, req.file.buffer);
+                            if (typeof bf === 'undefined') {
+                                err = new ServiceProcessError(`Invalid backup file: ${req.file.originalname}`, 'POST: app/backup/file', 'extractBackupOptions');
+                                next(err);
+                            }
+                            else {
+                                if (fs.existsSync(bf.filePath))
+                                    return next(new ServiceProcessError(`File already exists ${req.file.originalname}`, 'POST: app/backup/file', 'writeFile'));
+                                else {
+                                    try {
+                                        fs.writeFileSync(bf.filePath, req.file.buffer);
+                                    } catch (e) { logger.error(`Error writing backup 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); }
+        });
+        app.put('/app/restore/validate', async (req, res, next) => {
+            try {
+                // Validate all the restore options.
+                let opts = req.body;
+                let ctx = await webApp.validateRestore(opts);
+                return res.status(200).send(ctx);
+            } catch (err) { next(err); }
+        });
+        app.put('/app/restore/file', async (req, res, next) => {
+            try {
+                let opts = req.body;
+                let results = await webApp.restoreServers(opts);
+                return res.status(200).send(results);
+            } catch (err) { next(err); }
+        });
     }
 }

package/web/services/state/State.ts

@@ -15,6 +15,8 @@ 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 express from "express";
+import * as extend from "extend";
+
 import { state, ICircuitState, LightGroupState, ICircuitGroupState, ChemicalDoseState } from "../../../controller/State";
 import { sys } from "../../../controller/Equipment";
 import { utils } from '../../../controller/Constants';
@@ -79,7 +81,21 @@ export class StateRoute {
             catch (err) { next(err); }
 
         });
-        app.search('/state/chemController/:id/doseHistory/ph', async (req, res, next) => {
+        app.get('/state/chemController/:id/doseLog/ph', async (req, res, next) => {
+            try {
+                let schem = state.chemControllers.getItemById(parseInt(req.params.id));
+                let filter = req.body || {};
+                let dh = await DataLogger.readFromEndAsync(`chemDosage_${schem.ph.chemType}.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));
                 let filter = req.body || {};
@@ -93,6 +109,34 @@ export class StateRoute {
             }
             catch (err) { next(err); }
         });
+        app.get('/state/chemController/:id/doseLog/orp', async (req, res, next) => {
+            try {
+                let schem = state.chemControllers.getItemById(parseInt(req.params.id));
+                let filter = req.body || {};
+                let dh = await DataLogger.readFromEndAsync(`chemDosage_orp.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/orp', async (req, res, next) => {
+            try {
+                let schem = state.chemControllers.getItemById(parseInt(req.params.id));
+                let filter = req.body || {};
+                let dh = DataLogger.readFromEnd(`chemDosage_orp.log`, ChemicalDoseState, (lineNumber: number, entry: ChemicalDoseState, arr: ChemicalDoseState[]): boolean => {
+                    if (entry.id !== schem.id) return;
+                    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.put('/state/chemController/cancelDosing', async (req, res, next) => {
             try {
                 let schem = await sys.board.chemControllers.cancelDosingAsync(req.body);
@@ -109,7 +153,7 @@ export class StateRoute {
         });
 
         app.get('/state/chlorinator/:id', (req, res) => {
-            res.status(200).send(state.chlorinators.getItemById(parseInt(req.params.id, 10)).get());
+            res.status(200).send(state.chlorinators.getItemById(parseInt(req.params.id, 10), false).getExtended());
         });
         app.get('/state/circuit/:id', (req, res) => {
             res.status(200).send(state.circuits.getItemById(parseInt(req.params.id, 10)).get());
@@ -165,8 +209,8 @@ export class StateRoute {
             catch (err) {next(err);}
         });    
         app.put('/state/circuit/setTheme', async (req, res, next) => {
-           try {
-               let theme = await state.circuits.setLightThemeAsync(parseInt(req.body.id, 10), parseInt(req.body.theme, 10));
+            try {
+                let theme = await state.circuits.setLightThemeAsync(parseInt(req.body.id, 10), sys.board.valueMaps.lightThemes.encode(req.body.theme));
                return res.status(200).send(theme.get(true));
             } 
             catch (err) { next(err); }
@@ -229,7 +273,7 @@ export class StateRoute {
                 if (typeof req.body.heatSetpoint !== 'undefined' && !isNaN(parseInt(req.body.heatSetpoint, 10)))
                     await sys.board.bodies.setHeatSetpointAsync(body, parseInt(req.body.heatSetpoint, 10));
                 else if (typeof req.body.setPoint !== 'undefined' && !isNaN(parseInt(req.body.setPoint, 10)))
-                    await sys.board.bodies.setHeatSetpointAsync(body, parseInt(req.body.heatSetpoint, 10));
+                    await sys.board.bodies.setHeatSetpointAsync(body, parseInt(req.body.setpoint, 10));
                 let tbody = state.temps.bodies.getItemById(body.id);
                 return res.status(200).send(tbody.get(true));
             } catch (err) { next(err); }

package/web/services/state/StateSocket.ts

@@ -74,6 +74,7 @@ export class StateSocket {
             }
             catch (err) { logger.error(err); }
         });
+        
         sock.on('/chlorinator', async (data: any) => {
             try {
                 data = JSON.parse(data);
@@ -99,6 +100,22 @@ export class StateSocket {
             }
             catch (err) { logger.error(err); }
         });
+        sock.on('/filter', async (data: any) => {
+            try {
+                data = JSON.parse(data);
+                let id = parseInt(data.id, 10);
+                let filter = sys.filters.find(elem => elem.id === id);
+                if (typeof filter !== 'undefined' && filter.isActive && !isNaN(filter.id)) {
+                    let sfilter = state.filters.getItemById(filter.id, filter.isActive)
+                    let pu = sys.board.valueMaps.pressureUnits.transform(filter.pressureUnits);
+                    if (typeof data.pressure !== 'undefined')
+                        await sys.board.filters.setFilterPressure(filter.id, data.pressure, data.pressureUnits || pu.name);
+                    sfilter.emitEquipmentChange();
+                }
+
+                
+            } catch (err) { logger.error(err); }
+        });
         sock.on('/chemController', async (data: any) => {
             try {
                 //console.log(`chemController: ${data}`);
@@ -144,7 +161,7 @@ export class StateSocket {
                         if (typeof data.orpTank.units === 'string') scontroller.orp.tank.units = controller.orp.tank.units = data.orpTank.units;
                     }
 
-                    // Need to build this out to include the type of controller.  If this is Homegrown or REM Chem we
+                    // 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.
                     if (controller.type === 3) {