nodejs-poolcontroller 7.6.0 → 7.6.1

package/controller/nixie/valves/Valve.ts

@@ -1,170 +1,170 @@
-import { EquipmentNotFoundError, InvalidEquipmentDataError, InvalidEquipmentIdError, ParameterOutOfRangeError } from '../../Errors';
-import { utils, Timestamp } from '../../Constants';
-import { logger } from '../../../logger/Logger';
-
-import { NixieEquipment, NixieChildEquipment, NixieEquipmentCollection, INixieControlPanel } from "../NixieEquipment";
-import { Valve, ValveCollection, sys } from "../../../controller/Equipment";
-import { ValveState, state, } from "../../State";
-import { setTimeout, clearTimeout } from 'timers';
-import { NixieControlPanel } from '../Nixie';
-import { webApp, InterfaceServerResponse } from "../../../web/Server";
-
-export class NixieValveCollection extends NixieEquipmentCollection<NixieValve> {
-    public async deleteValveAsync(id: number) {
-        try {
-            for (let i = this.length - 1; i >= 0; i--) {
-                let valve = this[i];
-                if (valve.id === id) {
-                    await valve.closeAsync();
-                    this.splice(i, 1);
-                }
-            }
-        } catch (err) { return Promise.reject(`Nixie Control Panel deleteValveAsync ${err.message}`); }
-    }
-    public async setValveStateAsync(vstate: ValveState, isDiverted: boolean) {
-        try {
-            let valve: NixieValve = this.find(elem => elem.id === vstate.id) as NixieValve;
-            if (typeof valve === 'undefined') {
-                vstate.isDiverted = isDiverted;
-                return logger.error(`Nixie Control Panel Error setValveState could not find valve ${vstate.id}-${vstate.name}`);
-            }
-            await valve.setValveStateAsync(vstate, isDiverted);
-        } catch (err) { return Promise.reject(new Error(`Nixie Error setting valve state ${vstate.id}-${vstate.name}: ${err.message}`)); }
-    }
-    public async setValveAsync(valve: Valve, data: any) {
-        // By the time we get here we know that we are in control and this is a Nixie valve.
-        try {
-            let c: NixieValve = this.find(elem => elem.id === valve.id) as NixieValve;
-            if (typeof c === 'undefined') {
-                valve.master = 1;
-                c = new NixieValve(this.controlPanel, valve);
-                this.push(c);
-                await c.setValveAsync(data);
-                logger.info(`A valve was not found for id #${valve.id} creating valve`);
-            }
-            else {
-                await c.setValveAsync(data);
-            }
-        }
-        catch (err) { logger.error(`setValveAsync: ${err.message}`); return Promise.reject(err); }
-    }
-    public async initAsync(valves: ValveCollection) {
-        try {
-            for (let i = 0; i < valves.length; i++) {
-                let valve = valves.getItemByIndex(i);
-                if (valve.master === 1) {
-                    if (typeof this.find(elem => elem.id === valve.id) === 'undefined') {
-                        let nvalve = new NixieValve(this.controlPanel, valve);
-                        logger.info(`Initializing Nixie Valve ${nvalve.id}-${valve.name}`);
-                        this.push(nvalve);
-                    }
-                }
-            }
-        }
-        catch (err) { logger.error(`Nixie Valve initAsync Error: ${err.message}`); return Promise.reject(err); }
-    }
-    public async closeAsync() {
-        try {
-            for (let i = this.length - 1; i >= 0; i--) {
-                try {
-                    await this[i].closeAsync();
-                    this.splice(i, 1);
-                } catch (err) { logger.error(`Error stopping Nixie Valve ${err}`); }
-            }
-
-        } catch (err) { } // Don't bail if we have an errror.
-    }
-
-    public async initValveAsync(valve: Valve): Promise<NixieValve> {
-        try {
-            let c: NixieValve = this.find(elem => elem.id === valve.id) as NixieValve;
-            if (typeof c === 'undefined') {
-                c = new NixieValve(this.controlPanel, valve);
-                this.push(c);
-            }
-            return c;
-        } catch (err) { return Promise.reject(logger.error(`Nixie Controller: initValveAsync Error: ${err.message}`)); }
-    }
-
-}
-export class NixieValve extends NixieEquipment {
-    public pollingInterval: number = 10000;
-    private _pollTimer: NodeJS.Timeout = null;
-    public valve: Valve;
-    private _lastState;
-    constructor(ncp: INixieControlPanel, valve: Valve) {
-        super(ncp);
-        this.valve = valve;
-        this.pollEquipmentAsync();
-    }
-    public get id(): number { return typeof this.valve !== 'undefined' ? this.valve.id : -1; }
-    public async setValveStateAsync(vstate: ValveState, isDiverted: boolean) {
-        try {
-            // Here we go we need to set the valve state.
-            if (vstate.isDiverted !== isDiverted) {
-                logger.verbose(`Nixie: Set valve ${vstate.id}-${vstate.name} to ${isDiverted}`);
-            }
-            if (utils.isNullOrEmpty(this.valve.connectionId) || utils.isNullOrEmpty(this.valve.deviceBinding)) {
-                vstate.isDiverted = isDiverted;
-                return new InterfaceServerResponse(200, 'Success');
-            }
-            if (typeof this._lastState === 'undefined' || isDiverted || this._lastState !== isDiverted) {
-                let res = await NixieEquipment.putDeviceService(this.valve.connectionId, `/state/device/${this.valve.deviceBinding}`, { isOn: isDiverted, latch: isDiverted ? 10000 : undefined });
-                if (res.status.code === 200) this._lastState = vstate.isDiverted = isDiverted;
-                return res;
-            }
-            else {
-                vstate.isDiverted = isDiverted;
-                return new InterfaceServerResponse(200, 'Success');
-            }
-        } catch (err) { return logger.error(`Nixie Error setting valve state ${vstate.id}-${vstate.name}: ${err.message}`); }
-    }
-    public async setValveAsync(data: any) {
-        try {
-            let valve = this.valve;
-        }
-        catch (err) { logger.error(`Nixie setValveAsync: ${err.message}`); return Promise.reject(err); }
-    }
-    public async pollEquipmentAsync() {
-        let self = this;
-        try {
-            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
-            this._pollTimer = null;
-            let success = false;
-        }
-        catch (err) { logger.error(`Nixie Error polling valve - ${err}`); }
-        finally { this._pollTimer = setTimeout(async () => await self.pollEquipmentAsync(), this.pollingInterval || 10000); }
-    }
-    private async checkHardwareStatusAsync(connectionId: string, deviceBinding: string) {
-        try {
-            let dev = await NixieEquipment.getDeviceService(connectionId, `/status/device/${deviceBinding}`);
-            return dev;
-        } catch (err) { logger.error(`Nixie Valve checkHardwareStatusAsync: ${err.message}`); return { hasFault: true } }
-    }
-    public async validateSetupAsync(valve: Valve, vstate: ValveState) {
-        try {
-            if (typeof valve.connectionId !== 'undefined' && valve.connectionId !== ''
-                && typeof valve.deviceBinding !== 'undefined' && valve.deviceBinding !== '') {
-                try {
-                    let stat = await this.checkHardwareStatusAsync(valve.connectionId, valve.deviceBinding);
-                    // If we have a status check the return.
-                    vstate.commStatus = stat.hasFault ? 1 : 0;
-                } catch (err) { vstate.commStatus = 1; }
-            }
-            else
-                vstate.commStatus = 0;
-            // The validation will be different if the valve is on or not.  So lets get that information.
-        } catch (err) { logger.error(`Nixie Error checking Valve Hardware ${this.valve.name}: ${err.message}`); vstate.commStatus = 1; return Promise.reject(err); }
-    }
-    public async closeAsync() {
-        try {
-            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
-            this._pollTimer = null;
-            let vstate = state.valves.getItemById(this.valve.id);
-            this.setValveStateAsync(vstate, false);
-            vstate.emitEquipmentChange();
-        }
-        catch (err) { logger.error(`Nixie Valve closeAsync: ${err.message}`); return Promise.reject(err); }
-    }
-    public logData(filename: string, data: any) { this.controlPanel.logData(filename, data); }
-}
+import { EquipmentNotFoundError, InvalidEquipmentDataError, InvalidEquipmentIdError, ParameterOutOfRangeError } from '../../Errors';
+import { utils, Timestamp } from '../../Constants';
+import { logger } from '../../../logger/Logger';
+
+import { NixieEquipment, NixieChildEquipment, NixieEquipmentCollection, INixieControlPanel } from "../NixieEquipment";
+import { Valve, ValveCollection, sys } from "../../../controller/Equipment";
+import { ValveState, state, } from "../../State";
+import { setTimeout, clearTimeout } from 'timers';
+import { NixieControlPanel } from '../Nixie';
+import { webApp, InterfaceServerResponse } from "../../../web/Server";
+
+export class NixieValveCollection extends NixieEquipmentCollection<NixieValve> {
+    public async deleteValveAsync(id: number) {
+        try {
+            for (let i = this.length - 1; i >= 0; i--) {
+                let valve = this[i];
+                if (valve.id === id) {
+                    await valve.closeAsync();
+                    this.splice(i, 1);
+                }
+            }
+        } catch (err) { return Promise.reject(`Nixie Control Panel deleteValveAsync ${err.message}`); }
+    }
+    public async setValveStateAsync(vstate: ValveState, isDiverted: boolean) {
+        try {
+            let valve: NixieValve = this.find(elem => elem.id === vstate.id) as NixieValve;
+            if (typeof valve === 'undefined') {
+                vstate.isDiverted = isDiverted;
+                return logger.error(`Nixie Control Panel Error setValveState could not find valve ${vstate.id}-${vstate.name}`);
+            }
+            await valve.setValveStateAsync(vstate, isDiverted);
+        } catch (err) { return Promise.reject(new Error(`Nixie Error setting valve state ${vstate.id}-${vstate.name}: ${err.message}`)); }
+    }
+    public async setValveAsync(valve: Valve, data: any) {
+        // By the time we get here we know that we are in control and this is a Nixie valve.
+        try {
+            let c: NixieValve = this.find(elem => elem.id === valve.id) as NixieValve;
+            if (typeof c === 'undefined') {
+                valve.master = 1;
+                c = new NixieValve(this.controlPanel, valve);
+                this.push(c);
+                await c.setValveAsync(data);
+                logger.info(`A valve was not found for id #${valve.id} creating valve`);
+            }
+            else {
+                await c.setValveAsync(data);
+            }
+        }
+        catch (err) { logger.error(`setValveAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public async initAsync(valves: ValveCollection) {
+        try {
+            for (let i = 0; i < valves.length; i++) {
+                let valve = valves.getItemByIndex(i);
+                if (valve.master === 1) {
+                    if (typeof this.find(elem => elem.id === valve.id) === 'undefined') {
+                        let nvalve = new NixieValve(this.controlPanel, valve);
+                        logger.info(`Initializing Nixie Valve ${nvalve.id}-${valve.name}`);
+                        this.push(nvalve);
+                    }
+                }
+            }
+        }
+        catch (err) { logger.error(`Nixie Valve initAsync Error: ${err.message}`); return Promise.reject(err); }
+    }
+    public async closeAsync() {
+        try {
+            for (let i = this.length - 1; i >= 0; i--) {
+                try {
+                    await this[i].closeAsync();
+                    this.splice(i, 1);
+                } catch (err) { logger.error(`Error stopping Nixie Valve ${err}`); }
+            }
+
+        } catch (err) { } // Don't bail if we have an errror.
+    }
+
+    public async initValveAsync(valve: Valve): Promise<NixieValve> {
+        try {
+            let c: NixieValve = this.find(elem => elem.id === valve.id) as NixieValve;
+            if (typeof c === 'undefined') {
+                c = new NixieValve(this.controlPanel, valve);
+                this.push(c);
+            }
+            return c;
+        } catch (err) { return Promise.reject(logger.error(`Nixie Controller: initValveAsync Error: ${err.message}`)); }
+    }
+
+}
+export class NixieValve extends NixieEquipment {
+    public pollingInterval: number = 10000;
+    private _pollTimer: NodeJS.Timeout = null;
+    public valve: Valve;
+    private _lastState;
+    constructor(ncp: INixieControlPanel, valve: Valve) {
+        super(ncp);
+        this.valve = valve;
+        this.pollEquipmentAsync();
+    }
+    public get id(): number { return typeof this.valve !== 'undefined' ? this.valve.id : -1; }
+    public async setValveStateAsync(vstate: ValveState, isDiverted: boolean) {
+        try {
+            // Here we go we need to set the valve state.
+            if (vstate.isDiverted !== isDiverted) {
+                logger.verbose(`Nixie: Set valve ${vstate.id}-${vstate.name} to ${isDiverted}`);
+            }
+            if (utils.isNullOrEmpty(this.valve.connectionId) || utils.isNullOrEmpty(this.valve.deviceBinding)) {
+                vstate.isDiverted = isDiverted;
+                return new InterfaceServerResponse(200, 'Success');
+            }
+            if (typeof this._lastState === 'undefined' || isDiverted || this._lastState !== isDiverted) {
+                let res = await NixieEquipment.putDeviceService(this.valve.connectionId, `/state/device/${this.valve.deviceBinding}`, { isOn: isDiverted, latch: isDiverted ? 10000 : undefined });
+                if (res.status.code === 200) this._lastState = vstate.isDiverted = isDiverted;
+                return res;
+            }
+            else {
+                vstate.isDiverted = isDiverted;
+                return new InterfaceServerResponse(200, 'Success');
+            }
+        } catch (err) { return logger.error(`Nixie Error setting valve state ${vstate.id}-${vstate.name}: ${err.message}`); }
+    }
+    public async setValveAsync(data: any) {
+        try {
+            let valve = this.valve;
+        }
+        catch (err) { logger.error(`Nixie setValveAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public async pollEquipmentAsync() {
+        let self = this;
+        try {
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            let success = false;
+        }
+        catch (err) { logger.error(`Nixie Error polling valve - ${err}`); }
+        finally { this._pollTimer = setTimeout(async () => await self.pollEquipmentAsync(), this.pollingInterval || 10000); }
+    }
+    private async checkHardwareStatusAsync(connectionId: string, deviceBinding: string) {
+        try {
+            let dev = await NixieEquipment.getDeviceService(connectionId, `/status/device/${deviceBinding}`);
+            return dev;
+        } catch (err) { logger.error(`Nixie Valve checkHardwareStatusAsync: ${err.message}`); return { hasFault: true } }
+    }
+    public async validateSetupAsync(valve: Valve, vstate: ValveState) {
+        try {
+            if (typeof valve.connectionId !== 'undefined' && valve.connectionId !== ''
+                && typeof valve.deviceBinding !== 'undefined' && valve.deviceBinding !== '') {
+                try {
+                    let stat = await this.checkHardwareStatusAsync(valve.connectionId, valve.deviceBinding);
+                    // If we have a status check the return.
+                    vstate.commStatus = stat.hasFault ? 1 : 0;
+                } catch (err) { vstate.commStatus = 1; }
+            }
+            else
+                vstate.commStatus = 0;
+            // The validation will be different if the valve is on or not.  So lets get that information.
+        } catch (err) { logger.error(`Nixie Error checking Valve Hardware ${this.valve.name}: ${err.message}`); vstate.commStatus = 1; return Promise.reject(err); }
+    }
+    public async closeAsync() {
+        try {
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            let vstate = state.valves.getItemById(this.valve.id);
+            this.setValveStateAsync(vstate, false);
+            vstate.emitEquipmentChange();
+        }
+        catch (err) { logger.error(`Nixie Valve closeAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public logData(filename: string, data: any) { this.controlPanel.logData(filename, data); }
+}