nodejs-poolcontroller 8.1.2 → 8.4.0

package/controller/nixie/bodies/Body.ts

@@ -1,120 +1,120 @@
-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 { Body, BodyCollection, sys } from "../../../controller/Equipment";
-import { BodyTempState, state, } from "../../State";
-import { setTimeout, clearTimeout } from 'timers';
-import { NixieControlPanel } from '../Nixie';
-import { webApp, InterfaceServerResponse } from "../../../web/Server";
-
-export class NixieBodyCollection extends NixieEquipmentCollection<NixieBody> {
-    public async setBodyAsync(body: Body, data: any) {
-        // By the time we get here we know that we are in control and this is a REMChem.
-        try {
-            let c: NixieBody = this.find(elem => elem.id === body.id) as NixieBody;
-            if (typeof c === 'undefined') {
-                body.master = 1;
-                c = new NixieBody(this.controlPanel, body);
-                this.push(c);
-                await c.setBodyAsync(data);
-                logger.info(`A body was not found for id #${body.id} creating body`);
-            }
-            else {
-                await c.setBodyAsync(data);
-            }
-        }
-        catch (err) { logger.error(`setBodyAsync: ${err.message}`); return Promise.reject(err); }
-    }
-    public async initAsync(bodies: BodyCollection) {
-        try {
-            this.length = 0;
-            for (let i = 0; i < bodies.length; i++) {
-                let body = bodies.getItemByIndex(i);
-                if (body.master === 1) {
-                    if (typeof this.find(elem => elem.id === body.id) === 'undefined') {
-                        logger.info(`Initializing Nixie body ${body.name}`);
-                        let nbody = new NixieBody(this.controlPanel, body);
-                        this.push(nbody);
-                    }
-                }
-            }
-        }
-        catch (err) { logger.error(`Nixie Body initAsync: ${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 Body ${err}`); }
-            }
-
-        } catch (err) { } // Don't bail if we have an errror.
-    }
-
-}
-export class NixieBody extends NixieEquipment {
-    public pollingInterval: number = 10000;
-    private _pollTimer: NodeJS.Timeout = null;
-    public body: Body;
-    constructor(ncp: INixieControlPanel, body: Body) {
-        super(ncp);
-        this.body = body;
-        this.pollEquipmentAsync();
-        let bs = state.temps.bodies.getItemById(body.id);
-        bs.heaterCooldownDelay = false;
-        bs.heatStatus = 0;
-    }
-    public get id(): number { return typeof this.body !== 'undefined' ? this.body.id : -1; }
-    public async setBodyAsync(data: any) {
-        try {
-            let body = this.body;
-        }
-        catch (err) { logger.error(`Nixie setBodyAsync: ${err.message}`); return Promise.reject(err); }
-    }
-    public async setBodyStateAsync(bstate: BodyTempState, isOn: boolean) {
-        try {
-            // Here we go we need to set the valve state.
-            if (bstate.isOn !== isOn) {
-                logger.info(`Nixie: Set Body ${bstate.id}-${bstate.name} to ${isOn}`); 
-            }
-            bstate.isOn = isOn;
-        } catch (err) { logger.error(`Nixie Error setting body state ${bstate.id}-${bstate.name}: ${err.message}`); }
-    }
-
-    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 body - ${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 Body checkHardwareStatusAsync: ${err.message}`); return { hasFault: true } }
-    }
-    public async validateSetupAsync(body: Body, temp: BodyTempState) {
-        try {
-            // The validation will be different if the body is on or not.  So lets get that information.
-        } catch (err) { logger.error(`Nixie Error checking Body Hardware ${this.body.name}: ${err.message}`); return Promise.reject(err); }
-    }
-    public async closeAsync() {
-        try {
-            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
-            this._pollTimer = null;
-            let bstate = state.temps.bodies.getItemById(this.body.id);
-            await this.setBodyStateAsync(bstate, false);
-            bstate.emitEquipmentChange();
-        }
-        catch (err) { logger.error(`Nixie Body 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 { Body, BodyCollection, sys } from "../../../controller/Equipment";
+import { BodyTempState, state, } from "../../State";
+import { setTimeout, clearTimeout } from 'timers';
+import { NixieControlPanel } from '../Nixie';
+import { webApp, InterfaceServerResponse } from "../../../web/Server";
+
+export class NixieBodyCollection extends NixieEquipmentCollection<NixieBody> {
+    public async setBodyAsync(body: Body, data: any) {
+        // By the time we get here we know that we are in control and this is a REMChem.
+        try {
+            let c: NixieBody = this.find(elem => elem.id === body.id) as NixieBody;
+            if (typeof c === 'undefined') {
+                body.master = 1;
+                c = new NixieBody(this.controlPanel, body);
+                this.push(c);
+                await c.setBodyAsync(data);
+                logger.info(`A body was not found for id #${body.id} creating body`);
+            }
+            else {
+                await c.setBodyAsync(data);
+            }
+        }
+        catch (err) { logger.error(`setBodyAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public async initAsync(bodies: BodyCollection) {
+        try {
+            this.length = 0;
+            for (let i = 0; i < bodies.length; i++) {
+                let body = bodies.getItemByIndex(i);
+                if (body.master === 1) {
+                    if (typeof this.find(elem => elem.id === body.id) === 'undefined') {
+                        logger.info(`Initializing Nixie body ${body.name}`);
+                        let nbody = new NixieBody(this.controlPanel, body);
+                        this.push(nbody);
+                    }
+                }
+            }
+        }
+        catch (err) { logger.error(`Nixie Body initAsync: ${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 Body ${err}`); }
+            }
+
+        } catch (err) { } // Don't bail if we have an errror.
+    }
+
+}
+export class NixieBody extends NixieEquipment {
+    public pollingInterval: number = 10000;
+    private _pollTimer: NodeJS.Timeout = null;
+    public body: Body;
+    constructor(ncp: INixieControlPanel, body: Body) {
+        super(ncp);
+        this.body = body;
+        this.pollEquipmentAsync();
+        let bs = state.temps.bodies.getItemById(body.id);
+        bs.heaterCooldownDelay = false;
+        bs.heatStatus = 0;
+    }
+    public get id(): number { return typeof this.body !== 'undefined' ? this.body.id : -1; }
+    public async setBodyAsync(data: any) {
+        try {
+            let body = this.body;
+        }
+        catch (err) { logger.error(`Nixie setBodyAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public async setBodyStateAsync(bstate: BodyTempState, isOn: boolean) {
+        try {
+            // Here we go we need to set the valve state.
+            if (bstate.isOn !== isOn) {
+                logger.info(`Nixie: Set Body ${bstate.id}-${bstate.name} to ${isOn}`); 
+            }
+            bstate.isOn = isOn;
+        } catch (err) { logger.error(`Nixie Error setting body state ${bstate.id}-${bstate.name}: ${err.message}`); }
+    }
+
+    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 body - ${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 Body checkHardwareStatusAsync: ${err.message}`); return { hasFault: true } }
+    }
+    public async validateSetupAsync(body: Body, temp: BodyTempState) {
+        try {
+            // The validation will be different if the body is on or not.  So lets get that information.
+        } catch (err) { logger.error(`Nixie Error checking Body Hardware ${this.body.name}: ${err.message}`); return Promise.reject(err); }
+    }
+    public async closeAsync() {
+        try {
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            let bstate = state.temps.bodies.getItemById(this.body.id);
+            await this.setBodyStateAsync(bstate, false);
+            bstate.emitEquipmentChange();
+        }
+        catch (err) { logger.error(`Nixie Body closeAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public logData(filename: string, data: any) { this.controlPanel.logData(filename, data); }
+}

package/controller/nixie/bodies/Filter.ts

@@ -1,135 +1,135 @@
-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 { Filter, FilterCollection, sys } from "../../../controller/Equipment";
-import { FilterState, state, } from "../../State";
-import { setTimeout, clearTimeout } from 'timers';
-import { NixieControlPanel } from '../Nixie';
-import { webApp, InterfaceServerResponse } from "../../../web/Server";
-
-export class NixieFilterCollection extends NixieEquipmentCollection<NixieFilter> {
-    public async setFilterStateAsync(fstate: FilterState, val: boolean) {
-        try {
-            let f: NixieFilter = this.find(elem => elem.id === fstate.id) as NixieFilter;
-            if (typeof f === 'undefined') return Promise.reject(new Error(`NCP: Filter ${fstate.id}-${fstate.name} could not be found to set the state to ${val}.`));
-            await f.setFilterStateAsync(fstate, val);
-        }
-        catch (err) { return logger.error(`NCP: setCircuitFilterAsync ${fstate.id}-${fstate.name}: ${err.message}`); }
-    }
-
-    public async setFilterAsync(filter: Filter, data: any) {
-        // By the time we get here we know that we are in control and this is a REMChem.
-        try {
-            let c: NixieFilter = this.find(elem => elem.id === filter.id) as NixieFilter;
-            if (typeof c === 'undefined') {
-                filter.master = 1;
-                c = new NixieFilter(this.controlPanel, filter);
-                this.push(c);
-                await c.setFilterAsync(data);
-                logger.info(`A Filter was not found for id #${filter.id} creating Filter`);
-            }
-            else {
-                await c.setFilterAsync(data);
-            }
-        }
-        catch (err) { logger.error(`setFilterAsync: ${err.message}`); return Promise.reject(err); }
-    }
-    public async initAsync(filters: FilterCollection) {
-        try {
-            this.length = 0;
-            for (let i = 0; i < filters.length; i++) {
-                let filter = filters.getItemByIndex(i);
-                if (filter.master === 1) {
-                    if (typeof this.find(elem => elem.id === filter.id) === 'undefined') {
-                        logger.info(`Initializing Filter ${Filter.name}`);
-                        let nFilter = new NixieFilter(this.controlPanel, filter);
-                        this.push(nFilter);
-                    }
-                }
-            }
-        }
-        catch (err) { logger.error(`Nixie Filter initAsync: ${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 Filter ${err}`); }
-            }
-
-        } catch (err) { } // Don't bail if we have an errror.
-    }
-}
-export class NixieFilter extends NixieEquipment {
-    public pollingInterval: number = 10000;
-    private _pollTimer: NodeJS.Timeout = null;
-    private _lastState;
-    public filter: Filter;
-    constructor(ncp: INixieControlPanel, filter: Filter) {
-        super(ncp);
-        this.filter = filter;
-        this.pollEquipmentAsync();
-    }
-    public get id(): number { return typeof this.filter !== 'undefined' ? this.filter.id : -1; }
-    public async setFilterAsync(data: any) {
-        try {
-            let filter = this.filter;
-        }
-        catch (err) { logger.error(`Nixie setFilterAsync: ${err.message}`); return Promise.reject(err); }
-    }
-    public async setFilterStateAsync(fstate: FilterState, val: boolean): Promise<InterfaceServerResponse> {
-        try {
-            if (utils.isNullOrEmpty(this.filter.connectionId) || utils.isNullOrEmpty(this.filter.deviceBinding)) {
-                fstate.isOn = val;
-                return new InterfaceServerResponse(200, 'Success');
-            }
-            if (typeof this._lastState === 'undefined' || val || this._lastState !== val) {
-                let res = await NixieEquipment.putDeviceService(this.filter.connectionId, `/state/device/${this.filter.deviceBinding}`, { isOn: val, latch: val ? 10000 : undefined });
-                if (res.status.code === 200) this._lastState = fstate.isOn = val;
-                return res;
-            }
-            else {
-                fstate.isOn = val;
-                return new InterfaceServerResponse(200, 'Success');
-            }
-        } catch (err) { logger.error(`Nixie: Error setting filter state ${fstate.id}-${fstate.name} to ${val}`); }
-    }
-
-    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 Filter - ${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 Filter checkHardwareStatusAsync: ${err.message}`); return { hasFault: true } }
-    }
-    public async validateSetupAsync(Filter: Filter, temp: FilterState) {
-        try {
-            // The validation will be different if the Filter is on or not.  So lets get that information.
-        } catch (err) { logger.error(`Nixie Error checking Filter Hardware ${this.filter.name}: ${err.message}`); return Promise.reject(err); }
-    }
-    public async closeAsync() {
-        try {
-            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
-            this._pollTimer = null;
-            let fstate = state.filters.getItemById(this.filter.id);
-            logger.info(`Closing filter ${fstate.name}`)
-            await this.setFilterStateAsync(fstate, false);
-            fstate.emitEquipmentChange();
-        }
-        catch (err) { logger.error(`Nixie Filter 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 { Filter, FilterCollection, sys } from "../../../controller/Equipment";
+import { FilterState, state, } from "../../State";
+import { setTimeout, clearTimeout } from 'timers';
+import { NixieControlPanel } from '../Nixie';
+import { webApp, InterfaceServerResponse } from "../../../web/Server";
+
+export class NixieFilterCollection extends NixieEquipmentCollection<NixieFilter> {
+    public async setFilterStateAsync(fstate: FilterState, val: boolean) {
+        try {
+            let f: NixieFilter = this.find(elem => elem.id === fstate.id) as NixieFilter;
+            if (typeof f === 'undefined') return Promise.reject(new Error(`NCP: Filter ${fstate.id}-${fstate.name} could not be found to set the state to ${val}.`));
+            await f.setFilterStateAsync(fstate, val);
+        }
+        catch (err) { return logger.error(`NCP: setCircuitFilterAsync ${fstate.id}-${fstate.name}: ${err.message}`); }
+    }
+
+    public async setFilterAsync(filter: Filter, data: any) {
+        // By the time we get here we know that we are in control and this is a REMChem.
+        try {
+            let c: NixieFilter = this.find(elem => elem.id === filter.id) as NixieFilter;
+            if (typeof c === 'undefined') {
+                filter.master = 1;
+                c = new NixieFilter(this.controlPanel, filter);
+                this.push(c);
+                await c.setFilterAsync(data);
+                logger.info(`A Filter was not found for id #${filter.id} creating Filter`);
+            }
+            else {
+                await c.setFilterAsync(data);
+            }
+        }
+        catch (err) { logger.error(`setFilterAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public async initAsync(filters: FilterCollection) {
+        try {
+            this.length = 0;
+            for (let i = 0; i < filters.length; i++) {
+                let filter = filters.getItemByIndex(i);
+                if (filter.master === 1) {
+                    if (typeof this.find(elem => elem.id === filter.id) === 'undefined') {
+                        logger.info(`Initializing Filter ${Filter.name}`);
+                        let nFilter = new NixieFilter(this.controlPanel, filter);
+                        this.push(nFilter);
+                    }
+                }
+            }
+        }
+        catch (err) { logger.error(`Nixie Filter initAsync: ${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 Filter ${err}`); }
+            }
+
+        } catch (err) { } // Don't bail if we have an errror.
+    }
+}
+export class NixieFilter extends NixieEquipment {
+    public pollingInterval: number = 10000;
+    private _pollTimer: NodeJS.Timeout = null;
+    private _lastState;
+    public filter: Filter;
+    constructor(ncp: INixieControlPanel, filter: Filter) {
+        super(ncp);
+        this.filter = filter;
+        this.pollEquipmentAsync();
+    }
+    public get id(): number { return typeof this.filter !== 'undefined' ? this.filter.id : -1; }
+    public async setFilterAsync(data: any) {
+        try {
+            let filter = this.filter;
+        }
+        catch (err) { logger.error(`Nixie setFilterAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public async setFilterStateAsync(fstate: FilterState, val: boolean): Promise<InterfaceServerResponse> {
+        try {
+            if (utils.isNullOrEmpty(this.filter.connectionId) || utils.isNullOrEmpty(this.filter.deviceBinding)) {
+                fstate.isOn = val;
+                return new InterfaceServerResponse(200, 'Success');
+            }
+            if (typeof this._lastState === 'undefined' || val || this._lastState !== val) {
+                let res = await NixieEquipment.putDeviceService(this.filter.connectionId, `/state/device/${this.filter.deviceBinding}`, { isOn: val, latch: val ? 10000 : undefined });
+                if (res.status.code === 200) this._lastState = fstate.isOn = val;
+                return res;
+            }
+            else {
+                fstate.isOn = val;
+                return new InterfaceServerResponse(200, 'Success');
+            }
+        } catch (err) { logger.error(`Nixie: Error setting filter state ${fstate.id}-${fstate.name} to ${val}`); }
+    }
+
+    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 Filter - ${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 Filter checkHardwareStatusAsync: ${err.message}`); return { hasFault: true } }
+    }
+    public async validateSetupAsync(Filter: Filter, temp: FilterState) {
+        try {
+            // The validation will be different if the Filter is on or not.  So lets get that information.
+        } catch (err) { logger.error(`Nixie Error checking Filter Hardware ${this.filter.name}: ${err.message}`); return Promise.reject(err); }
+    }
+    public async closeAsync() {
+        try {
+            if (typeof this._pollTimer !== 'undefined' || this._pollTimer) clearTimeout(this._pollTimer);
+            this._pollTimer = null;
+            let fstate = state.filters.getItemById(this.filter.id);
+            logger.info(`Closing filter ${fstate.name}`)
+            await this.setFilterStateAsync(fstate, false);
+            fstate.emitEquipmentChange();
+        }
+        catch (err) { logger.error(`Nixie Filter closeAsync: ${err.message}`); return Promise.reject(err); }
+    }
+    public logData(filename: string, data: any) { this.controlPanel.logData(filename, data); }
+}