hoffmation-base 3.0.0-alpha.61 → 3.0.0-alpha.63

package/lib/server/devices/smartGarden/smartGardenMower.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartGardenMower = void 0;
+const smartGardenDevice_1 = require("./smartGardenDevice");
+const deviceType_1 = require("../deviceType");
+const DeviceCapability_1 = require("../DeviceCapability");
+const blockAutomaticHandler_1 = require("../../services/blockAutomaticHandler");
+const models_1 = require("../../../models");
+const sharedFunctions_1 = require("../sharedFunctions");
+const services_1 = require("../../services");
+class SmartGardenMower extends smartGardenDevice_1.SmartGardenDevice {
+    constructor(pInfo) {
+        super(pInfo, deviceType_1.DeviceType.SmartGardenMower);
+        /** @inheritDoc */
+        this.targetAutomaticState = false;
+        /** @inheritDoc */
+        this.settings = new models_1.ActuatorSettings();
+        /** @inheritDoc */
+        this.queuedValue = null;
+        this._lastPersist = 0;
+        this._actuatorOn = false;
+        this._activityControlStateId = `${pInfo.fullID}.SERVICE_MOWER_${this._deviceSerial}/activity_control_i`;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.actuator);
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.blockAutomatic);
+        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this), this.log.bind(this));
+    }
+    /** @inheritDoc */
+    get actuatorOn() {
+        return this._actuatorOn;
+    }
+    /** @inheritDoc */
+    restoreTargetAutomaticValue(c) {
+        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState));
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.queuedValue = null;
+        super.update(idSplit, state, initial, true);
+        if (idSplit.length < 6) {
+            return;
+        }
+        const folder = idSplit[4];
+        const stateName = idSplit[5];
+        if (folder.indexOf('SERVICE_MOWER') === 0) {
+            switch (stateName) {
+                case 'activity_value':
+                    this._actuatorOn = state.val;
+                    this.persist();
+                    break;
+            }
+        }
+    }
+    /** @inheritDoc */
+    setActuator(command) {
+        if (this._activityControlStateId === '') {
+            this.log(models_1.LogLevel.Error, 'Keine Switch ID bekannt.');
+            return;
+        }
+        sharedFunctions_1.LampUtils.setActuator(this, command);
+    }
+    /** @inheritDoc */
+    persist() {
+        var _a;
+        const now = services_1.Utils.nowMS();
+        if (this._lastPersist + 1000 > now) {
+            return;
+        }
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+        this._lastPersist = now;
+    }
+    /** @inheritDoc */
+    toggleActuator(command) {
+        const newVal = this.queuedValue !== null ? !this.queuedValue : !this._actuatorOn;
+        const setStateCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, command);
+        this.setActuator(setStateCommand);
+        return newVal;
+    }
+    /** @inheritDoc */
+    writeActuatorStateToDevice(c) {
+        if (!c.stateValue) {
+            this.park();
+            return;
+        }
+        // TODO: Add settings for duration
+        this.mov(4 * 60 * 60);
+    }
+    park(pauseGardenaPlan = true) {
+        if (pauseGardenaPlan) {
+            this.log(models_1.LogLevel.Info, 'Pausing Gardena Plan');
+            this.setState(this._activityControlStateId, 'PARK_UNTIL_FURTHER_NOTICE', undefined, (err) => {
+                this.log(models_1.LogLevel.Error, `Pausing gardena mower resulted in error: ${err}`);
+            });
+            return;
+        }
+        this.log(models_1.LogLevel.Info, 'Pausing until next task');
+        this.setState(this._activityControlStateId, 'PARK_UNTIL_NEXT_TASK', undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Pausing gardena mower resulted in error: ${err}`);
+        });
+    }
+    mov(durationInSeconds) {
+        this.log(models_1.LogLevel.Info, `Start moving for ${durationInSeconds} seconds`);
+        this.setState(this._activityControlStateId, durationInSeconds.toString(10), undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Starting gardena mower resulted in error: ${err}`);
+        });
+    }
+}
+exports.SmartGardenMower = SmartGardenMower;

package/lib/server/devices/smartGarden/smartGardenSensor.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import { iHumiditySensor, iTemperatureSensor } from '../baseDeviceInterfaces';
+import { SmartGardenDevice } from './smartGardenDevice';
+import { HumiditySensorChangeAction, TemperatureSensorChangeAction } from '../../../models';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class SmartGardenSensor extends SmartGardenDevice implements iHumiditySensor, iTemperatureSensor {
+    /** @inheritDoc */
+    readonly persistHumiditySensorInterval: NodeJS.Timeout;
+    /** @inheritDoc */
+    readonly persistTemperatureSensorInterval: NodeJS.Timeout;
+    private _humidityCallbacks;
+    private _humidity;
+    private _roomTemperature;
+    private _temperature;
+    private _temperaturCallbacks;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
+    get roomTemperature(): number;
+    /** @inheritDoc */
+    set roomTemperature(value: number);
+    /** @inheritDoc */
+    get humidity(): number;
+    private set humidity(value);
+    /** @inheritDoc */
+    get iTemperature(): number;
+    /** @inheritDoc */
+    get sTemperature(): string;
+    private set temperature(value);
+    /** @inheritDoc */
+    addHumidityCallback(pCallback: (action: HumiditySensorChangeAction) => void): void;
+    /** @inheritDoc */
+    addTempChangeCallback(pCallback: (action: TemperatureSensorChangeAction) => void): void;
+    /** @inheritDoc */
+    onTemperaturChange(newTemperatur: number): void;
+    /** @inheritDoc */
+    persistHumiditySensor(): void;
+    /** @inheritDoc */
+    persistTemperaturSensor(): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    dispose(): void;
+}

package/lib/server/devices/smartGarden/smartGardenSensor.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartGardenSensor = void 0;
+const baseDeviceInterfaces_1 = require("../baseDeviceInterfaces");
+const smartGardenDevice_1 = require("./smartGardenDevice");
+const models_1 = require("../../../models");
+const deviceType_1 = require("../deviceType");
+const DeviceCapability_1 = require("../DeviceCapability");
+const services_1 = require("../../services");
+class SmartGardenSensor extends smartGardenDevice_1.SmartGardenDevice {
+    constructor(pInfo) {
+        super(pInfo, deviceType_1.DeviceType.SmartGardenSensor);
+        /** @inheritDoc */
+        this.persistHumiditySensorInterval = services_1.Utils.guardedInterval(() => {
+            this.persistHumiditySensor();
+        }, 5 * 60 * 1000, this, false);
+        /** @inheritDoc */
+        this.persistTemperatureSensorInterval = services_1.Utils.guardedInterval(() => {
+            this.persistTemperaturSensor();
+        }, 5 * 60 * 1000, this, false);
+        this._humidityCallbacks = [];
+        this._humidity = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._roomTemperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._temperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        this._temperaturCallbacks = [];
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.humiditySensor);
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.temperatureSensor);
+    }
+    /** @inheritDoc */
+    get roomTemperature() {
+        return this._roomTemperature;
+    }
+    /** @inheritDoc */
+    set roomTemperature(value) {
+        this._roomTemperature = value;
+    }
+    /** @inheritDoc */
+    get humidity() {
+        return this._humidity;
+    }
+    set humidity(val) {
+        this._humidity = val;
+        for (const cb of this._humidityCallbacks) {
+            cb(new models_1.HumiditySensorChangeAction(this, val));
+        }
+    }
+    /** @inheritDoc */
+    get iTemperature() {
+        return this._temperature;
+    }
+    /** @inheritDoc */
+    get sTemperature() {
+        return `${this._temperature}°C`;
+    }
+    set temperature(val) {
+        this._temperature = val;
+        for (const cb of this._temperaturCallbacks) {
+            cb(new models_1.TemperatureSensorChangeAction(this, val));
+        }
+    }
+    /** @inheritDoc */
+    addHumidityCallback(pCallback) {
+        this._humidityCallbacks.push(pCallback);
+        if (this._humidity > 0) {
+            pCallback(new models_1.HumiditySensorChangeAction(this, this._humidity));
+        }
+    }
+    /** @inheritDoc */
+    addTempChangeCallback(pCallback) {
+        this._temperaturCallbacks.push(pCallback);
+        if (this._temperature > baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
+            pCallback(new models_1.TemperatureSensorChangeAction(this, this._temperature));
+        }
+    }
+    /** @inheritDoc */
+    onTemperaturChange(newTemperatur) {
+        this.roomTemperature = newTemperatur;
+    }
+    /** @inheritDoc */
+    persistHumiditySensor() {
+        var _a;
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistHumiditySensor(this);
+    }
+    /** @inheritDoc */
+    persistTemperaturSensor() {
+        var _a;
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistTemperatureSensor(this);
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        super.update(idSplit, state, initial, true);
+        if (idSplit.length < 6) {
+            return;
+        }
+        const folder = idSplit[4];
+        const stateName = idSplit[5];
+        if (folder.indexOf('SERVICE_SENSOR') === 0) {
+            switch (stateName) {
+                case 'soilHumidity_value':
+                    this.humidity = state.val;
+                    break;
+                case 'soilTemperature_value':
+                    this.temperature = state.val;
+                    break;
+            }
+        }
+    }
+    /** @inheritDoc */
+    dispose() {
+        if (this.persistTemperatureSensorInterval) {
+            clearInterval(this.persistTemperatureSensorInterval);
+        }
+        if (this.persistHumiditySensorInterval) {
+            clearInterval(this.persistHumiditySensorInterval);
+        }
+        super.dispose();
+    }
+}
+exports.SmartGardenSensor = SmartGardenSensor;

package/lib/server/devices/smartGarden/smartGardenService.d.ts

@@ -0,0 +1,7 @@
+import { deviceConfig } from '../../../models';
+import { SmartGardenDeviceRegistrationInfo } from './smartGardenDeviceRegistrationInfo';
+export declare class SmartGardenService {
+    private static readonly _registeredDevices;
+    static preRegisterDevice(id: string, registrationInfo: SmartGardenDeviceRegistrationInfo): void;
+    static processSmartGardenDevice(cDevConf: deviceConfig): void;
+}

package/lib/server/devices/smartGarden/smartGardenService.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartGardenService = void 0;
+const models_1 = require("../../../models");
+const services_1 = require("../../services");
+const IoBrokerDeviceInfo_1 = require("../IoBrokerDeviceInfo");
+const deviceType_1 = require("../deviceType");
+const devices_1 = require("../devices");
+const smartGardenSensor_1 = require("./smartGardenSensor");
+const smartGardenMower_1 = require("./smartGardenMower");
+const smartGardenValve_1 = require("./smartGardenValve");
+class SmartGardenService {
+    static preRegisterDevice(id, registrationInfo) {
+        this._registeredDevices.set(id, registrationInfo);
+    }
+    static processSmartGardenDevice(cDevConf) {
+        var _a;
+        const devName = (_a = cDevConf.common) === null || _a === void 0 ? void 0 : _a.name;
+        if (!devName || typeof devName !== 'string') {
+            return;
+        }
+        const registrationInfo = this._registeredDevices.get(devName);
+        if (!registrationInfo) {
+            services_1.ServerLogService.writeLog(models_1.LogLevel.Error, `SmartGarden Device ${devName} not registered`);
+            return;
+        }
+        const ioBrokerDeviceInfo = new IoBrokerDeviceInfo_1.IoBrokerDeviceInfo(cDevConf, registrationInfo.deviceId, deviceType_1.DeviceType[registrationInfo.deviceType], registrationInfo.room, registrationInfo.roomIndex);
+        const fullName = `${devices_1.Devices.IDENTIFIER_SMART_GARDEN}-${ioBrokerDeviceInfo.devID}`;
+        if (typeof devices_1.Devices.alLDevices[fullName] !== 'undefined') {
+            return;
+        }
+        ioBrokerDeviceInfo.allDevicesKey = fullName;
+        let d;
+        switch (registrationInfo.deviceType) {
+            case deviceType_1.DeviceType.SmartGardenSensor:
+                d = new smartGardenSensor_1.SmartGardenSensor(ioBrokerDeviceInfo);
+                break;
+            case deviceType_1.DeviceType.SmartGardenMower:
+                d = new smartGardenMower_1.SmartGardenMower(ioBrokerDeviceInfo);
+                break;
+            case deviceType_1.DeviceType.SmartGardenValve:
+                d = new smartGardenValve_1.SmartGardenValve(ioBrokerDeviceInfo);
+                break;
+            default:
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `No SmartGarden Device Type for ${registrationInfo.deviceType} defined`);
+                return;
+        }
+        devices_1.Devices.alLDevices[fullName] = d;
+    }
+}
+exports.SmartGardenService = SmartGardenService;
+SmartGardenService._registeredDevices = new Map();

package/lib/server/devices/smartGarden/smartGardenValve.d.ts

@@ -0,0 +1,36 @@
+import { SmartGardenDevice } from './smartGardenDevice';
+import { iActuator } from '../baseDeviceInterfaces';
+import { ActuatorSetStateCommand, ActuatorSettings, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand, RestoreTargetAutomaticValueCommand } from '../../../models';
+import { BlockAutomaticHandler } from '../../services/blockAutomaticHandler';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class SmartGardenValve extends SmartGardenDevice implements iActuator {
+    /** @inheritDoc */
+    readonly blockAutomationHandler: BlockAutomaticHandler;
+    /** @inheritDoc */
+    targetAutomaticState: boolean;
+    /** @inheritDoc */
+    settings: ActuatorSettings;
+    /** @inheritDoc */
+    queuedValue: boolean | null;
+    private _lastPersist;
+    private readonly _durationValueStateId;
+    private readonly _stopAllValvesStateId;
+    private _actuatorOn;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
+    get actuatorOn(): boolean;
+    /** @inheritDoc */
+    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    setActuator(command: ActuatorSetStateCommand): void;
+    /** @inheritDoc */
+    persist(): void;
+    /** @inheritDoc */
+    toggleActuator(command: ActuatorToggleCommand): boolean;
+    /** @inheritDoc */
+    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
+    private stopIrrigation;
+    private irrigate;
+}

package/lib/server/devices/smartGarden/smartGardenValve.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartGardenValve = void 0;
+const smartGardenDevice_1 = require("./smartGardenDevice");
+const models_1 = require("../../../models");
+const blockAutomaticHandler_1 = require("../../services/blockAutomaticHandler");
+const deviceType_1 = require("../deviceType");
+const DeviceCapability_1 = require("../DeviceCapability");
+const sharedFunctions_1 = require("../sharedFunctions");
+const services_1 = require("../../services");
+// TODO: Add iValve interface and DeviceCapability
+class SmartGardenValve extends smartGardenDevice_1.SmartGardenDevice {
+    constructor(pInfo) {
+        super(pInfo, deviceType_1.DeviceType.SmartGardenValve);
+        /** @inheritDoc */
+        this.targetAutomaticState = false;
+        /** @inheritDoc */
+        this.settings = new models_1.ActuatorSettings();
+        /** @inheritDoc */
+        this.queuedValue = null;
+        this._lastPersist = 0;
+        this._actuatorOn = false;
+        this._durationValueStateId = `${pInfo.fullID}.SERVICE_VALVE_${this._deviceSerial}/duration_value`;
+        this._stopAllValvesStateId = `${pInfo.fullID}.SERVICE_VALVE_SET_${this._deviceSerial}/stop_all_valves_i`;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.actuator);
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.blockAutomatic);
+        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this), this.log.bind(this));
+    }
+    /** @inheritDoc */
+    get actuatorOn() {
+        return this._actuatorOn;
+    }
+    /** @inheritDoc */
+    restoreTargetAutomaticValue(c) {
+        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState));
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.queuedValue = null;
+        super.update(idSplit, state, initial, true);
+        if (idSplit.length < 6) {
+            return;
+        }
+        const folder = idSplit[4];
+        const stateName = idSplit[5];
+        if (folder.indexOf('SERVICE_VALVE') === 0) {
+            switch (stateName) {
+                case 'activity_value':
+                    this._actuatorOn = state.val !== 'CLOSED';
+                    this.persist();
+                    break;
+            }
+        }
+    }
+    /** @inheritDoc */
+    setActuator(command) {
+        if (this._durationValueStateId === '') {
+            this.log(models_1.LogLevel.Error, 'Keine Switch ID bekannt.');
+            return;
+        }
+        sharedFunctions_1.LampUtils.setActuator(this, command);
+    }
+    /** @inheritDoc */
+    persist() {
+        var _a;
+        const now = services_1.Utils.nowMS();
+        if (this._lastPersist + 1000 > now) {
+            return;
+        }
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+        this._lastPersist = now;
+    }
+    /** @inheritDoc */
+    toggleActuator(command) {
+        const newVal = this.queuedValue !== null ? !this.queuedValue : !this._actuatorOn;
+        const setStateCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, command);
+        this.setActuator(setStateCommand);
+        return newVal;
+    }
+    /** @inheritDoc */
+    writeActuatorStateToDevice(c) {
+        if (!c.stateValue) {
+            this.stopIrrigation();
+            return;
+        }
+        // TODO: Add settings for duration
+        this.irrigate(15 * 60);
+    }
+    stopIrrigation() {
+        this.log(models_1.LogLevel.Info, 'Stopping irrigation until next task');
+        this.setState(this._stopAllValvesStateId, 'STOP_UNTIL_NEXT_TASK', undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Stopping irrigation immediately resulted in error: ${err}`);
+        });
+        this.setState(this._durationValueStateId, 'STOP_UNTIL_NEXT_TASK', undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Prevent irrigation restart resulted in error: ${err}`);
+        });
+    }
+    irrigate(durationInSeconds) {
+        this.log(models_1.LogLevel.Info, `Start irrigation for ${durationInSeconds} seconds`);
+        this.setState(this._durationValueStateId, durationInSeconds.toString(10), undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Starting irrigation resulted in error: ${err}`);
+        });
+    }
+}
+exports.SmartGardenValve = SmartGardenValve;