nodejs-poolcontroller 7.2.0 → 7.5.1

package/web/interfaces/influxInterface.ts

@@ -17,7 +17,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import extend = require("extend");
 import { ClientOptions, InfluxDB, Point, WriteApi, WritePrecisionType } from '@influxdata/influxdb-client';
-import { utils } from '../../controller/Constants';
+import { utils, Timestamp } from '../../controller/Constants';
 import { logger } from "../../logger/Logger";
 import { BaseInterfaceBindings, InterfaceContext, InterfaceEvent } from "./baseInterface";
 export class InfluxInterfaceBindings extends BaseInterfaceBindings {
@@ -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 => {
@@ -79,7 +92,7 @@ export class InfluxInterfaceBindings extends BaseInterfaceBindings {
                         this.buildTokens(e.filter, evt, toks, e, data[0]);
                         if (eval(this.replaceTokens(e.filter, toks)) === false) continue;
                     }
-                    for (let j = 0; j < e.points.length; j++){
+                    for (let j = 0; j < e.points.length; j++) {
                         let _point = e.points[j];
                         // Figure out whether we need to check the filter for each point.
                         if (typeof _point.filter !== 'undefined') {
@@ -105,40 +118,68 @@ export class InfluxInterfaceBindings extends BaseInterfaceBindings {
                             }
                         })
                         _point.fields.forEach(_field => {
-                            let sname = _field.name;
-                            this.buildTokens(sname, evt, toks, e, data[0]);
-                            //console.log(toks);
-                            sname = this.replaceTokens(sname, toks);
-                            let svalue = _field.value;
-                            this.buildTokens(svalue, evt, toks, e, data[0]);
-                            svalue = this.replaceTokens(svalue, toks);
-                            if (typeof sname !== 'undefined' && typeof svalue !== 'undefined' && !sname.includes('@bind') && !svalue.includes('@bind') && svalue !== null)
-                                switch (_field.type) {
-                                    case 'int':
-                                    case 'integer':
-                                        let int = parseInt(svalue, 10);
-                                        if (!isNaN(int)) point.intField(sname, int);
-                                        // if (!isNaN(int) && typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.intField(sname, int);
-                                        break;
-                                    case 'string':
-                                        point.stringField(sname, svalue);
-                                        // if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.stringField(sname, svalue);
-                                        break;
-                                    case 'boolean':
-                                        point.booleanField(sname, utils.makeBool(svalue));
-                                        if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.booleanField(sname, !utils.makeBool(svalue));
-                                        break;
-                                    case 'float':
-                                        let float = parseFloat(svalue);
-                                        if (!isNaN(float)) point.floatField(sname, float);
-                                        // if (!isNaN(float) && typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.intField(sname, int);
-                                        break;
+                            try {
+                                let sname = _field.name;
+                                this.buildTokens(sname, evt, toks, e, data[0]);
+                                //console.log(toks);
+                                sname = this.replaceTokens(sname, toks);
+                                let svalue = _field.value;
+                                this.buildTokens(svalue, evt, toks, e, data[0]);
+                                svalue = this.replaceTokens(svalue, toks);
+                                if (typeof sname !== 'undefined' && typeof svalue !== 'undefined' && !sname.includes('@bind') && !svalue.includes('@bind') && svalue !== null)
+                                    switch (_field.type) {
+                                        case 'int':
+                                        case 'integer':
+                                            let int = parseInt(svalue, 10);
+                                            if (!isNaN(int)) point.intField(sname, int);
+                                            // if (!isNaN(int) && typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.intField(sname, int);
+                                            break;
+                                        case 'string':
+                                            point.stringField(sname, svalue);
+                                            // if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.stringField(sname, svalue);
+                                            break;
+                                        case 'boolean':
+                                            point.booleanField(sname, utils.makeBool(svalue));
+                                            if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.booleanField(sname, !utils.makeBool(svalue));
+                                            break;
+                                        case 'float':
+                                            let float = parseFloat(svalue);
+                                            if (!isNaN(float)) point.floatField(sname, float);
+                                            // if (!isNaN(float) && typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.intField(sname, int);
+                                            break;
+                                        case 'timestamp':
+                                        case 'datetime':
+                                        case 'date':
+                                            //let dt = Date.parse(svalue.replace(/^["'](.+(?=["']$))["']$/, '$1'));
+                                            // RKS: 07-06-21 - I think this is missing the eval function around all of this. The strings still have the quotes around them.  I think
+                                            // maybe we need to create a closure and execute it as a code segment for variable data.
+                                            let sdt = eval(svalue);
+                                            if (sdt !== null && typeof sdt !== 'undefined') {
+                                                let dt = Date.parse(sdt);
+                                                if (!isNaN(dt)) point.intField(sname, dt);
+                                                else if (svalue !== '') logger.warn(`Influx error parsing date from ${sname}: ${svalue}`);
+                                            }
+                                            break;
+                                    }
+                                else {
+                                    logger.error(`InfluxDB point binding failure on ${evt}:${_field.name}/${_field.value} --> ${svalue || 'undefined'}`);
                                 }
-                            else {
-                                logger.error(`InfluxDB point binding failure on ${evt}:${_field.name}/${_field.value} --> ${svalue || 'undefined'}`);
-                            }
-                        })
-                        point.timestamp(new Date());
+                            } catch (err) { logger.error(`Error binding InfluxDB point fields ${err.message}`); }
+                        });
+                        if (typeof _point.series !== 'undefined') {
+                            try {
+                                this.buildTokens(_point.series.value, evt, toks, e, data[0]);
+                                let ser = eval(this.replaceTokens(_point.series.value, toks));
+                                let ts = Date.parse(ser);
+                                if (isNaN(ts)) {
+                                    logger.error(`Influx series timestamp is invalid ${ser}`);
+                                }
+                                else
+                                    point.timestamp(new Date(ts));
+                            } catch (err) { logger.error(`Error parsing Influx point series for ${evt} - ${_point.series.value}`); }
+                        }
+                        else
+                            point.timestamp(new Date());
                         try {
 
                             if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) {
@@ -147,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 {
@@ -176,6 +221,7 @@ class InfluxInterfaceEvent extends InterfaceEvent {
 
 export interface IPoint {
     measurement: string;
+    series?: ISeries;
     tags: ITag[];
     fields: IFields[];
     storePrevState?: boolean;
@@ -190,3 +236,6 @@ export interface IFields {
     value: string;
     type: string;
 }
+export interface ISeries {
+    value: string;
+}

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 = () => {
@@ -260,7 +260,7 @@ export class MqttInterfaceBindings extends BaseInterfaceBindings {
                                 if (typeof t.lastSent === 'undefined') t.lastSent = [];
                                 let lm = t.lastSent.find(elem => elem.topic === topic);
                                 if (typeof lm === 'undefined' || lm.message !== message) {
-                                    this.client.publish(topic, message, publishOptions);
+                                    setImmediate(() => { this.client.publish(topic, message, publishOptions); });
                                     logger.silly(`MQTT send:\ntopic: ${topic}\nmessage: ${message}\nopts:${JSON.stringify(publishOptions)}`);
                                 }
                                 if (typeof lm === 'undefined') t.lastSent.push({ topic: topic, message: message });
@@ -269,7 +269,7 @@ export class MqttInterfaceBindings extends BaseInterfaceBindings {
                             }
                             else {
                                 logger.silly(`MQTT send:\ntopic: ${topic}\nmessage: ${message}\nopts:${JSON.stringify(publishOptions)}`);
-                                this.client.publish(topic, message, publishOptions);
+                                setImmediate(() => { this.client.publish(topic, message, publishOptions); });
                                 if (typeof t.lastSent !== 'undefined') t.lastSent = undefined;
                             }
 
@@ -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,14 +57,15 @@ 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);
         });
         app.get('/config/options/rs485', (req, res) => {
             let opts = {
-                port: config.getSection('comms', { enabled: false, netConnect: false }),
-                portStatus: conn.buffer.counter
+                port: config.getSection('controller.comms', { enabled: false, netConnect: false }),
+                stats: conn.buffer.counter
             };
             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);
         });
@@ -239,6 +246,7 @@ export class ConfigRoute {
                     phSupplyTypes: sys.board.valueMaps.phSupplyTypes.toArray(),
                     volumeUnits: sys.board.valueMaps.volumeUnits.toArray(),
                     dosingMethods: sys.board.valueMaps.chemDosingMethods.toArray(),
+                    chlorDosingMethods: sys.board.valueMaps.chemChlorDosingMethods.toArray(),
                     orpProbeTypes: sys.board.valueMaps.chemORPProbeTypes.toArray(),
                     phProbeTypes: sys.board.valueMaps.chemPhProbeTypes.toArray(),
                     flowSensorTypes: sys.board.valueMaps.flowSensorTypes.toArray(),
@@ -280,7 +288,9 @@ export class ConfigRoute {
                 types: sys.board.valueMaps.chlorinatorType.toArray(),
                 bodies: sys.board.bodies.getBodyAssociations(),
                 chlorinators: sys.chlorinators.get(),
-                maxChlorinators: sys.equipment.maxChlorinators
+                maxChlorinators: sys.equipment.maxChlorinators,
+                models: sys.board.valueMaps.chlorinatorModel.toArray(),
+                equipmentMasters: sys.board.valueMaps.equipmentMaster.toArray()
             };
             return res.status(200).send(opts);
         });
@@ -305,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);
@@ -330,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();
@@ -338,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 {
@@ -360,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); }
@@ -373,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); }
@@ -587,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) => {
@@ -725,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
@@ -758,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);
@@ -790,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'));
         });
@@ -826,11 +841,18 @@ 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 {
+                let port = await conn.setPortAsync(req.body);
+                return res.status(200).send(port);
+            }
+            catch (err) { next(err); }
         });
         app.get('/app/config/startPacketCapture', (req, res) => {
             startPacketCapture(true);
@@ -840,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); }
+        });
     }
 }