homebridge-virtual-accessories/dist/configuration/accessories/configurationHeaterCooler.js

Virtual HomeKit accessories for Homebridge.

/* eslint-disable brace-style */
/* eslint-disable curly */
import { HeaterType, TemperatureUnit, ThresholdTemperature } from '../schema.js';
import { Utils } from '../../utils/utils.js';
/**
 *
 */
export class HeaterCoolerConfiguration {
    type;
    temperatureDisplayUnits;
    heatingThresholdCelsius;
    coolingThresholdCelsius;
    heatingThresholdFahrenheit;
    coolingThresholdFahrenheit;
    errorFields = [];
    fieldNames = Utils.proxiedPropertiesOf(this);
    isValid(prefix) {
        const isValidType = (Utils.required(this.type) &&
            HeaterType.Types.includes(this.type));
        const isValidTemperatureDisplayUnits = (Utils.required(this.temperatureDisplayUnits) &&
            TemperatureUnit.Units.includes(this.temperatureDisplayUnits));
        const heatingThreshold = this.getHeatingThreshold();
        const coolingThreshold = this.getCoolingThreshold();
        const isValidHeatingThreshold = (this.isValidHeatingThreshold());
        const isValidCoolingThreshold = (this.isValidCoolingThreshold());
        const isValidThresholdWindow = ((heatingThreshold !== undefined) && (coolingThreshold !== undefined) ?
            (coolingThreshold > heatingThreshold) :
            true);
        // Store fields failing validation
        const heatingThresholdField = '.heatingThreshold' + this.capitalize(this.temperatureDisplayUnits);
        const coolingThresholdField = '.coolingThreshold' + this.capitalize(this.temperatureDisplayUnits);
        if (!isValidType)
            this.errorFields.push(prefix + '.type');
        if (!isValidTemperatureDisplayUnits)
            this.errorFields.push(prefix + '.' + this.fieldNames.temperatureDisplayUnits);
        if (!isValidHeatingThreshold)
            this.errorFields.push(prefix + heatingThresholdField);
        if (!isValidCoolingThreshold)
            this.errorFields.push(prefix + coolingThresholdField);
        if (!isValidThresholdWindow)
            this.errorFields.push(prefix + heatingThresholdField + ' <= ' + prefix + coolingThresholdField);
        return [
            (isValidType &&
                isValidTemperatureDisplayUnits &&
                isValidHeatingThreshold &&
                isValidCoolingThreshold &&
                isValidThresholdWindow),
            this.errorFields,
        ];
    }
    getHeatingThreshold() {
        let heatingThreshold = undefined;
        if (this.temperatureDisplayUnits === TemperatureUnit.Celsius) {
            heatingThreshold = this.heatingThresholdCelsius;
        }
        else if (this.temperatureDisplayUnits === TemperatureUnit.Fahrenheit) {
            heatingThreshold = this.heatingThresholdFahrenheit;
        }
        return heatingThreshold;
    }
    getCoolingThreshold() {
        let coolingThreshold = undefined;
        if (this.temperatureDisplayUnits === TemperatureUnit.Celsius) {
            coolingThreshold = this.coolingThresholdCelsius;
        }
        else if (this.temperatureDisplayUnits === TemperatureUnit.Fahrenheit) {
            coolingThreshold = this.coolingThresholdFahrenheit;
        }
        return coolingThreshold;
    }
    isValidHeatingThreshold() {
        let isValidHeatingThreshold = false;
        // If it's a cooler onlu, then no heating threshold is valid
        if (this.type === HeaterType.Cooler) {
            isValidHeatingThreshold = true;
        }
        else if (this.temperatureDisplayUnits === TemperatureUnit.Celsius) {
            isValidHeatingThreshold =
                Utils.required(this.heatingThresholdCelsius) &&
                    (this.heatingThresholdCelsius >= ThresholdTemperature.HeatingThresholdCelsiusMin &&
                        this.heatingThresholdCelsius <= ThresholdTemperature.HeatingThresholdCelsiusMax);
        }
        else if (this.temperatureDisplayUnits === TemperatureUnit.Fahrenheit) {
            isValidHeatingThreshold =
                Utils.required(this.heatingThresholdFahrenheit) &&
                    (this.heatingThresholdFahrenheit >= ThresholdTemperature.HeatingThresholdFahrenheitMin &&
                        this.heatingThresholdFahrenheit <= ThresholdTemperature.HeatingThresholdFahrenheitMax);
        }
        return isValidHeatingThreshold;
    }
    isValidCoolingThreshold() {
        let isValidCoolingThreshold = false;
        // If it's a heater onlu, then no cooling threshold is valid
        if (this.type === HeaterType.Heater) {
            isValidCoolingThreshold = true;
        }
        else if (this.temperatureDisplayUnits === TemperatureUnit.Celsius) {
            isValidCoolingThreshold =
                Utils.required(this.coolingThresholdCelsius) &&
                    (this.coolingThresholdCelsius >= ThresholdTemperature.CoolingThresholdCelsiusMin &&
                        this.coolingThresholdCelsius <= ThresholdTemperature.CoolingThresholdCelsiusMax);
        }
        else if (this.temperatureDisplayUnits === TemperatureUnit.Fahrenheit) {
            isValidCoolingThreshold =
                Utils.required(this.coolingThresholdFahrenheit) &&
                    (this.coolingThresholdFahrenheit >= ThresholdTemperature.CoolingThresholdFahrenheitMin &&
                        this.coolingThresholdFahrenheit <= ThresholdTemperature.CoolingThresholdFahrenheitMax);
        }
        return isValidCoolingThreshold;
    }
    capitalize(value) {
        return String(value).charAt(0).toUpperCase() + String(value).slice(1);
    }
}
//# sourceMappingURL=configurationHeaterCooler.js.map