iobroker.iot 3.5.2 → 4.0.1

package/lib/AlexaSmartHomeV3/Controls/Control.js

@@ -1,352 +0,0 @@
-const AlexaResponse = require('../Alexa/AlexaResponse');
-const Utils = require('../Helpers/Utils');
-const Logger = require('../Helpers/Logger');
-const AdapterProvider = require('../Helpers/AdapterProvider');
-const Properties = require('../Alexa/Properties');
-
-/**
- * Represents the base functionality for a control in a smart device. A smart device has at least one control.
- * The specific functionality, natively supported capabilities, etc. are defined in derived classes.
- * @class
- */
-class Control {
-    /**
-     * @constructor
-     * @param detectedControl - The detected control in terms of iobroker type detector.
-     */
-    constructor(detectedControl) {
-        this.stateKeys = [
-            'SET',
-            'ACTUAL',
-            'ON_SET',
-            'ON_ACTUAL',
-            'POWER',
-            'MODE',
-            'HUE',
-            'DIMMER',
-            'BRIGHTNESS',
-            'SATURATION',
-            'TEMPERATURE',
-            'ON',
-            'MUTE',
-        ];
-        this.initStates(detectedControl);
-        this._supported = this.initCapabilities();
-        this._enforced = this.initEnforcedCapabilities();
-        this.log = new Logger(this);
-        this.log.silly(`created instance`);
-    }
-    /**
-     * This function maps a passed on control to an array of objects. Each object contains an Alexa capability the control natively supports
-     * and at least one property. Every property is initialized with corresponding iobroker state ids and value converters from Alexa to iobroker types
-     * and vice versa.
-     *
-     * @returns Array of objects with natively supported Alexa capabilities and correspondingly configured instances of StateProxies
-     */
-    initCapabilities() {
-        return [];
-    }
-    /**
-     * This function maps a passed on control to an array of objects. Each object contains an Alexa capability the control can handle even
-     * though not natively supported (e.g., the light control can handle the Alexa BrightnessController directive by switching
-     * itself `ON` on brightness > 0 and `OFF` on brightness == 0)
-     * Every capability has at least one property with set up iobroker state ids and value converters from Alexa to iobroker types
-     * and vice versa.
-     *
-     * @returns Array of objects with natively supported Alexa capabilities and correspondingly configured instances of StateProxies
-     */
-    initEnforcedCapabilities() {
-        return [];
-    }
-
-    get allCapabilities() {
-        return this.supported.concat(this.enforced);
-    }
-
-    static get type() {
-        return Utils.firstLower(Utils.className(this.toString()));
-    }
-    /**
-     * Getter for Alexa categories
-     */
-    get categories() {
-        return ['OTHER'];
-    }
-
-    get name() {
-        return `${this.constructor.name}`;
-    }
-    /**
-     * Getter for _supported
-     */
-    get supported() {
-        return this._supported;
-    }
-    /**
-     * Getter for _enforced
-     */
-    get enforced() {
-        return this._enforced;
-    }
-    /**
-     * This function returns whether the control natively supports the passed on Alexa directive.
-     * @param {*} event - The event containing the Alexa directive as it comes from AWS Alexa Service
-     * @returns {Boolean} - True if the control natively supports the directive, false - otherwise
-     */
-    supports(event) {
-        return this.supported.find(capability => capability.matches(event)) !== undefined;
-    }
-    /**
-     * This function returns whether the control though doesn't natively support the passed on Alexa directive, but able to handle it.
-     * @param {*} event - The event containing the Alexa directive as it comes from AWS Alexa Service
-     * @returns {Boolean} - True if the control can handle the directive, false - otherwise
-     */
-    canHandle(event) {
-        return this.enforced.find(capability => capability.matches(event)) !== undefined;
-    }
-    /**
-     * This function processes an Alexa directive. Usually the result of the processing is setting an iobroker state to some value
-     * as a reaction to an interaction with Alexa via voice, app, etc.
-     * @async
-     * @param {*} event - The event containing the Alexa directive as it comes from AWS Alexa Service
-     * @returns {Promise<Object>} - Object containing the response to be sent to Alexa Service
-     */
-    async handle(event) {
-        this.log.debug(`handling Alexa event`);
-        this.log.silly(`${JSON.stringify(event)}`);
-
-        const property = this.allCapabilities
-            .flatMap(item => item.properties)
-            .find(property => property.matches(event));
-
-        if (property) {
-            let alexaValue;
-            try {
-                const setter = this.valueSetter(event);
-                alexaValue = await setter(event, property);
-            } catch (error) {
-                this.log.debug(`${error}`);
-                this.log.error(`failed handling Alexa event`);
-                return Promise.reject(AlexaResponse.endpointUnreachable().get());
-            }
-
-            // even though the handler successfully processed the Alexa event,
-            // we return an error here for ENFORCED capabilities, to prevent
-            // reporting multiple successes for the same capability and
-            // running into a situation of returning a wrong value back to Alexa
-            if (this.enforced.find(capability => capability.matches(event))) {
-                return Promise.reject(AlexaResponse.directiveNotSupportedByControl(this.name, event?.directive?.header?.namespace, event?.directive?.header?.payloadVersion).get());
-            }
-
-            const response = AlexaResponse.handled(event, property.propertyName, property.reportValue(alexaValue), property.instance);
-
-            // though the processed directive required to change a single value, the response must contain values of all "relevant" properties
-            // Please refer to this for details: https://developer.amazon.com/en-US/docs/alexa/device-apis/alexa-thermostatcontroller.html#settargettemperature-response-event
-
-            // TODO: add values of relevant properties to response
-
-            this.log.silly(`${JSON.stringify(response.get())}`);
-            return response.get();
-        }
-
-        const errorResponse = AlexaResponse.directiveNotSupportedByControl(this.name, event?.directive?.header?.namespace);
-        this.log.silly(`${JSON.stringify(errorResponse.get())}`);
-        return Promise.reject(errorResponse.get());
-    }
-
-    valueSetter(event) {
-        return this.setValue.bind(this);
-    }
-
-    async setValue(event, property) {
-        // extract alexa value from event
-        const alexaValue = property.alexaDirectiveValue(event);
-
-        // convert alexa value to iobroker value
-        let value = property.value(alexaValue);
-
-        // if set, the device could support toggle
-        if (event.currentState) {
-            // console.error(`----------------------------------- command: ${value}, current value: ${JSON.stringify(event.currentState)}`);
-            const state = event.currentState.find(item => item.name === property.propertyName);
-            if (state && value === true) {
-                // it could support toggle.
-                // get current value
-                let current = property.value(state.value);
-                if (current === true) {
-                    // turn off
-                    value = false;
-                } else if (current !== false) {
-                    const currentValue = await this.getOrRetrieveCurrentValue(property);
-                    if (currentValue === true) {
-                        // turn off
-                        value = false;
-                    }
-                }
-            }
-        }
-
-        // set iobroker state
-        await this.setState(property, value);
-
-        property.currentValue = value;
-        // return value as expected by Alexa
-        return property.alexaValue(value);
-    }
-
-    async adjustValue(event, property) {
-        // extract Alexa delta value from event
-        const delta = property.alexaDirectiveValue(event);
-        // get current value
-        const currentValue = await this.getOrRetrieveCurrentValue(property);
-        // convert the current value to Alexa value
-        const valueToAdjust = property.alexaValue(currentValue);
-        // adjust Alexa value
-        const adjustedValue = Utils.ensureValueInRange_0_100(valueToAdjust + delta);
-        // convert adjusted value to iobroker value
-        const value = property.value(adjustedValue);
-
-        // set iobroker state
-        await this.setState(property, value);
-
-        return adjustedValue;
-    }
-
-    /**
-     * @param {Object} property
-     */
-    async getOrRetrieveCurrentValue(property) {
-        if (property.currentValue === undefined) {
-            property.currentValue = await AdapterProvider.getState(property.getId);
-        }
-
-        if (property.currentValue === undefined) {
-            throw new Error(`unable to retrieve ${property.getId}`);
-        }
-
-        return property.currentValue;
-    }
-
-    async reportState() {
-        this.log.debug(`reporting state`);
-
-        let propertiesToReport = [];
-
-        for (const capability of this.supported) {
-            for (const property of capability.properties) {
-                try {
-                    await this.getOrRetrieveCurrentValue(property);
-
-                    let toReport = {
-                        namespace: capability.namespace,
-                        instance: property.instance,
-                        name: property.propertyName,
-                        value: property.reportValue(property.alexaValue(property.currentValue)),
-                    };
-
-                    if (!toReport.instance) {
-                        delete toReport.instance;
-                    }
-
-                    propertiesToReport.push(toReport);
-                } catch (error) {
-                    this.log.error(`failed reporting state for property ${property.propertyName} of ${this.name}`);
-                    this.log.debug(`${error}`);
-                }
-            }
-        }
-
-        this.log.debug(`${JSON.stringify(propertiesToReport)}`);
-        return propertiesToReport;
-    }
-
-    toString() {
-        return `${this.constructor.name}`;
-    }
-
-    initStates(ctrl) {
-        this._states = {};
-        for (const stateKey of this.stateKeys) {
-            this._states[stateKey] = ctrl.states.find(s => s.name === stateKey);
-        }
-    }
-
-    get states() {
-        return this._states;
-    }
-
-    get statesMap() {
-        const map = {}
-        for (const stateKey of this.stateKeys) {
-            map[stateKey.toLowerCase()] = stateKey;
-        }
-        return map;
-    }
-
-    async setState(property, value) {
-        await AdapterProvider.setState(property.setId, value);
-        property.currentValue = value;
-    }
-
-
-    //-------------------------------------------------------
-    // standard property init objects
-    //
-
-    blankInitObject() {
-        // const states = this.initStates(ctrl);
-        const map = this.statesMap;
-        return {
-            setState: this.states[map.actual],
-            getState: this.states[map.actual],
-        };
-    }
-
-    powerStateInitObject() {
-        // const states = this.initStates(ctrl);
-        const map = this.statesMap;
-
-        return {
-            setState: this.states[map.set],
-            getState: this.states[map.actual],
-            alexaSetter: function (alexaValue) {
-                return alexaValue === Properties.PowerState.ON;
-            },
-            alexaGetter: function (value) {
-                return value ? Properties.PowerState.ON : Properties.PowerState.OFF;
-            },
-        };
-    }
-
-    detectedStateInitObject() {
-        const map = this.statesMap;
-        return {
-            setState: this.states[map.actual],
-            getState: this.states[map.actual],
-            alexaSetter: function (alexaValue) {
-                // should be never called
-                return 0;
-            },
-            alexaGetter: function (value) {
-                return value ? Properties.DetectionState.DETECTED : Properties.DetectionState.NOT_DETECTED;
-            },
-        };
-    }
-
-    percentageInitObject() {
-        const map = this.statesMap;
-        // const range = Utils.configuredRangeOrDefault(this.states[map.set]);
-        return {
-            setState: this.states[map.set],
-            getState: this.states[map.actual],
-            alexaSetter: function (alexaValue) {
-                return Utils.denormalize_0_100(alexaValue, this.valuesRangeMin, this.valuesRangeMax);
-            },
-            alexaGetter: function (value) {
-                return Utils.normalize_0_100(value, this.valuesRangeMin, this.valuesRangeMax);
-            },
-        };
-    }
-}
-
-module.exports = Control;

package/lib/AlexaSmartHomeV3/Controls/Ct.js

@@ -1,172 +0,0 @@
-const Capabilities = require('../Alexa/Capabilities');
-const Utils = require('../Helpers/Utils');
-const Properties = require('../Alexa/Properties');
-const AdapterProvider = require('../Helpers/AdapterProvider');
-const AdjustableControl = require('./AdjustableControl');
-
-/**
- * @class
- */
-class Ct extends AdjustableControl {
-    get categories() {
-        return ['LIGHT'];
-    }
-
-    adjustableProperties() {
-        return [Properties.ColorTemperatureInKelvin];
-    }
-
-    initCapabilities() {
-        const map = this.statesMap;
-        const result = [new Capabilities.ColorController()];
-
-        // if the state DIMMER or BRIGHTNESS configured
-        if (this.states[map.dimmer] || this.states[map.brightness]) {
-            this._brightnessCapability = new Capabilities.BrightnessController();
-            this._brightness = this._brightnessCapability.brightness;
-            result.push(this._brightnessCapability);
-        }
-
-        // if the state TEMPERATURE configured
-        if (this.states[map.temperature]) {
-            this._colorTemperatureCapability = new Capabilities.ColorTemperatureController();
-            result.push(this._colorTemperatureCapability);
-        }
-
-        // if the state ON, DIMMER or BRIGHTNESS configured
-        if (this.states[map.on] || this._brightness) {
-            this._powerControllerCapability = new Capabilities.PowerController();
-            this._powerState = this._powerControllerCapability.powerState;
-            result.push(this._powerControllerCapability);
-        }
-
-        for (const property of result.flatMap(item => item.properties)) {
-            property.init(this.composeInitObject(property))
-        }
-
-        return result;
-    }
-
-    async getOrRetrieveCurrentValue(property) {
-        const map = this.statesMap;
-
-        if (property.currentValue === undefined) {
-            property.currentValue = await AdapterProvider.getState(property.getId);
-            // convert the non-zero brightness to power = true
-            if (property.propertyName === Properties.PowerState.propertyName && !this.states[map.on]) {
-                property.currentValue = property.currentValue !== 0;
-            }
-        }
-
-        if (property.currentValue === undefined) {
-            throw new Error(`unable to retrieve ${property.getId}`);
-        }
-
-        return property.currentValue;
-    }
-
-    async setState(property, value) {
-        const map = this.statesMap;
-
-        if (property.propertyName === Properties.PowerState.propertyName) {
-            if (this.states[map.on]) {
-                await AdapterProvider.setState(property.setId, value);
-                property.currentValue = value;
-            } else {
-                if (value) { // set brightness
-                    // set byOn to the configured value or range.max otherwise
-                    const range = Utils.configuredRangeOrDefault(this.states[map.dimmer] || this.states[map.brightness]);
-                    let byOn = (this.states[map.dimmer] || this.states[map.brightness])?.smartName?.byON;
-                    byOn = isNaN(byOn) ? range.max : parseInt(byOn);
-                    await AdapterProvider.setState(this._brightness.setId, byOn);
-                    this._brightness.currentValue = byOn;
-                    this._powerState.currentValue = true;
-                } else { // set brightness to 0 on power OFF
-                    await AdapterProvider.setState(this._brightness.setId, 0);
-                    this._brightness.currentValue = 0;
-                    this._powerState.currentValue = false;
-                }
-            }
-        } else
-        if (property.propertyName === Properties.Brightness.propertyName
-            || property.propertyName === Properties.ColorTemperatureInKelvin.propertyName) {
-            await AdapterProvider.setState(property.setId, value);
-            property.currentValue = value;
-        } else
-        if (property.propertyName === Properties.ColorTemperatureInKelvin.propertyName) {
-            await AdapterProvider.setState(property.setId, value);
-            property.currentValue = value;
-        }
-    }
-
-    async adjustValue(event, property) {
-        // extract Alexa delta value from event
-        const delta = property.alexaDirectiveValue(event);
-        
-        // convert delta to iobroker value
-        const value = property.value(delta);
-
-        // set iobroker state
-        await this.setState(property, value);
-
-        return value;
-    }
-
-    composeInitObject(property) {
-        const map = this.statesMap;
-
-        if (property.propertyName === Properties.PowerState.propertyName) {
-            return {
-                setState: this.states[map.on] || this.states[map.dimmer] || this.states[map.brightness],
-                getState: this.states[map.on] || this.states[map.dimmer] || this.states[map.brightness],
-                alexaSetter: function (alexaValue) {
-                    return alexaValue === Properties.PowerState.ON;
-                },
-                alexaGetter: function (value) {
-                    return value ? Properties.PowerState.ON : Properties.PowerState.OFF;
-                },
-            };
-        }
-
-        if (property.propertyName === Properties.Brightness.propertyName) {
-            return {
-                setState: this.states[map.dimmer] || this.states[map.brightness],
-                getState: this.states[map.dimmer] || this.states[map.brightness],
-                alexaSetter: function (alexaValue) {
-                    return Utils.denormalize_0_100(alexaValue, this.valuesRangeMin, this.valuesRangeMax);
-                },
-                alexaGetter: function (value) {
-                    return Utils.normalize_0_100(value, this.valuesRangeMin, this.valuesRangeMax);
-                },
-            };
-        }
-
-        if (property.propertyName === Properties.ColorTemperatureInKelvin.propertyName) {
-            return {
-                setState: this.states[map.temperature],
-                getState: this.states[map.temperature],
-                alexaSetter: function (alexaValue) {
-                    if (alexaValue === 1) { // increase directive
-                        const closest = Utils.closestFromList(this.currentValue || this.colorTemperatureTable[0], this.colorTemperatureTable);
-                        let index = this.colorTemperatureTable.indexOf(closest) + 1;
-                        index = index >= this.colorTemperatureTable.length ? this.colorTemperatureTable.length - 1 : index;
-                        return this.colorTemperatureTable[index];
-                    }
-                    if (alexaValue === -1) { // decrease directive
-                        const closest = Utils.closestFromList(this.currentValue || this.colorTemperatureTable[0], this.colorTemperatureTable);
-                        let index = this.colorTemperatureTable.indexOf(closest) - 1;
-                        index = index < 0 ? 0 : index;
-                        return this.colorTemperatureTable[index];
-                    }
-                    
-                    return alexaValue;
-                },
-                alexaGetter: function (value) {
-                    return value;
-                },
-            };
-        }
-    }
-}
-
-module.exports = Ct;

package/lib/AlexaSmartHomeV3/Controls/Dimmer.js

@@ -1,124 +0,0 @@
-const Capabilities = require('../Alexa/Capabilities');
-const AdjustableControl = require('./AdjustableControl');
-const Utils = require('../Helpers/Utils');
-const Properties = require('../Alexa/Properties');
-const AdapterProvider = require('../Helpers/AdapterProvider');
-
-/**
- * @class
- */
-class Dimmer extends AdjustableControl {
-    get categories() {
-        return ['LIGHT'];
-    }
-
-    adjustableProperties() {
-        return [Properties.Brightness];
-    }
-
-    initCapabilities() {
-        this._powerControllerCapability = new Capabilities.PowerController();
-        this._powerState = this._powerControllerCapability.powerState;
-
-        this._brightnessCapability = new Capabilities.BrightnessController();
-        this._brightness = this._brightnessCapability.brightness;
-
-        let result = [this._powerControllerCapability, this._brightnessCapability];
-        for (const property of result.flatMap(item => item.properties)) {
-            property.init(this.composeInitObject(property))
-        }
-
-        return result;
-    }
-
-    async setState(property, value) {
-        // set the property itself
-        await AdapterProvider.setState(property.setId, value);
-        property.currentValue = value;
-        const valuesRange = Utils.configuredRangeOrDefault(this.states[this.statesMap.set]);
-
-        // todo: use adapter.config.deviceOffLevel
-        // If
-
-        if (property.propertyName === Properties.PowerState.propertyName) {
-            // set brightness
-            if (value) {
-                // set byOn to the configured value or 100 otherwise
-                let byOn = this.states[this.statesMap.set].smartName?.byON;
-                byOn = isNaN(byOn) ? valuesRange.max : parseInt(byOn);
-                await AdapterProvider.setState(this._brightness.setId, byOn);
-                this._brightness.currentValue = byOn;
-            } else { // set brightness to 0 on power OFF
-                await AdapterProvider.setState(this._brightness.setId, valuesRange.min);
-                this._brightness.currentValue = valuesRange.min;
-            }
-        } else {
-            // set power
-            const powerValue = value !== valuesRange.min;
-
-            // only do this on different IDs for brightness and power
-            if (this._brightness.setId !== this._powerState.setId) {
-                await AdapterProvider.setState(this._powerState.setId, powerValue);
-            }
-            this._powerState.currentValue = powerValue;
-        }
-    }
-
-    async getOrRetrieveCurrentValue(property) {
-        if (property.currentValue === undefined) {
-            property.currentValue = await AdapterProvider.getState(property.getId);
-
-            const valuesRange = Utils.configuredRangeOrDefault(this.states[this.statesMap.set]);
-            // convert non-zero brightness to power = true
-            if (property.propertyName === this._powerState.propertyName && property.getId === this._brightness.getId) {
-                property.currentValue = property.currentValue !== valuesRange.min;
-            }
-        }
-
-        if (property.currentValue === undefined) {
-            throw new Error(`unable to retrieve ${property.getId}`);
-        }
-
-        return property.currentValue;
-    }
-
-    composeInitObject(property) {
-        /*
-            Device of type 'dimmer' can be switched 'ON'/'OFF' and its brightness can be set to a value between 0 and 100.
-
-            If there is no 'ON_SET' state available:
-            - switching control 'OFF' is done via setting its brightness to 0
-            - switching control 'ON' is done via setting its brightness to the configured 'byOn' value or to the last known brightness.
-        */
-
-        const map = this.statesMap;
-
-        if (property.propertyName === Properties.PowerState.propertyName) {
-            return {
-                setState: this.states[map.on_set] || this.states[map.set],
-                getState: this.states[map.on_actual] || this.states[map.on_set] || this.states[map.set],
-                alexaSetter: function (alexaValue) {
-                    return alexaValue === Properties.PowerState.ON;
-                },
-                alexaGetter: function (value) {
-                    return value ? Properties.PowerState.ON : Properties.PowerState.OFF;
-                },
-            }
-        }
-
-        if (property.propertyName === Properties.Brightness.propertyName) {
-            return {
-                setState: this.states[map.set],
-                getState: this.states[map.actual],
-                alexaSetter: function (alexaValue) {
-                    return Utils.denormalize_0_100(alexaValue, this.valuesRangeMin, this.valuesRangeMax);
-                },
-                alexaGetter: function (value) {
-                    return Utils.normalize_0_100(value, this.valuesRangeMin, this.valuesRangeMax);
-                },
-            };
-        }
-    }
-}
-
-module.exports = Dimmer;

package/lib/AlexaSmartHomeV3/Controls/Door.js

@@ -1,9 +0,0 @@
-const ContactSensor = require('./ContactSensor');
-
-/**
- * @class
- */
-class Door extends ContactSensor {
-}
-
-module.exports = Door;