nodejs-poolcontroller 7.2.0 → 7.5.1

package/controller/boards/SystemBoard.ts

@@ -16,14 +16,14 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 import * as extend from 'extend';
 import { logger } from '../../logger/Logger';
-import { webApp } from '../../web/Server';
-import { conn } from '../comms/Comms';
-import { ncp } from "../nixie/Nixie"
-import { Message, Outbound, Protocol, Response } from '../comms/messages/Messages';
-import { utils, Heliotrope, Timestamp } from '../Constants';
-import { Body, ChemController, Chlorinator, Circuit, CircuitGroup, CircuitGroupCircuit, ConfigVersion, CustomName, CustomNameCollection, EggTimer, Feature, General, Heater, ICircuit, LightGroup, LightGroupCircuit, Location, Options, Owner, PoolSystem, Pump, Schedule, sys, Valve, ControllerType, TempSensorCollection, Filter, Equipment } from '../Equipment';
-import { EquipmentNotFoundError, InvalidEquipmentDataError, InvalidEquipmentIdError, ParameterOutOfRangeError } from '../Errors';
-import { BodyTempState, ValveState, ChemControllerState, ChlorinatorState, ICircuitGroupState, ICircuitState, LightGroupState, PumpState, state, TemperatureState, VirtualCircuitState, HeaterState, ScheduleState, FilterState, ChemicalState, CircuitGroupState, CircuitState } from '../State';
+import { Message, Outbound } from '../comms/messages/Messages';
+import { Timestamp, utils } from '../Constants';
+import { Body, ChemController, Chlorinator, Circuit, CircuitGroup, CircuitGroupCircuit, ConfigVersion, ControllerType, CustomName, CustomNameCollection, EggTimer, Equipment, Feature, Filter, General, Heater, ICircuit, LightGroup, LightGroupCircuit, Location, Options, Owner, PoolSystem, Pump, Schedule, sys, TempSensorCollection, Valve } from '../Equipment';
+import { EquipmentNotFoundError, InvalidEquipmentDataError, InvalidEquipmentIdError } from '../Errors';
+import { ncp } from "../nixie/Nixie";
+import { BodyTempState, ChemControllerState, ChlorinatorState, CircuitGroupState, FilterState, ICircuitGroupState, ICircuitState, LightGroupState, ScheduleState, state, TemperatureState, ValveState, VirtualCircuitState } from '../State';
+import { RestoreResults } from '../../web/Server';
+
 
 export class byteValueMap extends Map<number, any> {
   public transform(byte: number, ext?: number) { return extend(true, { val: byte || 0 }, this.get(byte) || this.get(0)); }
@@ -218,10 +218,10 @@ export class byteValueMaps {
   ]);
   public panelModes: byteValueMap = new byteValueMap([
     [0, { val: 0, name: 'auto', desc: 'Auto' }],
-    [1, { val: 1, name: 'service', desc: 'Service' }],
-    [8, { val: 8, name: 'freeze', desc: 'Freeze' }],
-    [128, { val: 128, name: 'timeout', desc: 'Timeout' }],
-    [129, { val: 129, name: 'service-timeout', desc: 'Service/Timeout' }],
+    // [1, { val: 1, name: 'service', desc: 'Service' }],
+    // [8, { val: 8, name: 'freeze', desc: 'Freeze' }],
+    // [128, { val: 128, name: 'timeout', desc: 'Timeout' }],
+    // [129, { val: 129, name: 'service-timeout', desc: 'Service/Timeout' }],
     [255, { name: 'error', desc: 'System Error' }]
   ]);
   public controllerStatus: byteValueMap = new byteValueMap([
@@ -246,7 +246,9 @@ export class byteValueMaps {
     [15, { name: 'floorcleaner', desc: 'Floor Cleaner' }],
     [16, { name: 'intellibrite', desc: 'Intellibrite', isLight: true }],
     [17, { name: 'magicstream', desc: 'Magicstream', isLight: true }],
-    [19, { name: 'notused', desc: 'Not Used' }]
+    [19, { name: 'notused', desc: 'Not Used' }],
+    [65, { name: 'lotemp', desc: 'Lo-Temp' }],
+    [66, { name: 'hightemp', desc: 'Hi-Temp' }]
   ]);
 
   // Feature functions are used as the available options to define a circuit.
@@ -289,6 +291,26 @@ export class byteValueMaps {
     [254, { name: 'unknown', desc: 'unknown' }],
     [255, { name: 'none', desc: 'None' }]
   ]);
+  public colorLogicThemes = new byteValueMap([
+    [0, { name: 'cloudwhite', desc: 'Cloud White', type: 'colorlogic', sequence: 7 }],
+    [1, { name: 'deepsea', desc: 'Deep Sea', type: 'colorlogic', sequence: 2 }],
+    [2, { name: 'royalblue', desc: 'Royal Blue', type: 'colorlogic', sequence: 3 }],
+    [3, { name: 'afernoonskies', desc: 'Afternoon Skies', type: 'colorlogic', sequence: 4 }],
+    [4, { name: 'aquagreen', desc: 'Aqua Green', type: 'colorlogic', sequence: 5 }],
+    [5, { name: 'emerald', desc: 'Emerald', type: 'colorlogic', sequence: 6 }],
+    [6, { name: 'warmred', desc: 'Warm Red', type: 'colorlogic', sequence: 8 }],
+    [7, { name: 'flamingo', desc: 'Flamingo', type: 'colorlogic', sequence: 9 }],
+    [8, { name: 'vividviolet', desc: 'Vivid Violet', type: 'colorlogic', sequence: 10 }],
+    [9, { name: 'sangria', desc: 'Sangria', type: 'colorlogic', sequence: 11 }],
+    [10, { name: 'twilight', desc: 'Twilight', type: 'colorlogic', sequence: 12 }],
+    [11, { name: 'tranquility', desc: 'Tranquility', type: 'colorlogic', sequence: 13 }],
+    [12, { name: 'gemstone', desc: 'Gemstone', type: 'colorlogic', sequence: 14 }],
+    [13, { name: 'usa', desc: 'USA', type: 'colorlogic', sequence: 15 }],
+    [14, { name: 'mardigras', desc: 'Mardi Gras', type: 'colorlogic', sequence: 16 }],
+    [15, { name: 'cabaret', desc: 'Cabaret', type: 'colorlogic', sequence: 17 }],
+    [255, { name: 'none', desc: 'None' }]
+  ]);
+
   public lightColors: byteValueMap = new byteValueMap([
     [0, { name: 'white', desc: 'White' }],
     [2, { name: 'lightgreen', desc: 'Light Green' }],
@@ -416,7 +438,9 @@ export class byteValueMaps {
   ]);
   public bodyTypes: byteValueMap = new byteValueMap([
     [0, { name: 'pool', desc: 'Pool' }],
-    [1, { name: 'spa', desc: 'Spa' }]
+    [1, { name: 'spa', desc: 'Spa' }],
+    [2, { name: 'spa', desc: 'Spa' }],
+    [3, { name: 'spa', desc: 'Spa' }]
   ]);
   public bodies: byteValueMap = new byteValueMap([
     [0, { name: 'pool', desc: 'Pool' }],
@@ -442,6 +466,19 @@ export class byteValueMaps {
     [2, { name: 'aquarite', desc: 'Aquarite' }],
     [3, { name: 'unknown', desc: 'unknown' }]
   ]);
+  public chlorinatorModel: byteValueMap = new byteValueMap([
+    [0, { name: 'unknown', desc: 'unknown', capacity: 0, chlorinePerDay: 0, chlorinePerSec: 0 }],
+    [1, { name: 'intellichlor--15', desc: 'IntelliChlor IC15', capacity: 15000, chlorinePerDay: 0.60, chlorinePerSec: 0.60 / 86400 }],
+    [2, { name: 'intellichlor--20', desc: 'IntelliChlor IC20', capacity: 20000, chlorinePerDay: 0.70, chlorinePerSec: 0.70 / 86400 }],
+    [3, { name: 'intellichlor--40', desc: 'IntelliChlor IC40', capacity: 40000, chlorinePerDay: 1.40, chlorinePerSec: 1.4 / 86400 }],
+    [4, { name: 'intellichlor--60', desc: 'IntelliChlor IC60', capacity: 60000, chlorinePerDay: 2, chlorinePerSec: 2 / 86400 }],
+    [5, { name: 'aquarite-t15', desc: 'AquaRite T15', capacity: 40000, chlorinePerDay: 1.47, chlorinePerSec: 1.47 / 86400 }],
+    [6, { name: 'aquarite-t9', desc: 'AquaRite T9', capacity: 30000, chlorinePerDay: 0.98, chlorinePerSec: 0.98 / 86400 }],
+    [7, { name: 'aquarite-t5', desc: 'AquaRite T5', capacity: 20000, chlorinePerDay: 0.735, chlorinePerSec: 0.735 / 86400 }],
+    [8, { name: 'aquarite-t3', desc: 'AquaRite T3', capacity: 15000, chlorinePerDay: 0.53, chlorinePerSec: 0.53 / 86400 }],
+    [9, { name: 'aquarite-925', desc: 'AquaRite 925', capacity: 25000, chlorinePerDay: 0.98, chlorinePerSec: 0.98 / 86400 }],
+    [10, { name: 'aquarite-940', desc: 'AquaRite 940', capacity: 40000, chlorinePerDay: 1.47, chlorinePerSec: 1.47 / 86400 }]
+  ])
   public customNames: byteValueMap = new byteValueMap();
   public circuitNames: byteValueMap = new byteValueMap();
   public scheduleTypes: byteValueMap = new byteValueMap([
@@ -458,6 +495,10 @@ export class byteValueMaps {
     [0, { name: 'off', desc: 'Off' }],
     [1, { name: 'on', desc: 'On' }]
   ]);
+  public systemUnits: byteValueMap = new byteValueMap([
+    [0, { name: 'english', desc: 'English' }],
+    [4, { name: 'metric', desc: 'Metric' }]
+  ]);
   public tempUnits: byteValueMap = new byteValueMap([
     [0, { name: 'F', desc: 'Fahrenheit' }],
     [4, { name: 'C', desc: 'Celsius' }]
@@ -482,7 +523,7 @@ export class byteValueMaps {
     [0, { name: 'none', desc: 'None', ph: { min: 6.8, max: 7.6 }, orp: { min: 400, max: 800 }, hasAddress: false }],
     [1, { name: 'unknown', desc: 'Unknown', ph: { min: 6.8, max: 7.6 }, hasAddress: false }],
     [2, { name: 'intellichem', desc: 'IntelliChem', ph: { min: 7.2, max: 7.6 }, orp: { min: 400, max: 800 }, hasAddress: true }],
-    [3, { name: 'homegrown', desc: 'Homegrown', ph: { min: 6.8, max: 7.6 }, hasAddress: false }],
+    // [3, { name: 'homegrown', desc: 'Homegrown', ph: { min: 6.8, max: 7.6 }, hasAddress: false }],
     [4, { name: 'rem', desc: 'REM Chem', ph: { min: 6.8, max: 8.0 }, hasAddress: false }]
   ]);
   public siCalcTypes: byteValueMap = new byteValueMap([
@@ -510,12 +551,15 @@ export class byteValueMaps {
     [2, { name: 'rate', desc: 'Rate Sensor', remAddress: true }],
     [4, { name: 'pressure', desc: 'Pressure Sensor', remAddress: true }],
   ]);
-
   public chemDosingMethods: byteValueMap = new byteValueMap([
     [0, { name: 'manual', desc: 'Manual' }],
     [1, { name: 'time', desc: 'Time' }],
     [2, { name: 'volume', desc: 'Volume' }]
   ]);
+  public chemChlorDosingMethods: byteValueMap = new byteValueMap([
+    [0, { name: 'chlor', desc: 'Use Chlorinator Settings' }],
+    [1, { name: 'target', desc: 'Dynamic based on ORP Setpoint' }]
+  ]);
   public phSupplyTypes: byteValueMap = new byteValueMap([
     [0, { name: 'base', desc: 'Base pH+' }],
     [1, { name: 'acid', desc: 'Acid pH-' }]
@@ -530,6 +574,14 @@ export class byteValueMaps {
     [6, { name: 'qt', desc: 'Quarts' }],
     [7, { name: 'pt', desc: 'Pints' }]
   ]);
+  public pressureUnits: byteValueMap = new byteValueMap([
+    [0, { name: 'psi', desc: 'Pounds per Sqare Inch' }],
+    [1, { name: 'Pa', desc: 'Pascal' }],
+    [2, { name: 'kPa', desc: 'Kilo-pascals' }],
+    [3, { name: 'atm', desc: 'Atmospheres' }],
+    [4, { name: 'bar', desc: 'Barometric' }]
+  ]);
+
   public areaUnits: byteValueMap = new byteValueMap([
     [0, { name: '', desc: 'No Units' }],
     [1, { name: 'sqft', desc: 'Square Feet' }],
@@ -767,27 +819,36 @@ export class SystemBoard {
   /// relays.  This method does not control RS485 operations such as pumps and chlorinators.  These are done through the respective
   /// equipment polling functions.
   public async processStatusAsync() {
+    let self = this;
     try {
       if (this._statusCheckRef > 0) return;
       this.suspendStatus(true);
       if (typeof this._statusTimer !== 'undefined' && this._statusTimer) clearTimeout(this._statusTimer);
       // Go through all the assigned equipment and verify the current state.
       sys.board.system.keepManualTime();
-      await sys.board.circuits.syncCircuitRelayStates();
-      await sys.board.features.syncGroupStates();
-      await sys.board.circuits.syncVirtualCircuitStates();
-      await sys.board.valves.syncValveStates();
-      await sys.board.filters.syncFilterStates();
-      await sys.board.heaters.syncHeaterStates();
+      await sys.board.bodies.syncFreezeProtection();
+      await sys.board.syncEquipmentItems();
       await sys.board.schedules.syncScheduleStates();
+      await sys.board.circuits.checkEggTimerExpirationAsync();
       state.emitControllerChange();
       state.emitEquipmentChanges();
     } catch (err) { state.status = 255; logger.error(`Error performing processStatusAsync ${err.message}`); }
     finally {
       this.suspendStatus(false);
-      if (this.statusInterval > 0) this._statusTimer = setTimeout(() => this.processStatusAsync(), this.statusInterval);
+      if (this.statusInterval > 0) this._statusTimer = setTimeout(async () => await self.processStatusAsync(), this.statusInterval);
     }
   }
+  public async syncEquipmentItems() {
+    try {
+      await sys.board.circuits.syncCircuitRelayStates();
+      await sys.board.features.syncGroupStates();
+      await sys.board.circuits.syncVirtualCircuitStates();
+      await sys.board.valves.syncValveStates();
+      await sys.board.filters.syncFilterStates();
+      await sys.board.heaters.syncHeaterStates();
+    }
+    catch (err) { logger.error(`Error synchronizing equipment items: ${err.message}`); }
+  }
   public async setControllerType(obj): Promise<Equipment> {
     try {
       if (obj.controllerType !== sys.controllerType)
@@ -865,6 +926,76 @@ export class BoardCommands {
   constructor(parent: SystemBoard) { this.board = parent; }
 }
 export class SystemCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }): Promise<RestoreResults> {
+    let res = new RestoreResults();
+    try {
+      let ctx = await sys.board.system.validateRestore(rest);
+      // Restore the general stuff.
+      if (ctx.general.update.length > 0) await sys.board.system.setGeneralAsync(ctx.general.update[0]);
+      for (let i = 0; i < ctx.customNames.update.length; i++) {
+        let cn = ctx.customNames.update[i];
+        try {
+          await sys.board.system.setCustomNameAsync(cn);
+          res.addModuleSuccess('customName', `Update: ${cn.id}-${cn.name}`);
+        } catch (err) { res.addModuleError('customName', `Update: ${cn.id}-${cn.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.customNames.add.length; i++) {
+        let cn = ctx.customNames.add[i];
+        try {
+          await sys.board.system.setCustomNameAsync(cn);
+          res.addModuleSuccess('customName', `Add: ${cn.id}-${cn.name}`);
+        } catch (err) { res.addModuleError('customName', `Add: ${cn.id}-${cn.name}: ${err.message}`); }
+      }
+      await sys.board.bodies.restore(rest, ctx, res);
+      await sys.board.filters.restore(rest, ctx, res);
+      await sys.board.circuits.restore(rest, ctx, res);
+      await sys.board.heaters.restore(rest, ctx, res);
+      await sys.board.features.restore(rest, ctx, res);
+      await sys.board.pumps.restore(rest, ctx, res);
+      await sys.board.valves.restore(rest, ctx, res);
+      await sys.board.chlorinator.restore(rest, ctx, res);
+      await sys.board.chemControllers.restore(rest, ctx, res);
+      await sys.board.schedules.restore(rest, ctx, res);
+      return res;
+      //await sys.board.covers.restore(rest, ctx);
+    } catch (err) { logger.error(`Error restoring njsPC server: ${err.message}`); res.addModuleError('system', err.message); return Promise.reject(err);}
+  }
+  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<any> {
+    try {
+      let ctx: any = { board: { errors: [], warnings: [] } };
+
+      // Step 1 - Verify that the boards are the same.  For instance you do not want to restore an IntelliTouch to an IntelliCenter.
+      let cfg = rest.poolConfig;
+      if (sys.controllerType === cfg.controllerType) {
+        ctx.customNames = { errors: [], warnings: [], add: [], update: [], remove: [] };
+        let customNames = sys.customNames.get();
+        for (let i = 0; i < rest.poolConfig.customNames.length; i++) {
+          let cn = customNames.find(elem => elem.id === rest.poolConfig.customNames[i].id);
+          if (typeof cn === 'undefined') ctx.customNames.add.push(rest.poolConfig.customNames[i]);
+          else if (JSON.stringify(rest.poolConfig.customNames[i]) !== JSON.stringify(cn)) ctx.customNames.update.push(cn);
+        }
+        ctx.general = { errors: [], warnings: [], add: [], update: [], remove: [] };
+        if (JSON.stringify(sys.general.get()) !== JSON.stringify(cfg.pool)) ctx.general.update.push(cfg.pool);
+        ctx.bodies = await sys.board.bodies.validateRestore(rest);
+        ctx.pumps = await sys.board.pumps.validateRestore(rest);
+        await sys.board.circuits.validateRestore(rest, ctx);
+        ctx.features = await sys.board.features.validateRestore(rest);
+        ctx.chlorinators = await sys.board.chlorinator.validateRestore(rest);
+        ctx.heaters = await sys.board.heaters.validateRestore(rest);
+        ctx.valves = await sys.board.valves.validateRestore(rest);
+
+        //ctx.covers = await sys.board.covers.validateRestore(rest);
+        ctx.chemControllers = await sys.board.chemControllers.validateRestore(rest);
+        ctx.filters = await sys.board.filters.validateRestore(rest);
+        ctx.schedules = await sys.board.schedules.validateRestore(rest);
+      }
+      else ctx.board.errors.push(`Panel Types do not match cannot restore bakup from ${sys.controllerType} to ${rest.poolConfig.controllerType}`);
+
+      return ctx;
+
+    } catch (err) { logger.error(`Error validating restore file: ${err.message}`); return Promise.reject(err);}
+
+  }
   public cancelDelay(): Promise<any> { state.delay = sys.board.valueMaps.delay.getValue('nodelay'); return Promise.resolve(state.data.delay); }
   public setDateTimeAsync(obj: any): Promise<any> { return Promise.resolve(); }
   public keepManualTime() {
@@ -929,6 +1060,9 @@ export class SystemCommands extends BoardCommands {
     if (obj.clockSource === 'server') sys.board.system.setTZ();
     sys.board.system.setTempSensorsAsync(obj);
     sys.general.options.set(obj);
+    let bodyUnits = sys.general.options.units === 0 ? 1 : 2;
+    for (let i = 0; i < sys.bodies.length; i++) sys.bodies.getItemByIndex(i).capacityUnits = bodyUnits;
+    state.temps.units = sys.general.options.units === 0 ? 1 : 4;
     return new Promise<Options>(function (resolve, reject) { resolve(sys.general.options); });
   }
   public async setLocationAsync(obj: any): Promise<Location> {
@@ -959,7 +1093,10 @@ export class SystemCommands extends BoardCommands {
               state.temps.waterSensor1 = sys.equipment.tempSensors.getCalibration('water1') + temp;
               let body = state.temps.bodies.getItemById(1);
               if (body.isOn) body.temp = state.temps.waterSensor1;
-
+              else if (sys.equipment.shared) {
+                body = state.temps.bodies.getItemById(2);
+                if (body.isOn) body.temp = state.temps.waterSensor1;
+              }
             }
             break;
           case 'waterSensor2':
@@ -1132,17 +1269,182 @@ export class SystemCommands extends BoardCommands {
   }
 }
 export class BodyCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the bodies that should be removed.
+      for (let i = 0; i < ctx.bodies.remove.length; i++) {
+        let body = ctx.bodies.remove[i];
+        try {
+          sys.bodies.removeItemById(body.id);
+          state.temps.bodies.removeItemById(body.id);
+          res.addModuleSuccess('body', `Remove: ${body.id}-${body.name}`);
+        } catch (err) { res.addModuleError('body', `Remove: ${body.id}-${body.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.bodies.update.length; i++) {
+        let body = ctx.bodies.update[i];
+        try {
+          await sys.board.bodies.setBodyAsync(body);
+          res.addModuleSuccess('body', `Update: ${body.id}-${body.name}`);
+        } catch (err) { res.addModuleError('body', `Update: ${body.id}-${body.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.bodies.add.length; i++) {
+        let body = ctx.bodies.add[i];
+        try {
+          // pull a little trick to first add the data then perform the update.
+          sys.bodies.getItemById(body.id, true);
+          await sys.board.bodies.setBodyAsync(body);
+        } catch (err) { res.addModuleError('body', `Add: ${body.id}-${body.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring bodies: ${err.message}`); res.addModuleError('system', `Error restoring bodies: ${err.message}`); return false; }
+  }
+  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any}> {
+    try {
+      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      // Look at bodies.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.bodies.length; i++) {
+        let r = cfg.bodies[i];
+        let c = sys.bodies.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.bodies.length; i++) {
+        let c = sys.bodies.getItemByIndex(i);
+        let r = cfg.bodies.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating bodies for restore: ${err.message}`); }
+  }
+  public freezeProtectBodyOn: Date;
+  public freezeProtectStart: Date;
+  public async syncFreezeProtection() {
+    try {
+      // Go through all the features and circuits to make sure we have the freeze protect set appropriately.  The freeze
+      // flag will have already been set whether this is a Nixie setup or there is an OCP involved.
+
+      // First turn on/off any features that are in our control that should be under our control.  If this is an OCP we
+      // do not create features beyond those controlled by the OCP so we don't need to check these in that condition.  That is
+      // why it first checks the controller type.
+      let freeze = utils.makeBool(state.freeze);
+      if (sys.controllerType === ControllerType.Nixie) {
+        // If we are a Nixie controller we need to evaluate the current freeze settings against the air temperature.
+        if (typeof state.temps.air !== 'undefined') freeze = state.temps.air <= sys.general.options.freezeThreshold;
+        else freeze = false;
+
+        // We need to know when we first turned the freeze protection on. This is because we will be rotating between pool and spa
+        // on shared body systems when both pool and spa have freeze protection checked.
+        if (state.freeze !== freeze) {
+          this.freezeProtectStart = freeze ? new Date() : undefined;
+          state.freeze = freeze;
+        }
+        for (let i = 0; i < sys.features.length; i++) {
+          let feature = sys.features.getItemByIndex(i);
+          let fstate = state.features.getItemById(feature.id, true);
+          if (!feature.freeze || !feature.isActive === true || feature.master !== 1) {
+            fstate.freezeProtect = false;
+            continue; // This is not affected by freeze conditions.
+          }
+          if (freeze && !fstate.isOn) {
+            // This feature should be on because we are freezing.
+            fstate.freezeProtect = true;
+            await sys.board.features.setFeatureStateAsync(feature.id, true);
+          }
+          else if (!freeze && fstate.freezeProtect) {
+            // This feature was turned on by freeze protection.  We need to turn it off because it has warmed up.
+            fstate.freezeProtect = false;
+            await sys.board.features.setFeatureStateAsync(feature.id, false);
+          }
+        }
+      }
+      let bodyRotationChecked = false;
+      for (let i = 0; i < sys.circuits.length; i++) {
+        let circ = sys.circuits.getItemByIndex(i);
+        let cstate = state.circuits.getItemById(circ.id);
+        if (!circ.freeze || !circ.isActive === true || circ.master !== 1) {
+          cstate.freezeProtect = false;
+          continue; // This is not affected by freeze conditions.
+        }
+        if (sys.equipment.shared && freeze && (circ.id === 1 || circ.id === 6)) {
+          // Exit out of here because we already checked the body rotation.  We only want to do this once since it can be expensive turning
+          // on a particular body.
+          if (bodyRotationChecked) continue;
+          // These are our body circuits so we need to check to see if they need to be rotated between pool and spa.
+          let pool = circ.id === 6 ? circ : sys.circuits.getItemById(6);
+          let spa = circ.id === 1 ? circ : sys.circuits.getItemById(1);
+          if (pool.freeze && spa.freeze) {
+            // We only need to rotate between pool and spa when they are both checked.
+            let pstate = circ.id === 6 ? cstate : state.circuits.getItemById(6);
+            let sstate = circ.id === 1 ? cstate : state.circuits.getItemById(1);
+            if (!pstate.isOn && !sstate.isOn) {
+              // Neither the pool or spa are on so we will turn on the pool first.
+              pstate.freezeProtect = true;
+              this.freezeProtectBodyOn = new Date();
+              await sys.board.circuits.setCircuitStateAsync(6, true);
+            }
+            else {
+              // If neither of the bodies were turned on for freeze protection then we need to ignore this. 
+              if (!pstate.freezeProtect && !sstate.freezeProtect) {
+                this.freezeProtectBodyOn = undefined;
+                continue;
+              }
+
+              // One of the two bodies is on so we need to check for the rotation.  If it is time to rotate do the rotation.
+              if (typeof this.freezeProtectBodyOn === 'undefined') this.freezeProtectBodyOn = new Date();
+              let dt = new Date().getTime();
+              if (dt - 1000 * 60 * 15 > this.freezeProtectBodyOn.getTime()) {
+                logger.info(`Swapping bodies for freeze protection pool:${pstate.isOn} spa:${sstate.isOn} interval: ${utils.formatDuration(dt - this.freezeProtectBodyOn.getTime() / 1000)}`);
+                // 10 minutes has elapsed so we will be rotating to the other body.
+                if (pstate.isOn) {
+                  // The setCircuitState method will handle turning off the pool body.
+                  sstate.freezeProtect = true;
+                  pstate.freezeProtect = false;
+                  await sys.board.circuits.setCircuitStateAsync(1, true);
+                }
+                else {
+                  sstate.freezeProtect = false;
+                  pstate.freezeProtect = true;
+                  await sys.board.circuits.setCircuitStateAsync(6, true);
+                }
+                // Set a new date as this will be our rotation check now.
+                this.freezeProtectBodyOn = new Date();
+              }
+            }
+          }
+          else {
+            // Only this circuit is selected for freeze protection so we don't need any special treatment.
+            cstate.freezeProtect = true;
+            if (!cstate.isOn) await sys.board.circuits.setCircuitStateAsync(circ.id, true);
+          }
+          bodyRotationChecked = true;
+        }
+        else if (freeze && !cstate.isOn) {
+          // This circuit should be on because we are freezing.
+          cstate.freezeProtect = true;
+          await sys.board.features.setFeatureStateAsync(circ.id, true);
+        }
+        else if (!freeze && cstate.freezeProtect) {
+          // This feature was turned on by freeze protection.  We need to turn it off because it has warmed up.
+          await sys.board.circuits.setCircuitStateAsync(circ.id, false);
+          cstate.freezeProtect = false;
+        }
+      }
+    }
+    catch (err) { logger.error(`syncFreezeProtection: Error synchronizing freeze protection states`); }
+  }
+
   public async initFilters() {
     try {
       let filter: Filter;
       let sFilter: FilterState;
       if (sys.equipment.maxBodies > 0) {
         filter = sys.filters.getItemById(1, true, { filterType: 3, name: sys.equipment.shared ? 'Filter' : 'Filter 1' });
-        sFilter = state.filters.getItemById(1, true, { name: filter.name });
+        sFilter = state.filters.getItemById(1, true, { id: 1, name: filter.name });
         filter.isActive = true;
         filter.master = sys.board.equipmentMaster;
         filter.body = sys.equipment.shared ? sys.board.valueMaps.bodies.transformByName('poolspa') : 0;
-        sFilter = state.filters.getItemById(1, true);
+        //sFilter = state.filters.getItemById(1, true);
         sFilter.body = filter.body;
         sFilter.filterType = filter.filterType;
         sFilter.name = filter.name;
@@ -1268,53 +1570,54 @@ export class BodyCommands extends BoardCommands {
     sys.board.heaters.syncHeaterStates();
     return Promise.resolve(bstate);
   }
-  public getHeatSources(bodyId: number) {
-    let heatSources = [];
-    let heatTypes = this.board.heaters.getInstalledHeaterTypes(bodyId);
-    heatSources.push(this.board.valueMaps.heatSources.transformByName('nochange'));
-    if (heatTypes.total > 0) heatSources.push(this.board.valueMaps.heatSources.transformByName('off'));
-    if (heatTypes.gas > 0) heatSources.push(this.board.valueMaps.heatSources.transformByName('heater'));
-    if (heatTypes.solar > 0) {
-      let hm = this.board.valueMaps.heatSources.transformByName('solar');
-      heatSources.push(hm);
-      if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('solarpref'));
-    }
-    if (heatTypes.heatpump > 0) {
-      let hm = this.board.valueMaps.heatSources.transformByName('heatpump');
-      heatSources.push(hm);
-      if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('heatpumppref'));
-    }
-    if (heatTypes.ultratemp > 0) {
-      let hm = this.board.valueMaps.heatSources.transformByName('ultratemp');
-      heatSources.push(hm);
-      if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('ultratemppref'));
-    }
-    return heatSources;
-  }
-  public getHeatModes(bodyId: number) {
-    let heatModes = [];
-    // RKS: 09-26-20 This will need to be overloaded in IntelliCenterBoard when the other heater types are identified. (e.g. ultratemp, hybrid, maxetherm, and mastertemp)
-    heatModes.push(this.board.valueMaps.heatModes.transformByName('off')); // In IC fw 1.047 off is no longer 0.
-    let heatTypes = this.board.heaters.getInstalledHeaterTypes(bodyId);
-    if (heatTypes.gas > 0)
-      heatModes.push(this.board.valueMaps.heatModes.transformByName('heater'));
-    if (heatTypes.solar > 0) {
-      let hm = this.board.valueMaps.heatModes.transformByName('solar');
-      heatModes.push(hm);
-      if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('solarpref'));
-    }
-    if (heatTypes.heatpump > 0) {
-      let hm = this.board.valueMaps.heatModes.transformByName('heatpump');
-      heatModes.push(hm);
-      if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('heatpumppref'));
-    }
-    if (heatTypes.ultratemp > 0) {
-      let hm = this.board.valueMaps.heatModes.transformByName('ultratemp');
-      heatModes.push(hm);
-      if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('ultratemppref'));
-    }
-    return heatModes;
-  }
+    public getHeatSources(bodyId: number) {
+        let heatSources = [];
+        let heatTypes = this.board.heaters.getInstalledHeaterTypes(bodyId);
+        heatSources.push(this.board.valueMaps.heatSources.transformByName('nochange'));
+        if (heatTypes.total > 0) heatSources.push(this.board.valueMaps.heatSources.transformByName('off'));
+        if (heatTypes.gas > 0) heatSources.push(this.board.valueMaps.heatSources.transformByName('heater'));
+        if (heatTypes.mastertemp > 0) heatSources.push(this.board.valueMaps.heatSources.transformByName('mastertemp'));
+        if (heatTypes.solar > 0) {
+            let hm = this.board.valueMaps.heatSources.transformByName('solar');
+            heatSources.push(hm);
+            if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('solarpref'));
+        }
+        if (heatTypes.heatpump > 0) {
+            let hm = this.board.valueMaps.heatSources.transformByName('heatpump');
+            heatSources.push(hm);
+            if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('heatpumppref'));
+        }
+        if (heatTypes.ultratemp > 0) {
+            let hm = this.board.valueMaps.heatSources.transformByName('ultratemp');
+            heatSources.push(hm);
+            if (heatTypes.total > 1) heatSources.push(this.board.valueMaps.heatSources.transformByName('ultratemppref'));
+        }
+        return heatSources;
+    }
+    public getHeatModes(bodyId: number) {
+        let heatModes = [];
+        // RKS: 09-26-20 This will need to be overloaded in IntelliCenterBoard when the other heater types are identified. (e.g. ultratemp, hybrid, maxetherm, and mastertemp)
+        heatModes.push(this.board.valueMaps.heatModes.transformByName('off')); // In IC fw 1.047 off is no longer 0.
+        let heatTypes = this.board.heaters.getInstalledHeaterTypes(bodyId);
+        if (heatTypes.gas > 0) heatModes.push(this.board.valueMaps.heatModes.transformByName('heater'));
+        if (heatTypes.mastertemp > 0) heatModes.push(this.board.valueMaps.heatModes.transformByName('mastertemp'));
+        if (heatTypes.solar > 0) {
+            let hm = this.board.valueMaps.heatModes.transformByName('solar');
+            heatModes.push(hm);
+            if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('solarpref'));
+        }
+        if (heatTypes.heatpump > 0) {
+            let hm = this.board.valueMaps.heatModes.transformByName('heatpump');
+            heatModes.push(hm);
+            if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('heatpumppref'));
+        }
+        if (heatTypes.ultratemp > 0) {
+            let hm = this.board.valueMaps.heatModes.transformByName('ultratemp');
+            heatModes.push(hm);
+            if (heatTypes.total > 1) heatModes.push(this.board.valueMaps.heatModes.transformByName('ultratemppref'));
+        }
+        return heatModes;
+    }
   public getPoolStates(): BodyTempState[] {
     let arrPools = [];
     for (let i = 0; i < state.temps.bodies.length; i++) {
@@ -1382,6 +1685,56 @@ export class BodyCommands extends BoardCommands {
   }
 }
 export class PumpCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the pumps that should be removed.
+      for (let i = 0; i < ctx.pumps.remove.length; i++) {
+        let p = ctx.pumps.remove[i];
+        try {
+          await sys.board.pumps.deletePumpAsync(p);
+          res.addModuleSuccess('pump', `Remove: ${p.id}-${p.name}`);
+        } catch (err) { res.addModuleError('pump', `Remove: ${p.id}-${p.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.pumps.update.length; i++) {
+        let p = ctx.pumps.update[i];
+        try {
+          await sys.board.pumps.setPumpAsync(p);
+          res.addModuleSuccess('pump', `Update: ${p.id}-${p.name}`);
+        } catch (err) { res.addModuleError('pump', `Update: ${p.id}-${p.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.pumps.add.length; i++) {
+        let p = ctx.pumps.add[i];
+        try {
+          // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+          // it won't error out.
+          sys.pumps.getItemById(p, true);
+          await sys.board.pumps.setPumpAsync(p);
+          res.addModuleSuccess('pump', `Add: ${p.id}-${p.name}`);
+        } catch (err) { res.addModuleError('pump', `Add: ${p.id}-${p.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring pumps: ${err.message}`); res.addModuleError('system', `Error restoring pumps: ${err.message}`); return false; }
+  }
+  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
+    try {
+      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      // Look at pumps.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.pumps.length; i++) {
+        let r = cfg.pumps[i];
+        let c = sys.pumps.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.pumps.length; i++) {
+        let c = sys.pumps.getItemByIndex(i);
+        let r = cfg.pumps.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating pumps for restore: ${err.message}`); }
+  }
+
   public getPumpTypes() { return this.board.valueMaps.pumpTypes.toArray(); }
   public getCircuitUnits(pump?: Pump) {
     if (typeof pump === 'undefined')
@@ -1446,14 +1799,15 @@ export class PumpCommands extends BoardCommands {
     // and props that aren't for this pump type
     let _id = pump.id;
     if (pump.type !== pumpType || pumpType === 0) {
-      const _isVirtual = sys.pumps.getItemById(_id).isVirtual;
+      let _p = pump.get(true);
+      // const _isVirtual = typeof _p.isVirtual !== 'undefined' ? _p.isVirtual : false;
       sys.pumps.removeItemById(_id);
-      let pump = sys.pumps.getItemById(_id, true);
-      if (_isVirtual) {
+      pump = sys.pumps.getItemById(_id, true);
+      /* if (_isVirtual) {
         // pump.isActive = true;
         // pump.isVirtual = true;
         pump.master = 1;
-      }
+      } */
       state.pumps.removeItemById(pump.id);
       pump.type = pumpType;
       let type = sys.board.valueMaps.pumpTypes.transform(pumpType);
@@ -1505,10 +1859,164 @@ export class PumpCommands extends BoardCommands {
   }
 }
 export class CircuitCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the circuit/lightGroups that should be removed.
+      for (let i = 0; i < ctx.circuitGroups.remove.length; i++) {
+        let c = ctx.circuitGroups.remove[i];
+        try {
+          await sys.board.circuits.deleteCircuitGroupAsync(c);
+          res.addModuleSuccess('circuitGroup', `Remove: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('circuitGroup', `Remove: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.lightGroups.remove.length; i++) {
+        let c = ctx.lightGroups.remove[i];
+        try {
+          await sys.board.circuits.deleteLightGroupAsync(c);
+          res.addModuleSuccess('lightGroup', `Remove: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('lightGroup', `Remove: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.circuits.remove.length; i++) {
+        let c = ctx.circuits.remove[i];
+        try {
+          await sys.board.circuits.deleteCircuitAsync(c);
+          res.addModuleSuccess('circuit', `Remove: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('circuit', `Remove: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.circuits.add.length; i++) {
+        let c = ctx.circuits.add[i];
+        try {
+          await sys.board.circuits.setCircuitAsync(c);
+          res.addModuleSuccess('circuit', `Add: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('circuit', `Add: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.circuitGroups.add.length; i++) {
+        let c = ctx.circuitGroups.add[i];
+        try {
+          await sys.board.circuits.setCircuitGroupAsync(c);
+          res.addModuleSuccess('circuitGroup', `Add: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('circuitGroup', `Add: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.lightGroups.add.length; i++) {
+        let c = ctx.lightGroups.add[i];
+        try {
+          await sys.board.circuits.setLightGroupAsync(c);
+          res.addModuleSuccess('lightGroup', `Add: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('lightGroup', `Add: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.circuits.update.length; i++) {
+        let c = ctx.circuits.update[i];
+        try {
+          await sys.board.circuits.setCircuitAsync(c);
+          res.addModuleSuccess('circuit', `Update: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('circuit', `Update: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.circuitGroups.update.length; i++) {
+        let c = ctx.circuitGroups.update[i];
+        try {
+          await sys.board.circuits.setCircuitGroupAsync(c);
+          res.addModuleSuccess('circuitGroup', `Update: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('circuitGroup', `Update: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.lightGroups.add.length; i++) {
+        let c = ctx.lightGroups.update[i];
+        try {
+          await sys.board.circuits.setLightGroupAsync(c);
+          res.addModuleSuccess('lightGroup', `Update: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('lightGroup', `Update: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring circuits: ${err.message}`); res.addModuleError('system', `Error restoring circuits/features: ${err.message}`); return false; }
+  }
+  public async validateRestore(rest: { poolConfig: any, poolState: any }, ctxRoot): Promise<boolean> {
+    try {
+      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      // Look at circuits.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.circuits.length; i++) {
+        let r = cfg.circuits[i];
+        let c = sys.circuits.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.circuits.length; i++) {
+        let c = sys.circuits.getItemByIndex(i);
+        let r = cfg.circuits.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      ctxRoot.circuits = ctx;
+      ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      for (let i = 0; i < cfg.circuitGroups.length; i++) {
+        let r = cfg.circuitGroups[i];
+        let c = sys.circuitGroups.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.circuitGroups.length; i++) {
+        let c = sys.circuitGroups.getItemByIndex(i);
+        let r = cfg.circuitGroups.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      ctxRoot.circuitGroups = ctx;
+      ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      for (let i = 0; i < cfg.lightGroups.length; i++) {
+        let r = cfg.lightGroups[i];
+        let c = sys.lightGroups.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.lightGroups.length; i++) {
+        let c = sys.lightGroups.getItemByIndex(i);
+        let r = cfg.lightGroups.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      ctxRoot.lightGroups = ctx;
+      return true;
+    } catch (err) { logger.error(`Error validating circuits for restore: ${err.message}`); }
+  }
+  public async checkEggTimerExpirationAsync() {
+    // turn off any circuits that have reached their egg timer;
+    // Nixie circuits we have 100% control over; 
+    // but features/cg/lg may override OCP control
+    try {
+      for (let i = 0; i < sys.circuits.length; i++) {
+        let c = sys.circuits.getItemByIndex(i);
+        let cstate = state.circuits.getItemByIndex(i);
+        if (!cstate.isActive || !cstate.isOn) continue;
+        if (c.master === 1) {
+          await ncp.circuits.checkCircuitEggTimerExpirationAsync(cstate);
+        }
+      }
+      for (let i = 0; i < sys.features.length; i++) {
+        let fstate = state.features.getItemByIndex(i);
+        if (!fstate.isActive || !fstate.isOn) continue;
+        if (fstate.endTime.toDate() < new Timestamp().toDate()) {
+          await sys.board.circuits.setCircuitStateAsync(fstate.id, false);
+          fstate.emitEquipmentChange();
+        }
+      }
+      for (let i = 0; i < sys.circuitGroups.length; i++) {
+        let cgstate = state.circuitGroups.getItemByIndex(i);
+        if (!cgstate.isActive || !cgstate.isOn) continue;
+        if (cgstate.endTime.toDate() < new Timestamp().toDate()) {
+          await sys.board.circuits.setCircuitGroupStateAsync(cgstate.id, false);
+          cgstate.emitEquipmentChange();
+        }
+      }
+      for (let i = 0; i < sys.lightGroups.length; i++) {
+        let lgstate = state.lightGroups.getItemByIndex(i);
+        if (!lgstate.isActive || !lgstate.isOn) continue;
+        if (lgstate.endTime.toDate() < new Timestamp().toDate()) {
+          await sys.board.circuits.setLightGroupStateAsync(lgstate.id, false);
+          lgstate.emitEquipmentChange();
+        }
+      }
+    } catch (err) { logger.error(`checkEggTimerExpiration: Error synchronizing circuit relays ${err.message}`); }
+  }
   public async syncCircuitRelayStates() {
     try {
       for (let i = 0; i < sys.circuits.length; i++) {
-        // Run through all the valves to see whether they should be triggered or not.
+        // Run through all the controlled circuits to see whether they should be triggered or not.
         let circ = sys.circuits.getItemByIndex(i);
         if (circ.master === 1 && circ.isActive) {
           let cstate = state.circuits.getItemById(circ.id);
@@ -1517,7 +2025,6 @@ export class CircuitCommands extends BoardCommands {
       }
     } catch (err) { logger.error(`syncCircuitRelayStates: Error synchronizing circuit relays ${err.message}`); }
   }
-
   public syncVirtualCircuitStates() {
     try {
       let arrCircuits = sys.board.valueMaps.virtualCircuits.toArray();
@@ -1650,7 +2157,6 @@ export class CircuitCommands extends BoardCommands {
       //[13, { name: 'spa', desc: 'Spa', hasHeatSource: true }]
       let func = sys.board.valueMaps.circuitFunctions.get(circuit.type);
       if (newState && (func.name === 'pool' || func.name === 'spa') && sys.equipment.shared === true) {
-        console.log(`Turning off shared body circuit`);
         // If we are shared we need to turn off the other circuit.
         let offType = func.name === 'pool' ? sys.board.valueMaps.circuitFunctions.getValue('spa') : sys.board.valueMaps.circuitFunctions.getValue('pool');
         let off = sys.circuits.get().filter(elem => elem.type === offType);
@@ -1665,14 +2171,13 @@ export class CircuitCommands extends BoardCommands {
       else if (id === 1) state.temps.bodies.getItemById(2, true).isOn = val;
       // Let the main nixie controller set the circuit state and affect the relays if it needs to.
       await ncp.circuits.setCircuitStateAsync(circ, newState);
+      await sys.board.syncEquipmentItems();
       return state.circuits.getInterfaceById(circ.id);
     }
     catch (err) { return Promise.reject(`Nixie: Error setCircuitStateAsync ${err.message}`); }
     finally {
-      // sys.board.virtualPumpControllers.start();
       ncp.pumps.syncPumpStates();
       sys.board.suspendStatus(false);
-      this.board.processStatusAsync();
       state.emitEquipmentChanges();
     }
   }
@@ -1770,7 +2275,7 @@ export class CircuitCommands extends BoardCommands {
       if (typeof data.id !== 'undefined') {
         let circuit = sys.circuits.getItemById(id, true);
         let scircuit = state.circuits.getItemById(id, true);
-        circuit.isActive = true;
+        scircuit.isActive = circuit.isActive = true;
         circuit.master = 1;
         scircuit.isOn = false;
         if (data.name) circuit.name = scircuit.name = data.name;
@@ -1788,6 +2293,7 @@ export class CircuitCommands extends BoardCommands {
         if (typeof data.deviceBinding !== 'undefined') circuit.deviceBinding = data.deviceBinding;
         if (typeof data.showInFeatures !== 'undefined') scircuit.showInFeatures = circuit.showInFeatures = utils.makeBool(data.showInFeatures);
         circuit.dontStop = circuit.eggTimer === 1440;
+
         sys.emitEquipmentChange();
         state.emitEquipmentChanges();
         if (circuit.master === 1) await ncp.circuits.setCircuitAsync(circuit, data);
@@ -1870,8 +2376,9 @@ export class CircuitCommands extends BoardCommands {
     if (typeof id === 'undefined') return Promise.reject(new InvalidEquipmentIdError(`Max circuit light group id exceeded`, id, 'LightGroup'));
     if (isNaN(id) || !sys.board.equipmentIds.circuitGroups.isInRange(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid circuit group id: ${obj.id}`, obj.id, 'LightGroup'));
     group = sys.lightGroups.getItemById(id, true);
+    let sgroup = state.lightGroups.getItemById(id, true);
     return new Promise<LightGroup>((resolve, reject) => {
-      if (typeof obj.name !== 'undefined') group.name = obj.name;
+      if (typeof obj.name !== 'undefined') sgroup.name = group.name = obj.name;
       if (typeof obj.dontStop !== 'undefined' && utils.makeBool(obj.dontStop) === true) obj.eggTimer = 1440;
       if (typeof obj.eggTimer !== 'undefined') group.eggTimer = Math.min(Math.max(parseInt(obj.eggTimer, 10), 0), 1440);
       group.dontStop = group.eggTimer === 1440;
@@ -1978,7 +2485,9 @@ export class CircuitCommands extends BoardCommands {
         await sys.board.circuits.setCircuitStateAsync(c.circuit, false);
       else if (!cstate.isOn && sys.board.valueMaps.lightThemes.getName(theme) !== 'off') await sys.board.circuits.setCircuitStateAsync(c.circuit, true);
     }
-    sgrp.isOn = sys.board.valueMaps.lightThemes.getName(theme) === 'off' ? false : true;
+    let isOn = sys.board.valueMaps.lightThemes.getName(theme) === 'off' ? false : true;
+    sys.board.circuits.setEndTime(grp, sgrp, isOn);
+    sgrp.isOn = isOn;
     // If we truly want to support themes in lightGroups we probably need to program
     // the specific on/off toggles to enable that.  For now this will go through the motions but it's just a pretender.
     switch (theme) {
@@ -2058,46 +2567,122 @@ export class CircuitCommands extends BoardCommands {
   public async setLightGroupStateAsync(id: number, val: boolean): Promise<ICircuitGroupState> {
     return sys.board.circuits.setCircuitGroupStateAsync(id, val);
   }
-  public setEndTime(thing: ICircuit, thingState: ICircuitState, isOn: boolean) {
-    // this is a generic fn for circuits, features, circuitGroups, lightGroups
-    // to set the end time based on the egg timer.
-    // it will be called from set[]StateAsync calls as well as when then state is 
-    // eval'ed from status packets/external messages and schedule changes.
-    // instead of maintaining timers here which would increase the amount of 
-    // emits substantially, let the clients keep their own local timers
-    // or just display the end time.
-    if (thing.dontStop || !isOn) {
-      console.log(`setting thing ${thingState.id} end time to undefined.`);
-      thingState.endTime = undefined;
-    }
-    else if (!thingState.isOn && isOn) {
-      let endTime: Timestamp;
-      let eggTimerEndTime: Timestamp;
-      // let remainingDuration: number;
-      if (typeof thing.eggTimer !== 'undefined') {
-        eggTimerEndTime = state.time.clone().addHours(0, thing.eggTimer);
-      }
-      // egg timers don't come into play if a schedule will control the circuit
-      for (let i = 0; i < sys.schedules.length; i++) {
-        let sched = sys.schedules.getItemByIndex(i);
-        if (sched.isActive && sys.board.schedules.includesCircuit(sched, thing.id)) {
-          let nearestStartTime = sys.board.schedules.getNearestStartTime(sched);
-          let nearestEndTime = sys.board.schedules.getNearestEndTime(sched);
-          // if the schedule doesn't have an end date (eg no days)...
-          if (nearestEndTime.getTime() === 0) continue;
-          // else if the egg timer will turn the circuit off before the schedule begins
-          else if (eggTimerEndTime.getTime() < nearestStartTime.getTime()) continue;
-          // else if the end time isn't yet set
-          else if (typeof endTime === 'undefined') endTime = nearestEndTime.clone();
-          // and finally, compare the end time of this sched to the existing closest end time
-          else if (nearestEndTime.getTime() < endTime.getTime()) endTime = nearestEndTime.clone();
+  public setEndTime(thing: ICircuit, thingState: ICircuitState, isOn: boolean, bForce: boolean= false) {
+    /*
+    this is a generic fn for circuits, features, circuitGroups, lightGroups
+    to set the end time based on the egg timer.
+    it will be called from set[]StateAsync calls as well as when then state is 
+    eval'ed from status packets/external messages and schedule changes.
+    instead of maintaining timers here which would increase the amount of 
+    emits substantially, let the clients keep their own local timers
+    or just display the end time.
+
+    bForce is an override sent by the syncScheduleStates.  It gets set after the circuit gets set but we need to know if the sched is on.  This allows the circuit end time to be 
+    re-evaluated even though it already has an end time.
+
+    Logic gets fun here... 
+    0. If the circuit is off, or has don't stop enabled, don't set an end time 
+    0.1. If the circuit state hasn't changed, abort (unless bForce is true).
+    1. If the schedule is on, the egg timer does not come into play
+    2. If the schedule is off...
+    2.1.  and the egg timer will turn off the circuit off before the schedule starts, use egg timer time
+    2.2.  else if the schedule will start before the egg timer turns it off, use the schedule end time
+    3. Iterate over each schedule for 1-2 above; nearest end time wins
+    */
+    try {
+      if (thing.dontStop || !isOn) {
+        thingState.endTime = undefined;
+      }
+      else if (!thingState.isOn && isOn || bForce) {
+        let endTime: Timestamp;
+        let eggTimerEndTime: Timestamp;
+        // let remainingDuration: number;
+        if (typeof thing.eggTimer !== 'undefined') {
+          eggTimerEndTime = state.time.clone().addHours(0, thing.eggTimer);
+        }
+        // egg timers don't come into play if a schedule will control the circuit
+        for (let i = 0; i < sys.schedules.length; i++) {
+          let sched = sys.schedules.getItemByIndex(i);
+          let ssched = state.schedules.getItemById(sched.id);
+          if (sched.isActive && sys.board.schedules.includesCircuit(sched, thing.id)) {
+            let nearestStartTime = sys.board.schedules.getNearestStartTime(sched);
+            let nearestEndTime = sys.board.schedules.getNearestEndTime(sched);
+            // if the schedule doesn't have an end date (eg no days)...
+            if (nearestEndTime.getTime() === 0) continue;
+            if (ssched.isOn) {
+              if (typeof endTime === 'undefined' || nearestEndTime.getTime() < endTime.getTime()) {
+                endTime = nearestEndTime.clone();
+                eggTimerEndTime = undefined;
+              }
+            }
+            else {
+              if (typeof eggTimerEndTime !== 'undefined' && eggTimerEndTime.getTime() < nearestStartTime.getTime()) {
+                if (typeof endTime === 'undefined' || eggTimerEndTime.getTime() < endTime.getTime()) endTime = eggTimerEndTime.clone();
+              }
+              else if (typeof endTime === 'undefined' || nearestEndTime.getTime() < endTime.getTime()) endTime = nearestEndTime.clone();
+            }
+          }
         }
+        if (typeof endTime !== 'undefined') thingState.endTime = endTime;
+        else if (typeof eggTimerEndTime !== 'undefined') thingState.endTime = eggTimerEndTime;
       }
-      thingState.endTime = typeof endTime !== 'undefined' ? endTime : eggTimerEndTime;
+    }
+    catch (err) {
+      logger.error(`Error setting end time for ${thing.id}: ${err}`)
     }
   }
 }
 export class FeatureCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the features that should be removed.
+      for (let i = 0; i < ctx.features.remove.length; i++) {
+        let f = ctx.features.remove[i];
+        try {
+          await sys.board.features.deleteFeatureAsync(f);
+          res.addModuleSuccess('feature', `Remove: ${f.id}-${f.name}`);
+        } catch (err) { res.addModuleError('feature', `Remove: ${f.id}-${f.name}: ${err.message}`) }
+      }
+      for (let i = 0; i < ctx.features.update.length; i++) {
+        let f = ctx.features.update[i];
+        try {
+          await sys.board.features.setFeatureAsync(f);
+          res.addModuleSuccess('feature', `Update: ${f.id}-${f.name}`);
+        } catch (err) { res.addModuleError('feature', `Update: ${f.id}-${f.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.features.add.length; i++) {
+        // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+        // it won't error out.
+        let f = ctx.features.add[i];
+        try {
+          sys.features.getItemById(f, true);
+          await sys.board.features.setFeatureAsync(f);
+          res.addModuleSuccess('feature', `Add: ${f.id}-${f.name}`);
+        } catch (err) { res.addModuleError('feature', `Add: ${f.id}-${f.name}: ${err.message}`) }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring features: ${err.message}`); res.addModuleError('system', `Error restoring features: ${err.message}`); return false; }
+  }
+  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
+    try {
+      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      // Look at features.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.features.length; i++) {
+        let r = cfg.features[i];
+        let c = sys.features.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.features.length; i++) {
+        let c = sys.features.getItemByIndex(i);
+        let r = cfg.features.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating features for restore: ${err.message}`); }
+  }
+
   public async setFeatureAsync(obj: any): Promise<Feature> {
     let id = parseInt(obj.id, 10);
     if (id <= 0 || isNaN(id)) {
@@ -2151,7 +2736,6 @@ export class FeatureCommands extends BoardCommands {
       sys.board.circuits.setEndTime(feature, fstate, val);
       fstate.isOn = val;
       sys.board.valves.syncValveStates();
-      // sys.board.virtualPumpControllers.start();
       ncp.pumps.syncPumpStates();
       state.emitEquipmentChanges();
       return fstate;
@@ -2214,6 +2798,57 @@ export class FeatureCommands extends BoardCommands {
   }
 }
 export class ChlorinatorCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the chlorinators that should be removed.
+      for (let i = 0; i < ctx.chlorinators.remove.length; i++) {
+        let c = ctx.chlorinators.remove[i];
+        try {
+          await sys.board.chlorinator.deleteChlorAsync(c);
+          res.addModuleSuccess('chlorinator', `Remove: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chlorinator', `Remove: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.chlorinators.update.length; i++) {
+        let c = ctx.chlorinators.update[i];
+        try {
+          await sys.board.chlorinator.setChlorAsync(c);
+          res.addModuleSuccess('chlorinator', `Update: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chlorinator', `Update: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.chlorinators.add.length; i++) {
+        let c = ctx.chlorinators.add[i];
+        try {
+          // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+          // it won't error out.
+          sys.chlorinators.getItemById(c.id, true);
+          await sys.board.chlorinator.setChlorAsync(c);
+          res.addModuleSuccess('chlorinator', `Add: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chlorinator', `Add: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring chlorinators: ${err.message}`); res.addModuleError('system', `Error restoring chlorinators: ${err.message}`); return false; }
+  }
+
+  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
+    try {
+      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      // Look at chlorinators.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.chlorinators.length; i++) {
+        let r = cfg.chlorinators[i];
+        let c = sys.chlorinators.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.chlorinators.length; i++) {
+        let c = sys.chlorinators.getItemByIndex(i);
+        let r = cfg.chlorinators.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating chlorinators for restore: ${err.message}`); }
+  }
+
   public async setChlorAsync(obj: any): Promise<ChlorinatorState> {
     try {
       let id = parseInt(obj.id, 10);
@@ -2232,7 +2867,7 @@ export class ChlorinatorCommands extends BoardCommands {
   public async deleteChlorAsync(obj: any): Promise<ChlorinatorState> {
     try {
       let id = parseInt(obj.id, 10);
-      if (isNaN(id)) obj.id = 1;
+      if (isNaN(id)) return Promise.reject(new InvalidEquipmentDataError(`Chlorinator id is not valid: ${obj.id}`, 'chlorinator', obj.id));
       let chlor = state.chlorinators.getItemById(id);
       chlor.isActive = false;
       await ncp.chlorinators.deleteChlorinatorAsync(id);
@@ -2256,6 +2891,56 @@ export class ChlorinatorCommands extends BoardCommands {
   }
 }
 export class ScheduleCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the schedules that should be removed.
+      for (let i = 0; i < ctx.schedules.remove.length; i++) {
+        let s = ctx.schedules.remove[i];
+        try {
+          await sys.board.schedules.deleteScheduleAsync(ctx.schedules.remove[i]);
+          res.addModuleSuccess('schedule', `Remove: ${s.id}-${s.circuitId}`);
+        } catch (err) { res.addModuleError('schedule', `Remove: ${s.id}-${s.circuitId} ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.schedules.update.length; i++) {
+        let s = ctx.schedules.update[i];
+        try {
+          await sys.board.schedules.setScheduleAsync(s);
+          res.addModuleSuccess('schedule', `Update: ${s.id}-${s.circuitId}`);
+        } catch (err) { res.addModuleError('schedule', `Update: ${s.id}-${s.circuitId} ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.schedules.add.length; i++) {
+        let s = ctx.schedules.add[i];
+        try {
+          // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+          // it won't error out.
+          sys.schedules.getItemById(s.id, true);
+          await sys.board.schedules.setScheduleAsync(s);
+          res.addModuleSuccess('schedule', `Add: ${s.id}-${s.circuitId}`);
+        } catch (err) { res.addModuleError('schedule', `Add: ${s.id}-${s.circuitId} ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring schedules: ${err.message}`); res.addModuleError('system', `Error restoring schedules: ${err.message}`); return false; }
+  }
+  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
+    try {
+      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      // Look at schedules.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.schedules.length; i++) {
+        let r = cfg.schedules[i];
+        let c = sys.schedules.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.schedules.length; i++) {
+        let c = sys.schedules.getItemByIndex(i);
+        let r = cfg.schedules.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating schedules for restore: ${err.message}`); }
+  }
+
   public transformDays(val: any): number {
     if (typeof val === 'number') return val;
     let edays = sys.board.valueMaps.scheduleDays.toArray();
@@ -2376,6 +3061,9 @@ export class ScheduleCommands extends BoardCommands {
       return Promise.reject(new InvalidEquipmentDataError(`Invalid circuit reference: ${circuit}`, 'Schedule', circuit));
     if (schedType === 128 && schedDays === 0) return Promise.reject(new InvalidEquipmentDataError(`Invalid schedule days: ${schedDays}. You must supply days that the schedule is to run.`, 'Schedule', schedDays));
 
+    // If we made it to here we are valid and the schedula and it state should exist.
+    sched = sys.schedules.getItemById(id, true);
+    ssched = state.schedules.getItemById(id, true);
     sched.circuit = ssched.circuit = circuit;
     sched.scheduleDays = ssched.scheduleDays = schedDays;
     sched.scheduleType = ssched.scheduleType = schedType;
@@ -2391,6 +3079,7 @@ export class ScheduleCommands extends BoardCommands {
     sched.startYear = startDate.getFullYear();
     sched.startMonth = startDate.getMonth() + 1;
     sched.startDay = startDate.getDate();
+    sched.isActive = sched.startTime !== 0;
 
     ssched.display = sched.display = display;
     if (typeof sched.startDate === 'undefined')
@@ -2428,10 +3117,10 @@ export class ScheduleCommands extends BoardCommands {
           (ssched.scheduleDays & dayVal) > 0 &&
           ts >= ssched.startTime && ts <= ssched.endTime) schedIsOn = true
         else schedIsOn = false;
-        if (schedIsOn !== ssched.isOn){
+        if (schedIsOn !== ssched.isOn) {
           // if the schedule state changes, it may affect the end time
-          sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(ssched.circuit), scirc, ssched.isOn);
           ssched.isOn = schedIsOn;
+          sys.board.circuits.setEndTime(sys.circuits.getInterfaceById(ssched.circuit), scirc, scirc.isOn, true);
         }
         ssched.emitEquipmentChange();
       }
@@ -2460,8 +3149,8 @@ export class ScheduleCommands extends BoardCommands {
     let days = sys.board.valueMaps.scheduleDays.transform(sched.scheduleDays).days;
     for (let i = 0; i < days.length; i++) {
       let schedDay = days[i].dow;
-      let dateDiff = schedDay + 7 - startDateDay % 7;
-      if (schedDay === startDateDay && sched.endTime > todayTime) dateDiff = 0;
+      let dateDiff = (schedDay + 7 - startDateDay) % 7;
+      if (schedDay === startDateDay && sched.endTime < todayTime) dateDiff = 7;
       let endDateTime = startDate.clone().addHours(dateDiff * 24, sched.endTime);
       if (nearestEndTime.getTime() === 0 || endDateTime.getTime() < nearestEndTime.getTime()) nearestEndTime = endDateTime;
     }
@@ -2477,8 +3166,8 @@ export class ScheduleCommands extends BoardCommands {
     let days = sys.board.valueMaps.scheduleDays.transform(sched.scheduleDays).days;
     for (let i = 0; i < days.length; i++) {
       let schedDay = days[i].dow;
-      let dateDiff = schedDay + 7 - startDateDay % 7;
-      if (schedDay === startDateDay && sched.startTime > todayTime) dateDiff = 0;
+      let dateDiff = (schedDay + 7 - startDateDay) % 7;
+      if (schedDay === startDateDay && sched.startTime < todayTime) dateDiff = 7;
       let startDateTime = startDate.clone().addHours(dateDiff * 24, sched.startTime);
       if (nearestStartTime.getTime() === 0 || startDateTime.getTime() < nearestStartTime.getTime()) nearestStartTime = startDateTime;
     }
@@ -2486,387 +3175,535 @@ export class ScheduleCommands extends BoardCommands {
   }
 }
 export class HeaterCommands extends BoardCommands {
-  public getInstalledHeaterTypes(body?: number): any {
-    let heaters = sys.heaters.get();
-    let types = sys.board.valueMaps.heaterTypes.toArray();
-    let inst = { total: 0 };
-    for (let i = 0; i < types.length; i++) if (types[i].name !== 'none') inst[types[i].name] = 0;
-    for (let i = 0; i < heaters.length; i++) {
-      let heater = heaters[i];
-      if (typeof body !== 'undefined' && heater.body !== 'undefined') {
-        if ((heater.body !== 32 && body !== heater.body + 1) || (heater.body === 32 && body > 2)) continue;
-      }
-      let type = types.find(elem => elem.val === heater.type);
-      if (typeof type !== 'undefined') {
-        if (inst[type.name] === 'undefined') inst[type.name] = 0;
-        inst[type.name] = inst[type.name] + 1;
-        if (heater.coolingEnabled === true && type.hasCoolSetpoint === true) inst['hasCoolSetpoint'] = true;
-        inst.total++;
-      }
-    }
-    return inst;
-  }
-  public isSolarInstalled(body?: number): boolean {
-    let heaters = sys.heaters.get();
-    let types = sys.board.valueMaps.heaterTypes.toArray();
-    for (let i = 0; i < heaters.length; i++) {
-      let heater = heaters[i];
-      if (typeof body !== 'undefined' && body !== heater.body) continue;
-      let type = types.find(elem => elem.val === heater.type);
-      if (typeof type !== 'undefined') {
-        switch (type.name) {
-          case 'solar':
+    public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+        try {
+            // First delete the heaters that should be removed.
+            for (let i = 0; i < ctx.heaters.remove.length; i++) {
+                let h = ctx.heaters.remove[i];
+                try {
+                    await sys.board.heaters.deleteHeaterAsync(h);
+                    res.addModuleSuccess('heater', `Remove: ${h.id}-${h.name}`);
+                } catch (err) { res.addModuleError('heater', `Remove: ${h.id}-${h.name}: ${err.message}`); }
+            }
+            for (let i = 0; i < ctx.heaters.update.length; i++) {
+                let h = ctx.heaters.update[i];
+                try {
+                    await sys.board.heaters.setHeaterAsync(h);
+                    res.addModuleSuccess('heater', `Update: ${h.id}-${h.name}`);
+                } catch (err) { res.addModuleError('heater', `Update: ${h.id}-${h.name}: ${err.message}`); }
+            }
+            for (let i = 0; i < ctx.heaters.add.length; i++) {
+                let h = ctx.heaters.add[i];
+                try {
+                    // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+                    // it won't error out.
+                    sys.heaters.getItemById(h, true);
+                    await sys.board.heaters.setHeaterAsync(h);
+                    res.addModuleSuccess('heater', `Add: ${h.id}-${h.name}`);
+                } catch (err) { res.addModuleError('heater', `Add: ${h.id}-${h.name}: ${err.message}`); }
+            }
             return true;
-        }
-      }
+        } catch (err) { logger.error(`Error restoring heaters: ${err.message}`); res.addModuleError('system', `Error restoring heaters: ${err.message}`); return false; }
     }
-  }
-  public isHeatPumpInstalled(body?: number): boolean {
-    let heaters = sys.heaters.get();
-    let types = sys.board.valueMaps.heaterTypes.toArray();
-    for (let i = 0; i < heaters.length; i++) {
-      let heater = heaters[i];
-      if (typeof body !== 'undefined' && body !== heater.body) continue;
-      let type = types.find(elem => elem.val === heater.type);
-      if (typeof type !== 'undefined') {
-        switch (type.name) {
-          case 'heatpump':
-            return true;
+    public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
+        try {
+            let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+            // Look at heaters.
+            let cfg = rest.poolConfig;
+            for (let i = 0; i < cfg.heaters.length; i++) {
+                let r = cfg.heaters[i];
+                let c = sys.heaters.find(elem => r.id === elem.id);
+                if (typeof c === 'undefined') ctx.add.push(r);
+                else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+            }
+            for (let i = 0; i < sys.heaters.length; i++) {
+                let c = sys.heaters.getItemByIndex(i);
+                let r = cfg.heaters.find(elem => elem.id == c.id);
+                if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+            }
+            return ctx;
+        } catch (err) { logger.error(`Error validating heaters for restore: ${err.message}`); }
+    }
+
+    public getInstalledHeaterTypes(body?: number): any {
+        let heaters = sys.heaters.get();
+        let types = sys.board.valueMaps.heaterTypes.toArray();
+        let inst = { total: 0 };
+        for (let i = 0; i < types.length; i++) if (types[i].name !== 'none') inst[types[i].name] = 0;
+        for (let i = 0; i < heaters.length; i++) {
+            let heater = heaters[i];
+            if (typeof body !== 'undefined' && heater.body !== 'undefined') {
+                if ((heater.body !== 32 && body !== heater.body + 1) || (heater.body === 32 && body > 2)) continue;
+            }
+            let type = types.find(elem => elem.val === heater.type);
+            if (typeof type !== 'undefined') {
+                if (inst[type.name] === 'undefined') inst[type.name] = 0;
+                inst[type.name] = inst[type.name] + 1;
+                if (heater.coolingEnabled === true && type.hasCoolSetpoint === true) inst['hasCoolSetpoint'] = true;
+                inst.total++;
+            }
         }
-      }
+        return inst;
     }
-  }
-  public setHeater(heater: Heater, obj?: any) {
-    if (typeof obj !== undefined) {
-      for (var s in obj)
-        heater[s] = obj[s];
+    public isSolarInstalled(body?: number): boolean {
+        let heaters = sys.heaters.get();
+        let types = sys.board.valueMaps.heaterTypes.toArray();
+        for (let i = 0; i < heaters.length; i++) {
+            let heater = heaters[i];
+            if (typeof body !== 'undefined' && body !== heater.body) continue;
+            let type = types.find(elem => elem.val === heater.type);
+            if (typeof type !== 'undefined') {
+                switch (type.name) {
+                    case 'solar':
+                        return true;
+                }
+            }
+        }
     }
-  }
-  public async setHeaterAsync(obj: any): Promise<Heater> {
-    try {
-      let id = typeof obj.id === 'undefined' ? -1 : parseInt(obj.id, 10);
-      if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError('Heater Id is not valid.', obj.id, 'Heater'));
-      else if (id < 256 && id > 0) return Promise.reject(new InvalidEquipmentIdError('Virtual Heaters controlled by njspc must have an Id > 256.', obj.id, 'Heater'));
-      let heater: Heater;
-      if (id <= 0) {
-        // We are adding a heater.  In this case all heaters are virtual.
-        let vheaters = sys.heaters.filter(h => h.isVirtual === true);
-        id = vheaters.length + 256;
-      }
-      heater = sys.heaters.getItemById(id, true);
-      if (typeof obj !== undefined) {
-        for (var s in obj) {
-          if (s === 'id') continue;
-          heater[s] = obj[s];
-        }
-      }
-      let hstate = state.heaters.getItemById(id, true);
-      hstate.isVirtual = heater.isVirtual = true;
-      hstate.name = heater.name;
-      hstate.type = heater.type;
-      heater.master = 1;
-      if (heater.master === 1) await ncp.heaters.setHeaterAsync(heater, obj);
-      await sys.board.heaters.updateHeaterServices();
-      await sys.board.heaters.syncHeaterStates();
-      return heater;
-    } catch (err) { return Promise.reject(new Error(`Error setting heater configuration: ${err}`)); }
-  }
-  public async deleteHeaterAsync(obj: any): Promise<Heater> {
-    try {
-      let id = parseInt(obj.id, 10);
-      if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError('Cannot delete.  Heater Id is not valid.', obj.id, 'Heater'));
-      let heater = sys.heaters.getItemById(id);
-      heater.isActive = false;
-      if (heater.master === 1) await ncp.heaters.deleteHeaterAsync(heater.id);
-      sys.heaters.removeItemById(id);
-      state.heaters.removeItemById(id);
-      sys.board.heaters.updateHeaterServices();
-      sys.board.heaters.syncHeaterStates();
-      return heater;
-    } catch (err) { return Promise.reject(`Error deleting heater: ${err.message}`) }
-  }
-  public updateHeaterServices() {
-    let htypes = sys.board.heaters.getInstalledHeaterTypes();
-    let solarInstalled = htypes.solar > 0;
-    let heatPumpInstalled = htypes.heatpump > 0;
-    let gasHeaterInstalled = htypes.gas > 0;
-
-    if (sys.heaters.length > 0) sys.board.valueMaps.heatSources = new byteValueMap([[0, { name: 'off', desc: 'Off' }]]);
-    if (gasHeaterInstalled) sys.board.valueMaps.heatSources.set(3, { name: 'heater', desc: 'Heater' });
-    if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatSources.merge([[5, { name: 'solar', desc: 'Solar Only' }], [21, { name: 'solarpref', desc: 'Solar Preferred' }]]);
-    else if (solarInstalled) sys.board.valueMaps.heatSources.set(5, { name: 'solar', desc: 'Solar' });
-    if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatSources.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Preferred' }]]);
-    else if (heatPumpInstalled) sys.board.valueMaps.heatSources.set(9, { name: 'heatpump', desc: 'Heat Pump' });
-    sys.board.valueMaps.heatSources.set(32, { name: 'nochange', desc: 'No Change' });
-
-    sys.board.valueMaps.heatModes = new byteValueMap([[0, { name: 'off', desc: 'Off' }]]);
-    if (gasHeaterInstalled) sys.board.valueMaps.heatModes.set(3, { name: 'heater', desc: 'Heater' });
-    if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatModes.merge([[5, { name: 'solar', desc: 'Solar Only' }], [21, { name: 'solarpref', desc: 'Solar Preferred' }]]);
-    else if (solarInstalled) sys.board.valueMaps.heatModes.set(5, { name: 'solar', desc: 'Solar' });
-    if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatModes.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Preferred' }]]);
-    else if (heatPumpInstalled) sys.board.valueMaps.heatModes.set(9, { name: 'heatpump', desc: 'Heat Pump' });
-    // Now set the body data.
-    for (let i = 0; i < sys.bodies.length; i++) {
-      let body = sys.bodies.getItemByIndex(i);
-      let btemp = state.temps.bodies.getItemById(body.id, body.isActive !== false);
-      let opts = sys.board.heaters.getInstalledHeaterTypes(body.id);
-      btemp.heaterOptions = opts;
-    }
-    this.setActiveTempSensors();
-  }
-  public initTempSensors() {
-    // Add in the potential sensors and delete the ones that shouldn't exist.
-    let maxPairs = sys.equipment.maxBodies + (sys.equipment.shared ? -1 : 0);
-    sys.equipment.tempSensors.getItemById('air', true, { id: 'air', isActive: true, calibration: 0 }).name = 'Air';
-    sys.equipment.tempSensors.getItemById('water1', true, { id: 'water1', isActive: true, calibration: 0 }).name = maxPairs == 1 ? 'Water' : 'Body 1';
-    sys.equipment.tempSensors.getItemById('solar1', true, { id: 'solar1', isActive: false, calibration: 0 }).name = maxPairs == 1 ? 'Solar' : 'Solar 1';
-    if (maxPairs > 1) {
-      sys.equipment.tempSensors.getItemById('water2', true, { id: 'water2', isActive: false, calibration: 0 }).name = 'Body 2';
-      sys.equipment.tempSensors.getItemById('solar2', true, { id: 'solar2', isActive: false, calibration: 0 }).name = 'Solar 2';
+    public isHeatPumpInstalled(body?: number): boolean {
+        let heaters = sys.heaters.get();
+        let types = sys.board.valueMaps.heaterTypes.toArray();
+        for (let i = 0; i < heaters.length; i++) {
+            let heater = heaters[i];
+            if (typeof body !== 'undefined' && body !== heater.body) continue;
+            let type = types.find(elem => elem.val === heater.type);
+            if (typeof type !== 'undefined') {
+                switch (type.name) {
+                    case 'heatpump':
+                        return true;
+                }
+            }
+        }
     }
-    else {
-      sys.equipment.tempSensors.removeItemById('water2');
-      sys.equipment.tempSensors.removeItemById('solar2');
+    public setHeater(heater: Heater, obj?: any) {
+        if (typeof obj !== undefined) {
+            for (var s in obj)
+                heater[s] = obj[s];
+        }
     }
-    if (maxPairs > 2) {
-      sys.equipment.tempSensors.getItemById('water3', true, { id: 'water3', isActive: false, calibration: 0 }).name = 'Body 3';
-      sys.equipment.tempSensors.getItemById('solar3', true, { id: 'solar3', isActive: false, calibration: 0 }).name = 'Solar 3';
+    public async setHeaterAsync(obj: any): Promise<Heater> {
+        try {
+            let id = typeof obj.id === 'undefined' ? -1 : parseInt(obj.id, 10);
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError('Heater Id is not valid.', obj.id, 'Heater'));
+            else if (id < 256 && id > 0) return Promise.reject(new InvalidEquipmentIdError('Virtual Heaters controlled by njspc must have an Id > 256.', obj.id, 'Heater'));
+            let heater: Heater;
+            if (id <= 0) {
+                // We are adding a heater.  In this case all heaters are virtual.
+                let vheaters = sys.heaters.filter(h => h.master === 1);
+                id = vheaters.length + 256;
+            }
+            heater = sys.heaters.getItemById(id, true);
+            if (typeof obj !== undefined) {
+                for (var s in obj) {
+                    if (s === 'id') continue;
+                    heater[s] = obj[s];
+                }
+            }
+            let hstate = state.heaters.getItemById(id, true);
+            //hstate.isVirtual = heater.isVirtual = true;
+            hstate.name = heater.name;
+            hstate.type = heater.type;
+            heater.master = 1;
+            if (heater.master === 1) await ncp.heaters.setHeaterAsync(heater, obj);
+            await sys.board.heaters.updateHeaterServices();
+            await sys.board.heaters.syncHeaterStates();
+            return heater;
+        } catch (err) { return Promise.reject(new Error(`Error setting heater configuration: ${err}`)); }
     }
-    else {
-      sys.equipment.tempSensors.removeItemById('water3');
-      sys.equipment.tempSensors.removeItemById('solar3');
+    public async deleteHeaterAsync(obj: any): Promise<Heater> {
+        try {
+            let id = parseInt(obj.id, 10);
+            if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError('Cannot delete.  Heater Id is not valid.', obj.id, 'Heater'));
+            let heater = sys.heaters.getItemById(id);
+            heater.isActive = false;
+            if (heater.master === 1) await ncp.heaters.deleteHeaterAsync(heater.id);
+            sys.heaters.removeItemById(id);
+            state.heaters.removeItemById(id);
+            sys.board.heaters.updateHeaterServices();
+            sys.board.heaters.syncHeaterStates();
+            return heater;
+        } catch (err) { return Promise.reject(`Error deleting heater: ${err.message}`) }
     }
-    if (maxPairs > 3) {
-      sys.equipment.tempSensors.getItemById('water4', true, { id: 'water4', isActive: false, calibration: 0 }).name = 'Body 4';
-      sys.equipment.tempSensors.getItemById('solar4', true, { id: 'solar4', isActive: false, calibration: 0 }).name = 'Solar 4';
+    public updateHeaterServices() {
+        let htypes = sys.board.heaters.getInstalledHeaterTypes();
+        let solarInstalled = htypes.solar > 0;
+        let heatPumpInstalled = htypes.heatpump > 0;
+        let gasHeaterInstalled = htypes.gas > 0;
+
+        if (sys.heaters.length > 0) sys.board.valueMaps.heatSources = new byteValueMap([[0, { name: 'off', desc: 'Off' }]]);
+        if (gasHeaterInstalled) sys.board.valueMaps.heatSources.set(3, { name: 'heater', desc: 'Heater' });
+        if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatSources.merge([[5, { name: 'solar', desc: 'Solar Only' }], [21, { name: 'solarpref', desc: 'Solar Preferred' }]]);
+        else if (solarInstalled) sys.board.valueMaps.heatSources.set(5, { name: 'solar', desc: 'Solar' });
+        if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatSources.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Preferred' }]]);
+        else if (heatPumpInstalled) sys.board.valueMaps.heatSources.set(9, { name: 'heatpump', desc: 'Heat Pump' });
+        sys.board.valueMaps.heatSources.set(32, { name: 'nochange', desc: 'No Change' });
+
+        sys.board.valueMaps.heatModes = new byteValueMap([[0, { name: 'off', desc: 'Off' }]]);
+        if (gasHeaterInstalled) sys.board.valueMaps.heatModes.set(3, { name: 'heater', desc: 'Heater' });
+        if (solarInstalled && (gasHeaterInstalled || heatPumpInstalled)) sys.board.valueMaps.heatModes.merge([[5, { name: 'solar', desc: 'Solar Only' }], [21, { name: 'solarpref', desc: 'Solar Preferred' }]]);
+        else if (solarInstalled) sys.board.valueMaps.heatModes.set(5, { name: 'solar', desc: 'Solar' });
+        if (heatPumpInstalled && (gasHeaterInstalled || solarInstalled)) sys.board.valueMaps.heatModes.merge([[9, { name: 'heatpump', desc: 'Heatpump Only' }], [25, { name: 'heatpumppref', desc: 'Heat Pump Preferred' }]]);
+        else if (heatPumpInstalled) sys.board.valueMaps.heatModes.set(9, { name: 'heatpump', desc: 'Heat Pump' });
+        // Now set the body data.
+        for (let i = 0; i < sys.bodies.length; i++) {
+            let body = sys.bodies.getItemByIndex(i);
+            let btemp = state.temps.bodies.getItemById(body.id, body.isActive !== false);
+            let opts = sys.board.heaters.getInstalledHeaterTypes(body.id);
+            btemp.heaterOptions = opts;
+        }
+        this.setActiveTempSensors();
     }
-    else {
-      sys.equipment.tempSensors.removeItemById('water4');
-      sys.equipment.tempSensors.removeItemById('solar4');
-    }
-
-  }
-  // Sets the active temp sensors based upon the installed equipment.  At this point all
-  // detectable temp sensors should exist.
-  public setActiveTempSensors() {
-    let htypes;
-    // We are iterating backwards through the sensors array on purpose.  We do this just in case we need
-    // to remove a sensor during the iteration.  This way the index values will not be impacted and we can
-    // safely remove from the array we are iterating.
-    for (let i = sys.equipment.tempSensors.length - 1; i >= 0; i--) {
-      let sensor = sys.equipment.tempSensors.getItemByIndex(i);
-      // The names are normalized in this array.
-      switch (sensor.id) {
-        case 'air':
-          sensor.isActive = true;
-          break;
-        case 'water1':
-          sensor.isActive = sys.equipment.maxBodies > 0;
-          break;
-        case 'water2':
-          sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 2 : sys.equipment.maxBodies > 1;
-          break;
-        case 'water3':
-          sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 3 : sys.equipment.maxBodies > 2;
-          break;
-        case 'water4':
-          // It's a little weird but technically you should be able to install 3 expansions and a i10D personality
-          // board.  If this situation ever comes up we will see if it works. Whether it reports is another story
-          // since the 2 message is short a byte for this.
-          sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 4 : sys.equipment.maxBodies > 3;
-          break;
-        // Solar sensors are funny ducks. This is because they are for both heatpumps and solar and the equipment
-        // can be installed on specific bodies.  This will be true for heaters installed in expansion panels for *Touch, dual body systems,
-        // and any IntelliCenter with more than one body.  At some point simply implementing the multi-body functions for touch will make
-        // this all work. This will only be with i10D or expansion panels.
-        case 'solar1':
-          // The first solar sensor is a funny duck in that it should be active for shared systems
-          // if either body has an active solar heater or heatpump.
-          htypes = sys.board.heaters.getInstalledHeaterTypes(1);
-          if ('solar' in htypes || 'heatpump' in htypes) sensor.isActive = true;
-          else if (sys.equipment.shared) {
-            htypes = sys.board.heaters.getInstalledHeaterTypes(2);
-            sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
-          }
-          else sensor.isActive = false;
-          break;
-        case 'solar2':
-          if (sys.equipment.maxBodies > 1 + (sys.equipment.shared ? 1 : 0)) {
-            htypes = sys.board.heaters.getInstalledHeaterTypes(2 + (sys.equipment.shared ? 1 : 0));
-            sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
-          }
-          else sensor.isActive = false;
-          break;
-        case 'solar3':
-          if (sys.equipment.maxBodies > 2 + (sys.equipment.shared ? 1 : 0)) {
-            htypes = sys.board.heaters.getInstalledHeaterTypes(3 + (sys.equipment.shared ? 1 : 0));
-            sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
-          }
-          else sensor.isActive = false;
-          break;
-        case 'solar4':
-          if (sys.equipment.maxBodies > 3 + (sys.equipment.shared ? 1 : 0)) {
-            htypes = sys.board.heaters.getInstalledHeaterTypes(4 + (sys.equipment.shared ? 1 : 0));
-            sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
-          }
-          else sensor.isActive = false;
-          break;
-        default:
-          if (typeof sensor.id === 'undefined') sys.equipment.tempSensors.removeItemByIndex(i);
-          break;
-      }
+    public initTempSensors() {
+        // Add in the potential sensors and delete the ones that shouldn't exist.
+        let maxPairs = sys.equipment.maxBodies + (sys.equipment.shared ? -1 : 0);
+        sys.equipment.tempSensors.getItemById('air', true, { id: 'air', isActive: true, calibration: 0 }).name = 'Air';
+        sys.equipment.tempSensors.getItemById('water1', true, { id: 'water1', isActive: true, calibration: 0 }).name = maxPairs == 1 ? 'Water' : 'Body 1';
+        sys.equipment.tempSensors.getItemById('solar1', true, { id: 'solar1', isActive: false, calibration: 0 }).name = maxPairs == 1 ? 'Solar' : 'Solar 1';
+        if (maxPairs > 1) {
+            sys.equipment.tempSensors.getItemById('water2', true, { id: 'water2', isActive: false, calibration: 0 }).name = 'Body 2';
+            sys.equipment.tempSensors.getItemById('solar2', true, { id: 'solar2', isActive: false, calibration: 0 }).name = 'Solar 2';
+        }
+        else {
+            sys.equipment.tempSensors.removeItemById('water2');
+            sys.equipment.tempSensors.removeItemById('solar2');
+        }
+        if (maxPairs > 2) {
+            sys.equipment.tempSensors.getItemById('water3', true, { id: 'water3', isActive: false, calibration: 0 }).name = 'Body 3';
+            sys.equipment.tempSensors.getItemById('solar3', true, { id: 'solar3', isActive: false, calibration: 0 }).name = 'Solar 3';
+        }
+        else {
+            sys.equipment.tempSensors.removeItemById('water3');
+            sys.equipment.tempSensors.removeItemById('solar3');
+        }
+        if (maxPairs > 3) {
+            sys.equipment.tempSensors.getItemById('water4', true, { id: 'water4', isActive: false, calibration: 0 }).name = 'Body 4';
+            sys.equipment.tempSensors.getItemById('solar4', true, { id: 'solar4', isActive: false, calibration: 0 }).name = 'Solar 4';
+        }
+        else {
+            sys.equipment.tempSensors.removeItemById('water4');
+            sys.equipment.tempSensors.removeItemById('solar4');
+        }
+
     }
-  }
-  // This updates the heater states based upon the installed heaters.  This is true for heaters that are tied to the OCP
-  // and those that are not.
-  public syncHeaterStates() {
-    try {
-      // Go through the installed heaters and bodies to determine whether they should be on.  If there is a
-      // heater that is not controlled by the OCP then we need to determine whether it should be on.
-      let heaters = sys.heaters.toArray();
-      let bodies = state.temps.bodies.toArray();
-      let hon = [];
-      for (let i = 0; i < bodies.length; i++) {
-        let body: BodyTempState = bodies[i];
-        let cfgBody: Body = sys.bodies.getItemById(body.id);
-        let isHeating = false;
-        if (body.isOn) {
-          if (typeof body.temp === 'undefined' && heaters.length > 0) logger.warn(`The body temperature for ${body.name} cannot be determined. Heater status for this body cannot be calculated.`);
-          for (let j = 0; j < heaters.length; j++) {
-            let heater: Heater = heaters[j];
-            if (heater.isActive === false) continue;
-            let isOn = false;
-            // Determine whether the heater can be used on this body.
-            let isAssociated = false;
-            let b = sys.board.valueMaps.bodies.transform(heater.body);
-            switch (b.name) {
-              case 'body1':
-              case 'pool':
-                if (body.id === 1) isAssociated = true;
-                break;
-              case 'body2':
-              case 'spa':
-                if (body.id === 2) isAssociated = true;
-                break;
-              case 'poolspa':
-                if (body.id === 1 || body.id === 2) isAssociated = true;
-                break;
-              case 'body3':
-                if (body.id === 3) isAssociated = true;
-                break;
-              case 'body4':
-                if (body.id === 4) isAssociated = true;
-                break;
-            }
-            logger.silly(`Heater ${heater.name} is ${isAssociated === true ? '' : 'not '}associated with ${body.name}`);
-            if (isAssociated) {
-              let htype = sys.board.valueMaps.heaterTypes.transform(heater.type);
-              let status = sys.board.valueMaps.heatStatus.transform(body.heatStatus);
-              let hstate = state.heaters.getItemById(heater.id, true);
-              if (heater.isVirtual === true || heater.master === 1) {
-                // We need to do our own calculation as to whether it is on.  This is for Nixie heaters.
-                let mode = sys.board.valueMaps.heatModes.getName(body.heatMode);
-                switch (htype.name) {
-                  case 'solar':
-                    if (mode === 'solar' || mode === 'solarpref') {
-                      // Measure up against start and stop temp deltas for effective solar heating.
-                      if (body.temp < cfgBody.heatSetpoint &&
-                        state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('solar');
-                        isHeating = true;
-                      }
-                      else if (heater.coolingEnabled && body.temp > cfgBody.coolSetpoint && state.heliotrope.isNight &&
-                        state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('cooling');
-                        isHeating = true;
-                      }
-                      //else if (heater.coolingEnabled && state.time.isNight)
-                    }
+    // Sets the active temp sensors based upon the installed equipment.  At this point all
+    // detectable temp sensors should exist.
+    public setActiveTempSensors() {
+        let htypes;
+        // We are iterating backwards through the sensors array on purpose.  We do this just in case we need
+        // to remove a sensor during the iteration.  This way the index values will not be impacted and we can
+        // safely remove from the array we are iterating.
+        for (let i = sys.equipment.tempSensors.length - 1; i >= 0; i--) {
+            let sensor = sys.equipment.tempSensors.getItemByIndex(i);
+            // The names are normalized in this array.
+            switch (sensor.id) {
+                case 'air':
+                    sensor.isActive = true;
+                    break;
+                case 'water1':
+                    sensor.isActive = sys.equipment.maxBodies > 0;
+                    break;
+                case 'water2':
+                    sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 2 : sys.equipment.maxBodies > 1;
+                    break;
+                case 'water3':
+                    sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 3 : sys.equipment.maxBodies > 2;
                     break;
-                  case 'ultratemp':
-                    if (mode === 'ultratemp' || mode === 'ultratemppref') {
-                      if (body.temp < cfgBody.heatSetpoint &&
-                        state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpheat');
-                        isHeating = true;
-                      }
-                      else if (body.temp > cfgBody.coolSetpoint && heater.coolingEnabled) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpcool');
-                        isHeating = true;
-                      }
+                case 'water4':
+                    // It's a little weird but technically you should be able to install 3 expansions and a i10D personality
+                    // board.  If this situation ever comes up we will see if it works. Whether it reports is another story
+                    // since the 2 message is short a byte for this.
+                    sensor.isActive = sys.equipment.shared ? sys.equipment.maxBodies > 4 : sys.equipment.maxBodies > 3;
+                    break;
+                // Solar sensors are funny ducks. This is because they are for both heatpumps and solar and the equipment
+                // can be installed on specific bodies.  This will be true for heaters installed in expansion panels for *Touch, dual body systems,
+                // and any IntelliCenter with more than one body.  At some point simply implementing the multi-body functions for touch will make
+                // this all work. This will only be with i10D or expansion panels.
+                case 'solar1':
+                    // The first solar sensor is a funny duck in that it should be active for shared systems
+                    // if either body has an active solar heater or heatpump.
+                    htypes = sys.board.heaters.getInstalledHeaterTypes(1);
+                    if ('solar' in htypes || 'heatpump' in htypes) sensor.isActive = true;
+                    else if (sys.equipment.shared) {
+                        htypes = sys.board.heaters.getInstalledHeaterTypes(2);
+                        sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
                     }
+                    else sensor.isActive = false;
                     break;
-                  case 'gas':
-                    if (mode === 'heater') {
-                      if (body.temp < cfgBody.setPoint) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
-                        isHeating = true;
-                      }
+                case 'solar2':
+                    if (sys.equipment.maxBodies > 1 + (sys.equipment.shared ? 1 : 0)) {
+                        htypes = sys.board.heaters.getInstalledHeaterTypes(2 + (sys.equipment.shared ? 1 : 0));
+                        sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
                     }
-                    else if (mode === 'solarpref' || mode === 'heatpumppref') {
-                      // If solar should be running gas heater should be off.
-                      if (body.temp < cfgBody.setPoint &&
-                        state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) isOn = false;
-                      else if (body.temp < cfgBody.setPoint) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
-                        isHeating = true;
-                      }
+                    else sensor.isActive = false;
+                    break;
+                case 'solar3':
+                    if (sys.equipment.maxBodies > 2 + (sys.equipment.shared ? 1 : 0)) {
+                        htypes = sys.board.heaters.getInstalledHeaterTypes(3 + (sys.equipment.shared ? 1 : 0));
+                        sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
                     }
+                    else sensor.isActive = false;
                     break;
-                  case 'heatpump':
-                    if (mode === 'heatpump' || mode === 'heatpumppref') {
-                      if (body.temp < cfgBody.setPoint &&
-                        state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
-                        isOn = true;
-                        body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
-                        isHeating = true;
-                      }
+                case 'solar4':
+                    if (sys.equipment.maxBodies > 3 + (sys.equipment.shared ? 1 : 0)) {
+                        htypes = sys.board.heaters.getInstalledHeaterTypes(4 + (sys.equipment.shared ? 1 : 0));
+                        sensor.isActive = ('solar' in htypes || 'heatpump' in htypes);
                     }
+                    else sensor.isActive = false;
                     break;
-                  default:
-                    isOn = utils.makeBool(hstate.isOn);
+                default:
+                    if (typeof sensor.id === 'undefined') sys.equipment.tempSensors.removeItemByIndex(i);
                     break;
-                }
-                logger.debug(`Heater Type: ${htype.name} Mode:${mode} Temp: ${body.temp} Setpoint: ${cfgBody.setPoint} Status: ${body.heatStatus}`);
-              }
-              if (isOn === true && typeof hon.find(elem => elem === heater.id) === 'undefined') {
-                hon.push(heater.id);
-                if (heater.master === 1 && isOn) (async () => {
-                  try {
-                    await ncp.heaters.setHeaterStateAsync(hstate, isOn);
-                  } catch (err) { logger.error(err.message); }
-                })();
-                else hstate.isOn = isOn;
-              }
             }
-          }
         }
-        // When the controller is a virtual one we need to control the heat status ourselves.
-        if (!isHeating && (sys.controllerType === ControllerType.Virtual || sys.controllerType === ControllerType.Nixie)) body.heatStatus = 0;
+    }
+    // This updates the heater states based upon the installed heaters.  This is true for heaters that are tied to the OCP
+    // and those that are not.
+    public syncHeaterStates() {
+        try {
+            // Go through the installed heaters and bodies to determine whether they should be on.  If there is a
+            // heater that is not controlled by the OCP then we need to determine whether it should be on.
+            let heaters = sys.heaters.toArray();
+            let bodies = state.temps.bodies.toArray();
+            let hon = [];
+            for (let i = 0; i < bodies.length; i++) {
+                let body: BodyTempState = bodies[i];
+                let cfgBody: Body = sys.bodies.getItemById(body.id);
+                let isHeating = false;
+                if (body.isOn) {
+                    if (typeof body.temp === 'undefined' && heaters.length > 0) logger.warn(`The body temperature for ${body.name} cannot be determined. Heater status for this body cannot be calculated.`);
+                    for (let j = 0; j < heaters.length; j++) {
+                        let heater: Heater = heaters[j];
+                        if (heater.isActive === false) continue;
+                        let isOn = false;
+                        let isCooling = false;
+                        let sensorTemp = state.temps.waterSensor1;
+                        if (body.id === 4) sensorTemp = state.temps.waterSensor4;
+                        if (body.id === 3) sensorTemp = state.temps.waterSensor3;
+                        if (body.id === 2 && !sys.equipment.shared) sensorTemp = state.temps.waterSensor2;
+
+                        // Determine whether the heater can be used on this body.
+                        let isAssociated = false;
+                        let b = sys.board.valueMaps.bodies.transform(heater.body);
+                        switch (b.name) {
+                            case 'body1':
+                            case 'pool':
+                                if (body.id === 1) isAssociated = true;
+                                break;
+                            case 'body2':
+                            case 'spa':
+                                if (body.id === 2) isAssociated = true;
+                                break;
+                            case 'poolspa':
+                                if (body.id === 1 || body.id === 2) isAssociated = true;
+                                break;
+                            case 'body3':
+                                if (body.id === 3) isAssociated = true;
+                                break;
+                            case 'body4':
+                                if (body.id === 4) isAssociated = true;
+                                break;
+                        }
+                        // logger.silly(`Heater ${heater.name} is ${isAssociated === true ? '' : 'not '}associated with ${body.name}`);
+                        if (isAssociated) {
+                            let htype = sys.board.valueMaps.heaterTypes.transform(heater.type);
+                            let status = sys.board.valueMaps.heatStatus.transform(body.heatStatus);
+                            let hstate = state.heaters.getItemById(heater.id, true);
+                            if (heater.master === 1) {
+                                // We need to do our own calculation as to whether it is on.  This is for Nixie heaters.
+                                let mode = sys.board.valueMaps.heatModes.getName(body.heatMode);
+                                switch (htype.name) {
+                                    case 'solar':
+                                        if (mode === 'solar' || mode === 'solarpref') {
+                                            // Measure up against start and stop temp deltas for effective solar heating.
+                                            if (body.temp < cfgBody.heatSetpoint &&
+                                                state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('solar');
+                                                isHeating = true;
+                                            }
+                                            else if (heater.coolingEnabled && body.temp > cfgBody.coolSetpoint && state.heliotrope.isNight &&
+                                                state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('cooling');
+                                                isHeating = true;
+                                                isCooling = true;
+                                            }
+                                        }
+                                        break;
+                                    case 'ultratemp':
+                                        // We need to determine whether we are going to use the air temp or the solar temp
+                                        // for the sensor.
+                                        let deltaTemp = Math.max(state.temps.air, state.temps.solar || 0);
+                                        if (mode === 'ultratemp' || mode === 'ultratemppref') {
+                                            if (body.temp < cfgBody.heatSetpoint &&
+                                                deltaTemp > body.temp + heater.differentialTemp || 0) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpheat');
+                                                isHeating = true;
+                                                isCooling = false;
+                                            }
+                                            else if (body.temp > cfgBody.coolSetpoint && heater.coolingEnabled) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('hpcool');
+                                                isHeating = true;
+                                                isCooling = true;
+                                            }
+                                        }
+                                        break;
+                                    case 'mastertemp':
+                                        if (mode === 'mtheater') {
+                                            if (body.temp < cfgBody.setPoint) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heaterTypes.getValue('mtheater');
+                                                isHeating = true;
+                                            }
+                                        }
+                                        break;
+                                    case 'maxetherm':
+                                    case 'gas':
+                                        if (mode === 'heater') {
+                                            if (body.temp < cfgBody.setPoint) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
+                                                isHeating = true;
+                                            }
+                                        }
+                                        else if (mode === 'solarpref' || mode === 'heatpumppref') {
+                                            // If solar should be running gas heater should be off.
+                                            if (body.temp < cfgBody.setPoint &&
+                                                state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) isOn = false;
+                                            else if (body.temp < cfgBody.setPoint) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
+                                                isHeating = true;
+                                            }
+                                        }
+                                        break;
+                                    case 'heatpump':
+                                        if (mode === 'heatpump' || mode === 'heatpumppref') {
+                                            if (body.temp < cfgBody.setPoint &&
+                                                state.temps.solar > body.temp + (hstate.isOn ? heater.stopTempDelta : heater.startTempDelta)) {
+                                                isOn = true;
+                                                body.heatStatus = sys.board.valueMaps.heatStatus.getValue('heater');
+                                                isHeating = true;
+                                            }
+                                        }
+                                        break;
+                                    default:
+                                        isOn = utils.makeBool(hstate.isOn);
+                                        break;
+                                }
+                                logger.debug(`Heater Type: ${htype.name} Mode:${mode} Temp: ${body.temp} Setpoint: ${cfgBody.setPoint} Status: ${body.heatStatus}`);
+                            }
+                            else {
+                                let mode = sys.board.valueMaps.heatModes.getName(body.heatMode);
+                                switch (htype.name) {
+                                    case 'mastertemp':
+                                        if (status === 'mtheater') isHeating = isOn = true;
+                                        break;
+                                    case 'maxetherm':
+                                    case 'gas':
+                                        if (status === 'heater') isHeating = isOn = true;
+                                        break;
+                                    case 'hybrid':
+                                    case 'ultratemp':
+                                    case 'heatpump':
+                                        if (mode === 'ultratemp' || mode === 'ultratemppref' || mode === 'heatpump' || mode === 'heatpumppref') {
+                                            if (status === 'heater') isHeating = isOn = true;
+                                            else if (status === 'cooling') isCooling = isOn = true;
+                                        }
+                                        break;
+                                    case 'solar':
+                                        if (mode === 'solar' || mode === 'solarpref') {
+                                            if (status === 'solar') isHeating = isOn = true;
+                                            else if (status === 'cooling') isCooling = isOn = true;
+                                        }
+                                        break;
+                                }
+                            }
+                            if (isOn === true && typeof hon.find(elem => elem === heater.id) === 'undefined') {
+                                hon.push(heater.id);
+                                if (heater.master === 1 && isOn) (async () => {
+                                    try {
+                                        await ncp.heaters.setHeaterStateAsync(hstate, isOn, isCooling);
+                                    } catch (err) { logger.error(err.message); }
+                                })();
+                                else hstate.isOn = isOn;
+                            }
+                        }
+                    }
+                }
+                // When the controller is a virtual one we need to control the heat status ourselves.
+                if (!isHeating && (sys.controllerType === ControllerType.Nixie)) body.heatStatus = 0;
+            }
+            // Turn off any heaters that should be off.  The code above only turns heaters on.
+            for (let i = 0; i < heaters.length; i++) {
+                let heater: Heater = heaters[i];
+                if (typeof hon.find(elem => elem === heater.id) === 'undefined') {
+                    let hstate = state.heaters.getItemById(heater.id, true);
+                    if (heater.master === 1) (async () => {
+                        try {
+                            await ncp.heaters.setHeaterStateAsync(hstate, false, false);
+                        } catch (err) { logger.error(err.message); }
+                    })();
+                    else hstate.isOn = false;
+                }
+            }
+        } catch (err) { logger.error(`Error synchronizing heater states`); }
+    }
+}
+export class ValveCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the valves that should be removed.
+      for (let i = 0; i < ctx.valves.remove.length; i++) {
+        let v = ctx.valves.remove[i];
+        try {
+          await sys.board.valves.deleteValveAsync(v);
+          res.addModuleSuccess('valve', `Remove: ${v.id}-${v.name}`);
+        } catch (err) { res.addModuleError('valve', `Remove: ${v.id}-${v.name}: ${err.message}`); }
       }
-      // Turn off any heaters that should be off.  The code above only turns heaters on.
-      for (let i = 0; i < heaters.length; i++) {
-        let heater: Heater = heaters[i];
-        if (typeof hon.find(elem => elem === heater.id) === 'undefined') {
-          let hstate = state.heaters.getItemById(heater.id, true);
-          if (heater.master === 1) (async () => {
-            try {
-              await ncp.heaters.setHeaterStateAsync(hstate, false);
-            } catch (err) { logger.error(err.message); }
-          })();
-          else hstate.isOn = false;
-        }
+      for (let i = 0; i < ctx.valves.update.length; i++) {
+        let v = ctx.valves.update[i];
+        try {
+          await sys.board.valves.setValveAsync(v);
+          res.addModuleSuccess('valve', `Update: ${v.id}-${v.name}`);
+        } catch (err) { res.addModuleError('valve', `Update: ${v.id}-${v.name}: ${err.message}`); }
       }
-    } catch (err) { logger.error(`Error synchronizing heater states`); }
+      for (let i = 0; i < ctx.valves.add.length; i++) {
+        let v = ctx.valves.add[i];
+        try {
+          // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+          // it won't error out.
+          sys.valves.getItemById(ctx.valves.add[i].id, true);
+          await sys.board.valves.setValveAsync(v);
+          res.addModuleSuccess('valve', `Add: ${v.id}-${v.name}`);
+        } catch (err) { res.addModuleError('valve', `Add: ${v.id}-${v.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring valves: ${err.message}`); res.addModuleError('system', `Error restoring valves: ${err.message}`); return false; }
   }
-}
-export class ValveCommands extends BoardCommands {
+
+  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
+    try {
+      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      // Look at valves.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.valves.length; i++) {
+        let r = cfg.valves[i];
+        let c = sys.valves.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.valves.length; i++) {
+        let c = sys.valves.getItemByIndex(i);
+        let r = cfg.valves.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating valves for restore: ${err.message}`); }
+  }
+
   public async setValveStateAsync(valve: Valve, vstate: ValveState, isDiverted: boolean) {
     if (valve.master === 1) await ncp.valves.setValveStateAsync(vstate, isDiverted);
     else
@@ -2944,6 +3781,60 @@ export class ValveCommands extends BoardCommands {
   }
 }
 export class ChemControllerCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the chemControllers that should be removed.
+      for (let i = 0; i < ctx.chemControllers.remove.length; i++) {
+        let c = ctx.chemControllers.remove[i];
+        try {
+          await sys.board.chemControllers.deleteChemControllerAsync(c);
+          res.addModuleSuccess('chemController', `Remove: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chemController', `Remove: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.chemControllers.update.length; i++) {
+        let c = ctx.chemControllers.update[i];
+        try {
+          await sys.board.chemControllers.setChemControllerAsync(c);
+          res.addModuleSuccess('chemController', `Update: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chemController', `Update: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.chemControllers.add.length; i++) {
+        let c = ctx.chemControllers.add[i];
+        try {
+          // pull a little trick to first add the data then perform the update.  This way we won't get a new id or
+          // it won't error out.
+          let chem = sys.chemControllers.getItemById(c.id, true);
+          // RSG 11.24.21.  setChemControllerAsync will only set the type/address if it thinks it's new.   
+          // For a restore, if we set the type/address here it will pass the validation steps.
+          chem.type = c.type;
+          // chem.address = c.address;
+          await sys.board.chemControllers.setChemControllerAsync(c);
+          res.addModuleSuccess('chemController', `Add: ${c.id}-${c.name}`);
+        } catch (err) { res.addModuleError('chemController', `Add: ${c.id}-${c.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring chemControllers: ${err.message}`); res.addModuleError('system', `Error restoring chemControllers: ${err.message}`); return false; }
+  }
+  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
+    try {
+      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      // Look at chemControllers.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.chemControllers.length; i++) {
+        let r = cfg.chemControllers[i];
+        let c = sys.chemControllers.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.chemControllers.length; i++) {
+        let c = sys.chemControllers.getItemByIndex(i);
+        let r = cfg.chemControllers.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating chemControllers for restore: ${err.message}`); }
+  }
+
   public async deleteChemControllerAsync(data: any): Promise<ChemController> {
     try {
       let id = typeof data.id !== 'undefined' ? parseInt(data.id, 10) : -1;
@@ -3082,12 +3973,62 @@ export class ChemControllerCommands extends BoardCommands {
   }
 }
 export class FilterCommands extends BoardCommands {
+  public async restore(rest: { poolConfig: any, poolState: any }, ctx: any, res: RestoreResults): Promise<boolean> {
+    try {
+      // First delete the filters that should be removed.
+      for (let i = 0; i < ctx.filters.remove.length; i++) {
+        let filter = ctx.filters.remove[i];
+        try {
+          sys.filters.removeItemById(filter.id);
+          state.filters.removeItemById(filter.id);
+          res.addModuleSuccess('filter', `Remove: ${filter.id}-${filter.name}`);
+        } catch (err) { res.addModuleError('filter', `Remove: ${filter.id}-${filter.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.filters.update.length; i++) {
+        let filter = ctx.filters.update[i];
+        try {
+          await sys.board.filters.setFilterAsync(filter);
+          res.addModuleSuccess('filter', `Update: ${filter.id}-${filter.name}`);
+        } catch (err) { res.addModuleError('filter', `Update: ${filter.id}-${filter.name}: ${err.message}`); }
+      }
+      for (let i = 0; i < ctx.filters.add.length; i++) {
+        let filter = ctx.filters.add[i];
+        try {
+          // pull a little trick to first add the data then perform the update.
+          sys.filters.getItemById(filter.id, true);
+          await sys.board.filters.setFilterAsync(filter);
+          res.addModuleSuccess('filter', `Add: ${filter.id}-${filter.name}`);
+        } catch (err) { res.addModuleError('filter', `Add: ${filter.id}-${filter.name}: ${err.message}`); }
+      }
+      return true;
+    } catch (err) { logger.error(`Error restoring filters: ${err.message}`); res.addModuleError('system', `Error restoring filters: ${err.message}`); return false; }
+  }
+  public async validateRestore(rest: { poolConfig: any, poolState: any }): Promise<{ errors: any, warnings: any, add: any, update: any, remove: any }> {
+    try {
+      let ctx = { errors: [], warnings: [], add: [], update: [], remove: [] };
+      // Look at filters.
+      let cfg = rest.poolConfig;
+      for (let i = 0; i < cfg.filters.length; i++) {
+        let r = cfg.filters[i];
+        let c = sys.filters.find(elem => r.id === elem.id);
+        if (typeof c === 'undefined') ctx.add.push(r);
+        else if (JSON.stringify(c.get()) !== JSON.stringify(r)) ctx.update.push(r);
+      }
+      for (let i = 0; i < sys.filters.length; i++) {
+        let c = sys.filters.getItemByIndex(i);
+        let r = cfg.filters.find(elem => elem.id == c.id);
+        if (typeof r === 'undefined') ctx.remove.push(c.get(true));
+      }
+      return ctx;
+    } catch (err) { logger.error(`Error validating filters for restore: ${err.message}`); }
+  }
+
   public async syncFilterStates() {
     try {
       for (let i = 0; i < sys.filters.length; i++) {
         // Run through all the valves to see whether they should be triggered or not.
         let filter = sys.filters.getItemByIndex(i);
-        if (filter.isActive) {
+        if (filter.isActive && !isNaN(filter.id)) {
           let fstate = state.filters.getItemById(filter.id, true);
           // Check to see if the associated body is on.
           await sys.board.filters.setFilterStateAsync(filter, fstate, sys.board.bodies.isBodyOn(filter.body));
@@ -3095,8 +4036,84 @@ export class FilterCommands extends BoardCommands {
       }
     } catch (err) { logger.error(`syncFilterStates: Error synchronizing filters ${err.message}`); }
   }
+  public async setFilterPressure(id: number, pressure: number, units?: string) {
+    try {
+      let filter = sys.filters.find(elem => elem.id === id);
+      if (typeof filter === 'undefined' || isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`setFilterPressure: Invalid equipmentId ${id}`, id, 'Filter'));
+      if (isNaN(pressure)) return Promise.reject(new InvalidEquipmentDataError(`setFilterPressure: Invalid filter pressure ${pressure} for ${filter.name}`, 'Filter', pressure));
+      let sfilter = state.filters.getItemById(filter.id, true);
+      // Convert the pressure to the units that we have set on the filter for the pressure units.
+      let pu = sys.board.valueMaps.pressureUnits.transform(filter.pressureUnits || 0);
+      if (typeof units === 'undefined' || units === '') units = pu.name;
+      sfilter.pressureUnits = filter.pressureUnits;
+      sfilter.pressure = Math.round(pressure * 1000) / 1000; // Round this to 3 decimal places just in case we are getting stupid scales.
+      // Check to see if our circuit is the only thing on.  If it is then we will be setting our current clean pressure to the incoming pressure and calculating a percentage.
+      // Rules for the circuit.
+      // 1. The assigned circuit must be on.
+      // 2. There must not be a current freeze condition
+      // 3. No heaters can be on.
+      // 4. The assigned circuit must be on exclusively but we will be ignoring any of the light circuit types for the exclusivity.
+      let cstate = state.circuits.getInterfaceById(filter.pressureCircuitId);
+      if (cstate.isOn && state.freeze !== true) {
+        // Ok so our circuit is on.  We need to check to see if any other circuits are on.  This includes heaters.  The reason for this is that even with
+        // a gas heater there may be a heater bypass that will screw up our numbers.  Certainly reflow on a solar heater will skew the numbers.
+        let hon = state.temps.bodies.toArray().find(elem => elem.isOn && (elem.heatStatus || 0) !== 0);
+        if (typeof hon === 'undefined') {
+          // Put together the circuit types that could be lights.  We don't want these.
+          let ctypes = [];
+          let funcs = sys.board.valueMaps.circuitFunctions.toArray();
+          for (let i = 0; i < funcs.length; i++) {
+            let f = funcs[i];
+            if (f.isLight) ctypes.push(f.val);
+          }
+          let con = state.circuits.find(elem => elem.isOn === true && elem.id !== filter.pressureCircuitId && elem.id !== 1 && elem.id !== 6 && !ctypes.includes(elem.type));
+          if (typeof con === 'undefined') {
+            // This check is the one that will be the most problematic.  For this reason we are only going to check features that are not generic.  If they are spillway
+            // it definitely has to be off.
+            let feats = state.features.toArray();
+            let fon = false;
+            for (let i = 0; i < feats.length && fon === false; i++) {
+              let f = feats[i];
+              if (!f.isOn) continue;
+              if (f.id === filter.pressureCircuitId) continue;
+              if (f.type !== 0) fon = true;
+              // Check to see if this feature is used on a valve.  This will make it
+              // not include this pressure either.  We do not care whether the valve is diverted or not.
+              if (typeof sys.valves.find(elem => elem.circuitId === f.id) !== 'undefined')
+                fon = true;
+              else {
+                // Finally if the feature happens to be used on a pump then we don't want it either.
+                let pumps = sys.pumps.get();
+                for (let j = 0; j < pumps.length; j++) {
+                  let pmp = pumps[j];
+                  if (typeof pmp.circuits !== 'undefined') {
+                    if (typeof pmp.circuits.find(elem => elem.circuit === f.id) !== 'undefined') {
+                      fon = true;
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+            if (!fon) {
+              // Finally we have a value we can believe in.
+              sfilter.refPressure = pressure;
+            }
+          }
+          else {
+            logger.verbose(`Circuit ${con.id}-${con.name} is currently on filter pressure for cleaning ignored.`);
+          }
+        }
+        else {
+          logger.verbose(`Heater for body ${hon.name} is currently on ${hon.heatStatus} filter pressure for cleaning skipped.`);
+        }
+      }
+      sfilter.emitEquipmentChange();
+    }
+    catch (err) { logger.error(`setFilterPressure: Error setting filter #${id} pressure to ${pressure}${units || ''}`); }
+  }
   public async setFilterStateAsync(filter: Filter, fstate: FilterState, isOn: boolean) { fstate.isOn = isOn; }
-  public setFilter(data: any): any {
+  public async setFilterAsync(data: any): Promise<Filter> {
     let id = typeof data.id === 'undefined' ? -1 : parseInt(data.id, 10);
     if (id <= 0) id = sys.filters.length + 1; // set max filters?
     if (isNaN(id)) return Promise.reject(new InvalidEquipmentIdError(`Invalid filter id: ${data.id}`, data.id, 'Filter'));
@@ -3105,50 +4122,48 @@ export class FilterCommands extends BoardCommands {
     let filterType = typeof data.filterType !== 'undefined' ? parseInt(data.filterType, 10) : filter.filterType;
     if (typeof filterType === 'undefined') filterType = sys.board.valueMaps.filterTypes.getValue('unknown');
 
-    if (typeof data.isActive !== 'undefined') {
-      if (utils.makeBool(data.isActive) === false) {
-        sys.filters.removeItemById(id);
-        state.filters.removeItemById(id);
-        return;
-      }
-    }
+    // The only way to delete a filter is to call deleteFilterAsync.
+    //if (typeof data.isActive !== 'undefined') {
+    //    if (utils.makeBool(data.isActive) === false) {
+    //        sys.filters.removeItemById(id);
+    //        state.filters.removeItemById(id);
+    //        return;
+    //    }
+    //}
 
     let body = typeof data.body !== 'undefined' ? data.body : filter.body;
     let name = typeof data.name !== 'undefined' ? data.name : filter.name;
-
-    let psi = typeof data.psi !== 'undefined' ? parseFloat(data.psi) : sfilter.psi;
-    let lastCleanDate = typeof data.lastCleanDate !== 'undefined' ? data.lastCleanDate : sfilter.lastCleanDate;
-    let filterPsi = typeof data.filterPsi !== 'undefined' ? parseInt(data.filterPsi, 10) : sfilter.filterPsi;
-    let needsCleaning = typeof data.needsCleaning !== 'undefined' ? data.needsCleaning : sfilter.needsCleaning;
-
-    // Ensure all the defaults.
-    if (isNaN(psi)) psi = 0;
     if (typeof body === 'undefined') body = 32;
-
     // At this point we should have all the data.  Validate it.
     if (!sys.board.valueMaps.filterTypes.valExists(filterType)) return Promise.reject(new InvalidEquipmentDataError(`Invalid filter type; ${filterType}`, 'Filter', filterType));
 
+    filter.pressureUnits = typeof data.pressureUnits !== 'undefined' ? data.pressureUnits || 0 : filter.pressureUnits || 0;
+    filter.pressureCircuitId = parseInt(data.pressureCircuitId || filter.pressureCircuitId || 6, 10);
+    filter.cleanPressure = parseFloat(data.cleanPressure || filter.cleanPressure || 0);
+    filter.dirtyPressure = parseFloat(data.dirtyPressure || filter.dirtyPressure || 0);
+
     filter.filterType = sfilter.filterType = filterType;
     filter.body = sfilter.body = body;
-    filter.filterType = sfilter.filterType = filterType;
     filter.name = sfilter.name = name;
     filter.capacity = typeof data.capacity === 'number' ? data.capacity : filter.capacity;
     filter.capacityUnits = typeof data.capacityUnits !== 'undefined' ? data.capacityUnits : filter.capacity;
-    sfilter.psi = psi;
-    sfilter.filterPsi = filterPsi;
-    filter.needsCleaning = sfilter.needsCleaning = needsCleaning;
-    filter.lastCleanDate = sfilter.lastCleanDate = lastCleanDate;
     filter.connectionId = typeof data.connectionId !== 'undefined' ? data.connectionId : filter.connectionId;
     filter.deviceBinding = typeof data.deviceBinding !== 'undefined' ? data.deviceBinding : filter.deviceBinding;
+    sfilter.pressureUnits = filter.pressureUnits;
+    sfilter.calcCleanPercentage();
     sfilter.emitEquipmentChange();
     return filter; // Always return the config when we are dealing with the config not state.
   }
-
-  public deleteFilter(data: any): any {
-    let id = typeof data.id === 'undefined' ? -1 : parseInt(data.id, 10);
-    if (isNaN(id)) return;
-    sys.filters.removeItemById(id);
-    state.filters.removeItemById(id);
-    return state.filters.getItemById(id);
+  public async deleteFilterAsync(data: any): Promise<Filter> {
+    try {
+      let id = typeof data.id === 'undefined' ? -1 : parseInt(data.id, 10);
+      let filter = sys.filters.getItemById(id);
+      let sfilter = state.filters.getItemById(filter.id);
+      filter.isActive = false;
+      sys.filters.removeItemById(id);
+      state.filters.removeItemById(id);
+      sfilter.emitEquipmentChange();
+      return filter;
+    } catch (err) { logger.error(`deleteFilterAsync: Error deleting filter ${err.message}`); }
   }
-}
+}