@fastybird/smart-panel-backend 0.1.0-alpha.5

package/dist/plugins/devices-shelly-ng/delegates/delegates-manager.service.js

@@ -0,0 +1,1117 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatesManagerService = void 0;
+const class_transformer_1 = require("class-transformer");
+const common_1 = require("@nestjs/common");
+const logger_1 = require("../../../common/logger");
+const transform_utils_1 = require("../../../common/utils/transform.utils");
+const devices_constants_1 = require("../../../modules/devices/devices.constants");
+const channels_properties_service_1 = require("../../../modules/devices/services/channels.properties.service");
+const channels_service_1 = require("../../../modules/devices/services/channels.service");
+const device_connectivity_service_1 = require("../../../modules/devices/services/device-connectivity.service");
+const devices_service_1 = require("../../../modules/devices/services/devices.service");
+const devices_shelly_ng_constants_1 = require("../devices-shelly-ng.constants");
+const devices_shelly_ng_exceptions_1 = require("../devices-shelly-ng.exceptions");
+const update_channel_property_dto_1 = require("../dto/update-channel-property.dto");
+const mappings_1 = require("../mappings");
+const transformers_1 = require("../mappings/transformers/transformers");
+const device_manager_service_1 = require("../services/device-manager.service");
+const transform_utils_2 = require("../utils/transform.utils");
+const shelly_device_delegate_1 = require("./shelly-device.delegate");
+let DelegatesManagerService = class DelegatesManagerService {
+    constructor(devicesService, channelsService, channelsPropertiesService, deviceConnectivityService, deviceManagerService, propertyMappingStorage, transformerRegistry) {
+        this.devicesService = devicesService;
+        this.channelsService = channelsService;
+        this.channelsPropertiesService = channelsPropertiesService;
+        this.deviceConnectivityService = deviceConnectivityService;
+        this.deviceManagerService = deviceManagerService;
+        this.propertyMappingStorage = propertyMappingStorage;
+        this.transformerRegistry = transformerRegistry;
+        this.logger = (0, logger_1.createExtensionLogger)(devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_PLUGIN_NAME, 'DelegatesManagerService');
+        this.delegates = new Map();
+        this.delegateValueHandlers = new Map();
+        this.delegateConnectionHandlers = new Map();
+        this.changeHandlers = new Map();
+        this.setChannelsHandlers = new Map();
+        this.setPropertiesHandlers = new Map();
+        this.pendingWrites = new Map();
+        this.propertiesMap = new Map();
+        this.delegateDeviceIds = new Map();
+        this.insertGeneration = new Map();
+        this.deviceLocks = new Map();
+    }
+    get(id) {
+        return this.delegates.get(id);
+    }
+    async insert(shelly, force = false) {
+        return this.withDeviceLock(shelly.id, () => this.performInsert(shelly, force));
+    }
+    async performInsert(shelly, force = false) {
+        if (this.delegates.has(shelly.id)) {
+            if (force) {
+                this.performRemove(shelly.id);
+            }
+            else {
+                return this.delegates.get(shelly.id);
+            }
+        }
+        const generation = (this.insertGeneration.get(shelly.id) ?? 0) + 1;
+        this.insertGeneration.set(shelly.id, generation);
+        const delegate = new shelly_device_delegate_1.ShellyDeviceDelegate(shelly);
+        this.delegates.set(shelly.id, delegate);
+        const hostname = shelly.wifi?.sta_ip ?? shelly.ethernet?.ip ?? null;
+        if (hostname === null) {
+            throw new devices_shelly_ng_exceptions_1.DevicesShellyNgException('Missing device hostname or IP address');
+        }
+        let device = await this.devicesService.findOneBy('identifier', shelly.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+        let isNewDevice = false;
+        if (device === null) {
+            try {
+                device = await this.devicesService.create({
+                    type: devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE,
+                    category: this.determineCategory(delegate),
+                    identifier: shelly.id,
+                    hostname,
+                    name: shelly.system.config.device.name ?? shelly.modelName,
+                });
+                isNewDevice = true;
+            }
+            catch (error) {
+                device = await this.devicesService.findOneBy('identifier', shelly.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+                if (device === null) {
+                    throw error;
+                }
+            }
+        }
+        this.delegateDeviceIds.set(delegate.id, device.id);
+        if (isNewDevice) {
+            await this.deviceManagerService.createOrUpdate(device.id);
+            device = await this.devicesService.findOneBy('identifier', shelly.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (device === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgException('Device not found after provisioning');
+            }
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation) {
+            this.logger.warn(`Insert for device=${shelly.id} cancelled (device removed or re-inserted)`);
+            return delegate;
+        }
+        const deviceInformation = await this.channelsService.findOneBy('category', devices_constants_1.ChannelCategory.DEVICE_INFORMATION, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+        if (deviceInformation === null) {
+        }
+        else {
+            const statusProperty = await this.channelsPropertiesService.findOneBy('category', devices_constants_1.PropertyCategory.STATUS, deviceInformation.id);
+            if (statusProperty === null) {
+            }
+            const linkQuality = await this.channelsPropertiesService.findOneBy('category', devices_constants_1.PropertyCategory.LINK_QUALITY, deviceInformation.id);
+            if (linkQuality !== null) {
+                if (devices_shelly_ng_constants_1.ComponentType.WIFI in shelly) {
+                    const comp = shelly.wifi;
+                    await this.setDefaultPropertyValue(device.id, linkQuality, (0, transform_utils_1.clampNumber)((0, transform_utils_2.rssiToQuality)(comp.rssi), 0, 100));
+                }
+                this.changeHandlers.set(`${delegate.id}|${deviceInformation.identifier}|rssi`, (val) => {
+                    const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                    if (n === null || Number.isNaN(n)) {
+                        this.logger.warn(`Dropping invalid numeric update for link quality -> ${(0, transform_utils_1.safeToString)(val)} (property=${linkQuality.id})`);
+                        return;
+                    }
+                    this.handleChange(linkQuality, (0, transform_utils_1.clampNumber)((0, transform_utils_2.rssiToQuality)(n), 0, 100)).catch((err) => {
+                        this.logger.error(`Failed to set value for component=${deviceInformation.identifier} attribute=rssi and property=${linkQuality.id}`, {
+                            resource: device.id,
+                            message: err.message,
+                            stack: err.stack,
+                        });
+                    });
+                });
+            }
+            else {
+            }
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.switches.values()) {
+            const switcher = await this.channelsService.findOneBy('identifier', `switch:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (switcher === null) {
+                continue;
+            }
+            let switcherOn = await this.channelsPropertiesService.findOneBy('identifier', 'output', switcher.id);
+            if (switcherOn === null) {
+                const switcherOnAlt = await this.channelsPropertiesService.findOneBy('identifier', 'on', switcher.id);
+                if (switcherOnAlt === null) {
+                    continue;
+                }
+                switcherOn = switcherOnAlt;
+            }
+            await this.setDefaultPropertyValue(device.id, switcherOn, comp.output);
+            this.changeHandlers.set(`${delegate.id}|${comp.key}|output`, (val) => {
+                this.handleChange(switcherOn, (0, transform_utils_1.coerceBooleanSafe)(val)).catch((err) => {
+                    this.logger.error(`Failed to set value for component=${comp.key} attribute=output and property=${switcherOn.id}`, {
+                        resource: device.id,
+                        message: err.message,
+                        stack: err.stack,
+                    });
+                });
+            });
+            this.setPropertiesHandlers.set(`${delegate.id}|${switcherOn.id}`, async (val) => {
+                if (typeof val !== 'boolean') {
+                    return false;
+                }
+                await comp.set(val);
+                return true;
+            });
+            if (typeof comp.aenergy !== 'undefined') {
+                const electricalEnergy = await this.channelsService.findOneBy('identifier', `energy:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+                if (electricalEnergy === null) {
+                }
+                else {
+                    const consumption = await this.channelsPropertiesService.findOneBy('identifier', 'aenergy', electricalEnergy.id);
+                    if (consumption === null) {
+                    }
+                    else {
+                        await this.setDefaultPropertyValue(device.id, consumption, (0, transform_utils_2.toEnergy)(comp.aenergy));
+                        this.changeHandlers.set(`${delegate.id}|${comp.key}|aenergy`, (val) => {
+                            this.handleNumericChange(comp.key, 'aenergy', consumption.id, val, (n) => this.handleChange(consumption, (0, transform_utils_2.toEnergy)(n), false));
+                        });
+                    }
+                }
+            }
+            if (typeof comp.apower !== 'undefined') {
+                const electricalPower = await this.channelsService.findOneBy('identifier', `power:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+                if (electricalPower === null) {
+                }
+                else {
+                    const power = await this.channelsPropertiesService.findOneBy('identifier', 'apower', electricalPower.id);
+                    if (power === null) {
+                    }
+                    else {
+                        await this.setDefaultPropertyValue(device.id, power, Math.max(0, comp.apower));
+                        this.changeHandlers.set(`${delegate.id}|${comp.key}|apower`, (val) => {
+                            this.handleNumericChange(comp.key, 'apower', power.id, val, (n) => this.handleChange(power, Math.max(0, n), false));
+                        });
+                        if (typeof comp.voltage !== 'undefined') {
+                            const voltage = await this.channelsPropertiesService.findOneBy('identifier', 'voltage', electricalPower.id);
+                            if (voltage === null) {
+                            }
+                            else {
+                                await this.setDefaultPropertyValue(device.id, voltage, comp.voltage);
+                                this.changeHandlers.set(`${delegate.id}|${comp.key}|voltage`, (val) => {
+                                    this.handleNumericChange(comp.key, 'voltage', voltage.id, val, (n) => this.handleChange(voltage, n, false));
+                                });
+                            }
+                        }
+                        if (typeof comp.current !== 'undefined') {
+                            const current = await this.channelsPropertiesService.findOneBy('identifier', 'current', electricalPower.id);
+                            if (current === null) {
+                            }
+                            else {
+                                await this.setDefaultPropertyValue(device.id, current, comp.current);
+                                this.changeHandlers.set(`${delegate.id}|${comp.key}|current`, (val) => {
+                                    this.handleNumericChange(comp.key, 'current', current.id, val, (n) => this.handleChange(current, n, false));
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.covers.values()) {
+            const cover = await this.channelsService.findOneBy('identifier', `cover:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (cover === null) {
+                continue;
+            }
+            const coverState = await this.channelsPropertiesService.findOneBy('identifier', 'state', cover.id);
+            if (coverState === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load cover state channel property');
+            }
+            await this.setDefaultPropertyValue(device.id, coverState, comp.state);
+            this.changeHandlers.set(`${delegate.id}|${comp.key}|state`, (val) => {
+                if (typeof val !== 'string') {
+                    return;
+                }
+                if (val === 'calibrating')
+                    return;
+                this.handleChange(coverState, val).catch((err) => {
+                    this.logger.error(`Failed to set value for component=${comp.key} attribute=state and property=${coverState.id}`, {
+                        resource: device.id,
+                        message: err.message,
+                        stack: err.stack,
+                    });
+                });
+            });
+            const coverPosition = await this.channelsPropertiesService.findOneBy('identifier', 'current_pos', cover.id);
+            if (coverPosition === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load cover position channel property');
+            }
+            await this.setDefaultPropertyValue(device.id, coverPosition, (0, transform_utils_1.clampNumber)(comp.current_pos, 0, 100));
+            this.changeHandlers.set(`${delegate.id}|${comp.key}|current_pos`, (val) => {
+                this.handleNumericChange(comp.key, 'current_pos', coverPosition.id, val, (n) => this.handleChange(coverPosition, n, false), { clamp: { min: 0, max: 100 } });
+            });
+            this.setPropertiesHandlers.set(`${delegate.id}|${coverPosition.id}`, async (val) => {
+                const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                if (n === null || Number.isNaN(n)) {
+                    this.logger.warn(`Dropping invalid numeric update for ${comp.key}.current_pos -> ${String(val)} (property=${coverPosition.id})`);
+                    return;
+                }
+                await comp.goToPosition(Math.round((0, transform_utils_1.clampNumber)(n, 0, 100)));
+                return true;
+            });
+            const coverCommand = await this.channelsPropertiesService.findOneBy('category', devices_constants_1.PropertyCategory.COMMAND, cover.id);
+            if (coverCommand === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load cover command channel property');
+            }
+            await this.setDefaultPropertyValue(device.id, coverCommand, 'stop');
+            this.setPropertiesHandlers.set(`${delegate.id}|${coverCommand.id}`, async (val) => {
+                if (typeof val !== 'string') {
+                    return false;
+                }
+                if (val === 'open')
+                    await comp.open();
+                if (val === 'close')
+                    await comp.close();
+                if (val === 'stop')
+                    await comp.stop();
+                return true;
+            });
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.lights.values()) {
+            const light = await this.channelsService.findOneBy('identifier', `light:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (light === null) {
+                continue;
+            }
+            const lightOn = await this.channelsPropertiesService.findOneBy('identifier', 'output', light.id);
+            if (lightOn === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load light on channel property');
+            }
+            await this.setDefaultPropertyValue(device.id, lightOn, comp.output);
+            this.changeHandlers.set(`${delegate.id}|${comp.key}|output`, (val) => {
+                this.handleChange(lightOn, (0, transform_utils_1.coerceBooleanSafe)(val)).catch((err) => {
+                    this.logger.error(`Failed to set value for component=${comp.key} attribute=output and property=${lightOn.id}`, {
+                        resource: device.id,
+                        message: err.message,
+                        stack: err.stack,
+                    });
+                });
+            });
+            this.setPropertiesHandlers.set(`${delegate.id}|${lightOn.id}`, async (val) => {
+                if (typeof val !== 'boolean') {
+                    return false;
+                }
+                await comp.set(val);
+                return true;
+            });
+            if (typeof comp.brightness !== 'undefined') {
+                const brightness = await this.channelsPropertiesService.findOneBy('identifier', 'brightness', light.id);
+                if (brightness === null) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load light brightness channel property');
+                }
+                await this.setDefaultPropertyValue(device.id, brightness, (0, transform_utils_1.clampNumber)(comp.brightness, 0, 100));
+                this.changeHandlers.set(`${delegate.id}|${comp.key}|brightness`, (val) => {
+                    this.handleNumericChange(comp.key, 'brightness', brightness.id, val, (n) => this.handleChange(brightness, n, false), { clamp: { min: 0, max: 100 } });
+                });
+                this.setPropertiesHandlers.set(`${delegate.id}|${brightness.id}`, async (val) => {
+                    const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                    if (n === null || Number.isNaN(n)) {
+                        this.logger.warn(`Dropping invalid numeric update for ${comp.key}.brightness -> ${String(val)} (property=${brightness.id})`);
+                        return;
+                    }
+                    await comp.set(true, Math.round((0, transform_utils_1.clampNumber)(n, 0, 100)));
+                    return true;
+                });
+            }
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.rgb.values()) {
+            const rgb = await this.channelsService.findOneBy('identifier', `rgb:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (rgb === null) {
+                continue;
+            }
+            const rgbOn = await this.channelsPropertiesService.findOneBy('identifier', 'output', rgb.id);
+            if (rgbOn === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load rgb on channel property');
+            }
+            await this.setDefaultPropertyValue(device.id, rgbOn, comp.output);
+            this.changeHandlers.set(`${delegate.id}|${comp.key}|output`, (val) => {
+                this.handleChange(rgbOn, (0, transform_utils_1.coerceBooleanSafe)(val)).catch((err) => {
+                    this.logger.error(`Failed to set value for component=${comp.key} attribute=output and property=${rgbOn.id}`, {
+                        resource: device.id,
+                        message: err.message,
+                        stack: err.stack,
+                    });
+                });
+            });
+            this.setPropertiesHandlers.set(`${delegate.id}|${rgbOn.id}`, async (val) => {
+                if (typeof val !== 'boolean') {
+                    return false;
+                }
+                await comp.set(val);
+                return true;
+            });
+            if (typeof comp.brightness !== 'undefined') {
+                const brightness = await this.channelsPropertiesService.findOneBy('identifier', 'brightness', rgb.id);
+                if (brightness === null) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load rgb brightness channel property');
+                }
+                await this.setDefaultPropertyValue(device.id, brightness, (0, transform_utils_1.clampNumber)(comp.brightness, 0, 100));
+                this.changeHandlers.set(`${delegate.id}|${comp.key}|brightness`, (val) => {
+                    this.handleNumericChange(comp.key, 'brightness', brightness.id, val, (n) => this.handleChange(brightness, n, false), { clamp: { min: 0, max: 100 } });
+                });
+                this.setPropertiesHandlers.set(`${delegate.id}|${brightness.id}`, async (val) => {
+                    const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                    if (n === null || Number.isNaN(n)) {
+                        this.logger.warn(`Dropping invalid numeric update for ${comp.key}.brightness -> ${String(val)} (property=${brightness.id})`);
+                        return;
+                    }
+                    await comp.set(true, Math.round((0, transform_utils_1.clampNumber)(n, 0, 100)));
+                    return true;
+                });
+            }
+            if (typeof comp.rgb !== 'undefined') {
+                const colorRed = await this.channelsPropertiesService.findOneBy('identifier', 'rgb:red', rgb.id);
+                const colorGreen = await this.channelsPropertiesService.findOneBy('identifier', 'rgb:green', rgb.id);
+                const colorBlue = await this.channelsPropertiesService.findOneBy('identifier', 'rgb:blue', rgb.id);
+                if (colorRed === null || colorGreen === null || colorBlue === null) {
+                    this.logger.warn(`RGB color properties not found for device=${device.id} rgb=${comp.id}, skipping RGB color handling. Properties may not be created yet.`, { resource: device.id });
+                }
+                else {
+                    await this.setDefaultPropertyValue(device.id, colorRed, (0, transform_utils_1.clampNumber)(comp.rgb[0], 0, 255));
+                    await this.setDefaultPropertyValue(device.id, colorGreen, (0, transform_utils_1.clampNumber)(comp.rgb[1], 0, 255));
+                    await this.setDefaultPropertyValue(device.id, colorBlue, (0, transform_utils_1.clampNumber)(comp.rgb[2], 0, 255));
+                    this.changeHandlers.set(`${delegate.id}|${comp.key}|rgb`, (val) => {
+                        this.handleNumericChange(comp.key, 'rgb:red', colorRed.id, val[0], (n) => this.handleChange(colorRed, n, false), { clamp: { min: 0, max: 255 } });
+                        this.handleNumericChange(comp.key, 'rgb:green', colorGreen.id, val[1], (n) => this.handleChange(colorGreen, n, false), { clamp: { min: 0, max: 255 } });
+                        this.handleNumericChange(comp.key, 'rgb:blue', colorBlue.id, val[2], (n) => this.handleChange(colorBlue, n, false), { clamp: { min: 0, max: 255 } });
+                    });
+                    this.setPropertiesHandlers.set(`${delegate.id}|${colorRed.id}`, async (val) => {
+                        const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                        if (n === null || Number.isNaN(n)) {
+                            this.logger.warn(`Dropping invalid numeric update for ${comp.key}.rgb:red -> ${String(val)} (property=${colorRed.id})`);
+                            return;
+                        }
+                        await comp.set(true, comp.brightness, [Math.round((0, transform_utils_1.clampNumber)(n, 0, 255)), comp.rgb[1], comp.rgb[2]]);
+                        return true;
+                    });
+                    this.setPropertiesHandlers.set(`${delegate.id}|${colorGreen.id}`, async (val) => {
+                        const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                        if (n === null || Number.isNaN(n)) {
+                            this.logger.warn(`Dropping invalid numeric update for ${comp.key}.rgb:green -> ${String(val)} (property=${colorGreen.id})`);
+                            return;
+                        }
+                        await comp.set(true, comp.brightness, [comp.rgb[0], Math.round((0, transform_utils_1.clampNumber)(n, 0, 255)), comp.rgb[2]]);
+                        return true;
+                    });
+                    this.setPropertiesHandlers.set(`${delegate.id}|${colorBlue.id}`, async (val) => {
+                        const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                        if (n === null || Number.isNaN(n)) {
+                            this.logger.warn(`Dropping invalid numeric update for ${comp.key}.rgb:blue -> ${String(val)} (property=${colorBlue.id})`);
+                            return;
+                        }
+                        await comp.set(true, comp.brightness, [comp.rgb[0], comp.rgb[1], Math.round((0, transform_utils_1.clampNumber)(n, 0, 255))]);
+                        return true;
+                    });
+                }
+            }
+            this.setChannelsHandlers.set(`${delegate.id}|${rgb.id}`, async (updates) => {
+                const outputUpdate = updates.find((u) => u.property.identifier === 'output');
+                const brightnessUpdate = updates.find((u) => u.property.identifier === 'brightness');
+                const colorRedUpdate = updates.find((u) => u.property.identifier === 'rgb:red');
+                const colorGreenUpdate = updates.find((u) => u.property.identifier === 'rgb:green');
+                const colorBlueUpdate = updates.find((u) => u.property.identifier === 'rgb:blue');
+                const hasBrightnessOrColorUpdate = brightnessUpdate || colorRedUpdate || colorGreenUpdate || colorBlueUpdate;
+                const outputValue = outputUpdate
+                    ? (0, transform_utils_1.coerceBooleanSafe)(outputUpdate.val)
+                    : hasBrightnessOrColorUpdate
+                        ? true
+                        : (0, transform_utils_1.coerceBooleanSafe)(comp.output);
+                const brightnessValue = brightnessUpdate
+                    ? (0, transform_utils_1.coerceNumberSafe)(brightnessUpdate.val)
+                    : (0, transform_utils_1.coerceNumberSafe)(comp.brightness);
+                const colorRedValue = colorRedUpdate ? (0, transform_utils_1.coerceNumberSafe)(colorRedUpdate.val) : (0, transform_utils_1.coerceNumberSafe)(comp.rgb[0]);
+                const colorGreenValue = colorGreenUpdate
+                    ? (0, transform_utils_1.coerceNumberSafe)(colorGreenUpdate.val)
+                    : (0, transform_utils_1.coerceNumberSafe)(comp.rgb[1]);
+                const colorBlueValue = colorBlueUpdate ? (0, transform_utils_1.coerceNumberSafe)(colorBlueUpdate.val) : (0, transform_utils_1.coerceNumberSafe)(comp.rgb[2]);
+                if (outputValue === null ||
+                    typeof outputValue !== 'boolean' ||
+                    brightnessValue === null ||
+                    Number.isNaN(brightnessValue) ||
+                    colorRedValue === null ||
+                    Number.isNaN(colorRedValue) ||
+                    colorGreenValue === null ||
+                    Number.isNaN(colorGreenValue) ||
+                    colorBlueValue === null ||
+                    Number.isNaN(colorBlueValue)) {
+                    this.logger.warn(`Dropping invalid batch update for ${comp.key} (channel=${rgb.id})`);
+                    return;
+                }
+                await comp.set(outputValue, Math.round((0, transform_utils_1.clampNumber)(brightnessValue, 0, 100)), [
+                    Math.round((0, transform_utils_1.clampNumber)(colorRedValue, 0, 255)),
+                    Math.round((0, transform_utils_1.clampNumber)(colorGreenValue, 0, 255)),
+                    Math.round((0, transform_utils_1.clampNumber)(colorBlueValue, 0, 255)),
+                ]);
+                return true;
+            });
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.rgbw.values()) {
+            const rgbw = await this.channelsService.findOneBy('identifier', `rgbw:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (rgbw === null) {
+                continue;
+            }
+            const rgbwOn = await this.channelsPropertiesService.findOneBy('identifier', 'output', rgbw.id);
+            if (rgbwOn === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load rgbw on channel property');
+            }
+            await this.setDefaultPropertyValue(device.id, rgbwOn, comp.output);
+            this.changeHandlers.set(`${delegate.id}|${comp.key}|output`, (val) => {
+                this.handleChange(rgbwOn, (0, transform_utils_1.coerceBooleanSafe)(val)).catch((err) => {
+                    this.logger.error(`Failed to set value for component=${comp.key} attribute=output and property=${rgbwOn.id}`, {
+                        resource: device.id,
+                        message: err.message,
+                        stack: err.stack,
+                    });
+                });
+            });
+            this.setPropertiesHandlers.set(`${delegate.id}|${rgbwOn.id}`, async (val) => {
+                if (typeof val !== 'boolean') {
+                    return false;
+                }
+                await comp.set(val);
+                return true;
+            });
+            if (typeof comp.brightness !== 'undefined') {
+                const brightness = await this.channelsPropertiesService.findOneBy('identifier', 'brightness', rgbw.id);
+                if (brightness === null) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load rgbw brightness channel property');
+                }
+                await this.setDefaultPropertyValue(device.id, brightness, (0, transform_utils_1.clampNumber)(comp.brightness, 0, 100));
+                this.changeHandlers.set(`${delegate.id}|${comp.key}|brightness`, (val) => {
+                    this.handleNumericChange(comp.key, 'brightness', brightness.id, val, (n) => this.handleChange(brightness, n, false), { clamp: { min: 0, max: 100 } });
+                });
+                this.setPropertiesHandlers.set(`${delegate.id}|${brightness.id}`, async (val) => {
+                    const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                    if (n === null || Number.isNaN(n)) {
+                        this.logger.warn(`Dropping invalid numeric update for ${comp.key}.brightness -> ${String(val)} (property=${brightness.id})`);
+                        return;
+                    }
+                    await comp.set(true, Math.round((0, transform_utils_1.clampNumber)(n, 0, 100)));
+                    return true;
+                });
+            }
+            if (typeof comp.rgb !== 'undefined') {
+                const colorRed = await this.channelsPropertiesService.findOneBy('identifier', 'rgb:red', rgbw.id);
+                const colorGreen = await this.channelsPropertiesService.findOneBy('identifier', 'rgb:green', rgbw.id);
+                const colorBlue = await this.channelsPropertiesService.findOneBy('identifier', 'rgb:blue', rgbw.id);
+                if (colorRed === null || colorGreen === null || colorBlue === null) {
+                    this.logger.warn(`RGB color properties not found for device=${device.id} rgbw=${comp.id}, skipping RGB color handling. Properties may not be created yet or device doesn't support RGB.`, { resource: device.id });
+                }
+                else {
+                    await this.setDefaultPropertyValue(device.id, colorRed, (0, transform_utils_1.clampNumber)(comp.rgb[0], 0, 255));
+                    await this.setDefaultPropertyValue(device.id, colorGreen, (0, transform_utils_1.clampNumber)(comp.rgb[1], 0, 255));
+                    await this.setDefaultPropertyValue(device.id, colorBlue, (0, transform_utils_1.clampNumber)(comp.rgb[2], 0, 255));
+                    this.changeHandlers.set(`${delegate.id}|${comp.key}|rgb`, (val) => {
+                        this.handleNumericChange(comp.key, 'rgb:red', colorRed.id, val[0], (n) => this.handleChange(colorRed, n, false), { clamp: { min: 0, max: 255 } });
+                        this.handleNumericChange(comp.key, 'rgb:green', colorGreen.id, val[1], (n) => this.handleChange(colorGreen, n, false), { clamp: { min: 0, max: 255 } });
+                        this.handleNumericChange(comp.key, 'rgb:blue', colorBlue.id, val[2], (n) => this.handleChange(colorBlue, n, false), { clamp: { min: 0, max: 255 } });
+                    });
+                    this.setPropertiesHandlers.set(`${delegate.id}|${colorRed.id}`, async (val) => {
+                        const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                        if (n === null || Number.isNaN(n)) {
+                            this.logger.warn(`Dropping invalid numeric update for ${comp.key}.rgb:red -> ${String(val)} (property=${colorRed.id})`);
+                            return;
+                        }
+                        await comp.set(true, comp.brightness, [Math.round((0, transform_utils_1.clampNumber)(n, 0, 255)), comp.rgb[1], comp.rgb[2]]);
+                        return true;
+                    });
+                    this.setPropertiesHandlers.set(`${delegate.id}|${colorGreen.id}`, async (val) => {
+                        const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                        if (n === null || Number.isNaN(n)) {
+                            this.logger.warn(`Dropping invalid numeric update for ${comp.key}.rgb:green -> ${String(val)} (property=${colorGreen.id})`);
+                            return;
+                        }
+                        await comp.set(true, comp.brightness, [comp.rgb[0], Math.round((0, transform_utils_1.clampNumber)(n, 0, 255)), comp.rgb[2]]);
+                        return true;
+                    });
+                    this.setPropertiesHandlers.set(`${delegate.id}|${colorBlue.id}`, async (val) => {
+                        const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                        if (n === null || Number.isNaN(n)) {
+                            this.logger.warn(`Dropping invalid numeric update for ${comp.key}.rgb:blue -> ${String(val)} (property=${colorBlue.id})`);
+                            return;
+                        }
+                        await comp.set(true, comp.brightness, [comp.rgb[0], comp.rgb[1], Math.round((0, transform_utils_1.clampNumber)(n, 0, 255))]);
+                        return true;
+                    });
+                }
+            }
+            if (typeof comp.white !== 'undefined') {
+                const white = await this.channelsPropertiesService.findOneBy('identifier', 'white', rgbw.id);
+                if (white === null) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load rgbw white channel property');
+                }
+                await this.setDefaultPropertyValue(device.id, white, (0, transform_utils_1.clampNumber)(comp.white, 0, 255));
+                this.changeHandlers.set(`${delegate.id}|${comp.key}|white`, (val) => {
+                    this.handleNumericChange(comp.key, 'white', white.id, val, (n) => this.handleChange(white, n, false), {
+                        clamp: { min: 0, max: 255 },
+                    });
+                });
+                this.setPropertiesHandlers.set(`${delegate.id}|${white.id}`, async (val) => {
+                    const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                    if (n === null || Number.isNaN(n)) {
+                        this.logger.warn(`Dropping invalid numeric update for ${comp.key}.white -> ${String(val)} (property=${white.id})`);
+                        return;
+                    }
+                    await comp.set(true, Math.round((0, transform_utils_1.clampNumber)(n, 0, 255)));
+                    return true;
+                });
+            }
+            this.setChannelsHandlers.set(`${delegate.id}|${rgbw.id}`, async (updates) => {
+                const outputUpdate = updates.find((u) => u.property.identifier === 'output');
+                const brightnessUpdate = updates.find((u) => u.property.identifier === 'brightness');
+                const colorRedUpdate = updates.find((u) => u.property.identifier === 'rgb:red');
+                const colorGreenUpdate = updates.find((u) => u.property.identifier === 'rgb:green');
+                const colorBlueUpdate = updates.find((u) => u.property.identifier === 'rgb:blue');
+                const whiteUpdate = updates.find((u) => u.property.identifier === 'white');
+                const hasBrightnessOrColorUpdate = brightnessUpdate || colorRedUpdate || colorGreenUpdate || colorBlueUpdate || whiteUpdate;
+                const outputValue = outputUpdate
+                    ? (0, transform_utils_1.coerceBooleanSafe)(outputUpdate.val)
+                    : hasBrightnessOrColorUpdate
+                        ? true
+                        : (0, transform_utils_1.coerceBooleanSafe)(comp.output);
+                const brightnessValue = brightnessUpdate
+                    ? (0, transform_utils_1.coerceNumberSafe)(brightnessUpdate.val)
+                    : (0, transform_utils_1.coerceNumberSafe)(comp.brightness);
+                const colorRedValue = colorRedUpdate ? (0, transform_utils_1.coerceNumberSafe)(colorRedUpdate.val) : (0, transform_utils_1.coerceNumberSafe)(comp.rgb[0]);
+                const colorGreenValue = colorGreenUpdate
+                    ? (0, transform_utils_1.coerceNumberSafe)(colorGreenUpdate.val)
+                    : (0, transform_utils_1.coerceNumberSafe)(comp.rgb[1]);
+                const colorBlueValue = colorBlueUpdate ? (0, transform_utils_1.coerceNumberSafe)(colorBlueUpdate.val) : (0, transform_utils_1.coerceNumberSafe)(comp.rgb[2]);
+                const whiteValue = whiteUpdate ? (0, transform_utils_1.coerceNumberSafe)(whiteUpdate.val) : (0, transform_utils_1.coerceNumberSafe)(comp.white);
+                if (outputValue === null ||
+                    typeof outputValue !== 'boolean' ||
+                    brightnessValue === null ||
+                    Number.isNaN(brightnessValue) ||
+                    colorRedValue === null ||
+                    Number.isNaN(colorRedValue) ||
+                    colorGreenValue === null ||
+                    Number.isNaN(colorGreenValue) ||
+                    colorBlueValue === null ||
+                    Number.isNaN(colorBlueValue) ||
+                    whiteValue === null ||
+                    Number.isNaN(whiteValue)) {
+                    this.logger.warn(`Dropping invalid batch update for ${comp.key} (channel=${rgbw.id})`);
+                    return;
+                }
+                await comp.set(outputValue, Math.round((0, transform_utils_1.clampNumber)(brightnessValue, 0, 100)), [
+                    Math.round((0, transform_utils_1.clampNumber)(colorRedValue, 0, 255)),
+                    Math.round((0, transform_utils_1.clampNumber)(colorGreenValue, 0, 255)),
+                    Math.round((0, transform_utils_1.clampNumber)(colorBlueValue, 0, 255)),
+                ], Math.round((0, transform_utils_1.clampNumber)(whiteValue, 0, 255)));
+                return true;
+            });
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.cct.values()) {
+            const cct = await this.channelsService.findOneBy('identifier', `cct:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (cct === null) {
+                continue;
+            }
+            const cctOn = await this.channelsPropertiesService.findOneBy('identifier', 'output', cct.id);
+            if (cctOn === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load cct on channel property');
+            }
+            await this.setDefaultPropertyValue(device.id, cctOn, comp.output);
+            this.changeHandlers.set(`${delegate.id}|${comp.key}|output`, (val) => {
+                this.handleChange(cctOn, (0, transform_utils_1.coerceBooleanSafe)(val)).catch((err) => {
+                    this.logger.error(`Failed to set value for component=${comp.key} attribute=output and property=${cctOn.id}`, {
+                        resource: device.id,
+                        message: err.message,
+                        stack: err.stack,
+                    });
+                });
+            });
+            this.setPropertiesHandlers.set(`${delegate.id}|${cctOn.id}`, async (val) => {
+                if (typeof val !== 'boolean') {
+                    return false;
+                }
+                await comp.set(val);
+                return true;
+            });
+            if (typeof comp.brightness !== 'undefined') {
+                const brightness = await this.channelsPropertiesService.findOneBy('identifier', 'brightness', cct.id);
+                if (brightness === null) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load cct brightness channel property');
+                }
+                await this.setDefaultPropertyValue(device.id, brightness, (0, transform_utils_1.clampNumber)(comp.brightness, 0, 100));
+                this.changeHandlers.set(`${delegate.id}|${comp.key}|brightness`, (val) => {
+                    this.handleNumericChange(comp.key, 'brightness', brightness.id, val, (n) => this.handleChange(brightness, n, false), { clamp: { min: 0, max: 100 } });
+                });
+                this.setPropertiesHandlers.set(`${delegate.id}|${brightness.id}`, async (val) => {
+                    const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                    if (n === null || Number.isNaN(n)) {
+                        this.logger.warn(`Dropping invalid numeric update for ${comp.key}.brightness -> ${String(val)} (property=${brightness.id})`);
+                        return;
+                    }
+                    await comp.set(true, Math.round((0, transform_utils_1.clampNumber)(n, 0, 100)));
+                    return true;
+                });
+            }
+            if (typeof comp.ct !== 'undefined') {
+                const ct = await this.channelsPropertiesService.findOneBy('identifier', 'temperature', cct.id);
+                if (ct === null) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load cct ct channel property');
+                }
+                await this.setDefaultPropertyValue(device.id, ct, (0, transform_utils_1.clampNumber)(comp.ct, 2_700, 6_500));
+                this.changeHandlers.set(`${delegate.id}|${comp.key}|ct`, (val) => {
+                    this.handleNumericChange(comp.key, 'ct', ct.id, val, (n) => this.handleChange(ct, n, false), {
+                        clamp: { min: 0, max: 100 },
+                    });
+                });
+                this.setPropertiesHandlers.set(`${delegate.id}|${ct.id}`, async (val) => {
+                    const n = (0, transform_utils_1.coerceNumberSafe)(val);
+                    if (n === null || Number.isNaN(n)) {
+                        this.logger.warn(`Dropping invalid numeric update for ${comp.key}.ct -> ${String(val)} (property=${ct.id})`);
+                        return;
+                    }
+                    await comp.set(true, Math.round((0, transform_utils_1.clampNumber)(n, 2_700, 6_500)));
+                    return true;
+                });
+            }
+            this.setChannelsHandlers.set(`${delegate.id}|${cct.id}`, async (updates) => {
+                const outputUpdate = updates.find((u) => u.property.identifier === 'output');
+                const brightnessUpdate = updates.find((u) => u.property.identifier === 'brightness');
+                const ctUpdate = updates.find((u) => u.property.identifier === 'temperature');
+                const hasBrightnessOrCtUpdate = brightnessUpdate || ctUpdate;
+                const outputValue = outputUpdate
+                    ? (0, transform_utils_1.coerceBooleanSafe)(outputUpdate.val)
+                    : hasBrightnessOrCtUpdate
+                        ? true
+                        : comp.output;
+                const brightnessValue = brightnessUpdate ? (0, transform_utils_1.coerceNumberSafe)(brightnessUpdate.val) : comp.brightness;
+                const ctValue = ctUpdate ? (0, transform_utils_1.coerceNumberSafe)(ctUpdate.val) : comp.ct;
+                if (outputValue === null ||
+                    typeof outputValue !== 'boolean' ||
+                    brightnessValue === null ||
+                    Number.isNaN(brightnessValue) ||
+                    ctValue === null ||
+                    Number.isNaN(ctValue)) {
+                    this.logger.warn(`Dropping invalid batch update for ${comp.key} (channel=${cct.id})`);
+                    return;
+                }
+                await comp.set(outputValue, Math.round((0, transform_utils_1.clampNumber)(brightnessValue, 0, 100)), Math.round((0, transform_utils_1.clampNumber)(ctValue, 2_700, 6_500)));
+                return true;
+            });
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.humidity.values()) {
+            const humidity = await this.channelsService.findOneBy('identifier', `humidity:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (humidity === null) {
+                continue;
+            }
+            const relativeHumidity = await this.channelsPropertiesService.findOneBy('identifier', 'rh', humidity.id);
+            if (relativeHumidity === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load humidity channel property');
+            }
+            await this.setDefaultPropertyValue(device.id, relativeHumidity, (0, transform_utils_1.clampNumber)(comp.rh, 0, 100));
+            this.changeHandlers.set(`${delegate.id}|${comp.key}|rh`, (val) => {
+                this.handleNumericChange(comp.key, 'rh', relativeHumidity.id, val, (n) => this.handleChange(relativeHumidity, n, false), { clamp: { min: 0, max: 100 } });
+            });
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.temperature.values()) {
+            const temperature = await this.channelsService.findOneBy('identifier', `temperature:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (temperature === null) {
+                continue;
+            }
+            const relativeTemperature = await this.channelsPropertiesService.findOneBy('identifier', 'tC', temperature.id);
+            if (relativeTemperature === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load temperature channel property');
+            }
+            await this.setDefaultPropertyValue(device.id, relativeTemperature, comp.tC);
+            this.changeHandlers.set(`${delegate.id}|${comp.key}|tC`, (val) => {
+                this.handleNumericChange(comp.key, 'tC', relativeTemperature.id, val, (n) => this.handleChange(relativeTemperature, n, false));
+            });
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.devPwr.values()) {
+            const devicePower = await this.channelsService.findOneBy('identifier', `devicePower:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (devicePower === null) {
+                continue;
+            }
+            if (comp.battery) {
+                const battery = await this.channelsPropertiesService.findOneBy('identifier', 'battery', devicePower.id);
+                if (battery === null) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load device power battery channel property');
+                }
+                await this.setDefaultPropertyValue(device.id, battery, (0, transform_utils_1.clampNumber)(comp.battery.percent, 0, 100));
+                this.changeHandlers.set(`${delegate.id}|${comp.key}|battery.percent`, (val) => {
+                    this.handleNumericChange(comp.key, 'battery.percent', battery.id, val, (n) => this.handleChange(battery, n, false), { clamp: { min: 0, max: 100 } });
+                });
+            }
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        for (const comp of delegate.pm1.values()) {
+            const electricalPower = await this.channelsService.findOneBy('identifier', `power:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (electricalPower === null) {
+                continue;
+            }
+            const power = await this.channelsPropertiesService.findOneBy('identifier', 'apower', electricalPower.id);
+            if (power === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load electrical power channel property');
+            }
+            await this.setDefaultPropertyValue(device.id, power, Math.max(0, comp.apower));
+            this.changeHandlers.set(`${delegate.id}|${comp.key}|apower`, (val) => {
+                this.handleNumericChange(comp.key, 'apower', power.id, val, (n) => this.handleChange(power, Math.max(0, n), false));
+            });
+            if (typeof comp.voltage !== 'undefined') {
+                const voltage = await this.channelsPropertiesService.findOneBy('identifier', 'voltage', electricalPower.id);
+                if (voltage === null) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load electrical power voltage channel property');
+                }
+                await this.setDefaultPropertyValue(device.id, voltage, comp.voltage);
+                this.changeHandlers.set(`${delegate.id}|${comp.key}|voltage`, (val) => {
+                    this.handleNumericChange(comp.key, 'voltage', voltage.id, val, (n) => this.handleChange(voltage, n, false));
+                });
+            }
+            if (typeof comp.current !== 'undefined') {
+                const current = await this.channelsPropertiesService.findOneBy('identifier', 'current', electricalPower.id);
+                if (current === null) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgNotFoundException('Failed to load electrical power current channel property');
+                }
+                await this.setDefaultPropertyValue(device.id, current, comp.current);
+                this.changeHandlers.set(`${delegate.id}|${comp.key}|current`, (val) => {
+                    this.handleNumericChange(comp.key, 'current', current.id, val, (n) => this.handleChange(current, n, false));
+                });
+            }
+            if (typeof comp.aenergy !== 'undefined') {
+                const electricalEnergy = await this.channelsService.findOneBy('identifier', `energy:${comp.id}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+                if (electricalEnergy === null) {
+                }
+                else {
+                    const consumption = await this.channelsPropertiesService.findOneBy('identifier', 'aenergy', electricalEnergy.id);
+                    if (consumption === null) {
+                    }
+                    else {
+                        await this.setDefaultPropertyValue(device.id, consumption, (0, transform_utils_2.toEnergy)(comp.aenergy));
+                        this.changeHandlers.set(`${delegate.id}|${comp.key}|aenergy`, (val) => {
+                            this.handleNumericChange(comp.key, 'aenergy', consumption.id, val, (n) => this.handleChange(consumption, (0, transform_utils_2.toEnergy)(n), false));
+                        });
+                    }
+                }
+            }
+        }
+        if (this.insertGeneration.get(shelly.id) !== generation)
+            return delegate;
+        const valueHandler = (compKey, attr, val) => {
+            const handler = this.changeHandlers.get(`${delegate.id}|${compKey}|${attr}`);
+            if (!handler) {
+                return;
+            }
+            try {
+                handler(val);
+            }
+            catch (error) {
+                const err = error;
+                this.logger.error(`Shelly handler error for component=${compKey} attribute=${attr}`, {
+                    resource: device.id,
+                    message: err.message,
+                    stack: err.stack,
+                });
+            }
+        };
+        delegate.on('value', valueHandler);
+        this.delegateValueHandlers.set(delegate.id, valueHandler);
+        const connectionHandler = (state) => {
+            this.deviceConnectivityService
+                .setConnectionState(device.id, {
+                state: state === null ? devices_constants_1.ConnectionState.UNKNOWN : state ? devices_constants_1.ConnectionState.CONNECTED : devices_constants_1.ConnectionState.DISCONNECTED,
+            })
+                .then(() => {
+                if (state) {
+                }
+                else {
+                }
+            })
+                .catch((err) => {
+                this.logger.error(`Failed to set state=${state ? devices_constants_1.ConnectionState.CONNECTED : devices_constants_1.ConnectionState.DISCONNECTED} for device=${delegate.id}`, {
+                    resource: device.id,
+                    message: err.message,
+                    stack: err.stack,
+                });
+            });
+        };
+        delegate.on('connected', connectionHandler);
+        this.delegateConnectionHandlers.set(delegate.id, connectionHandler);
+        connectionHandler(true);
+        this.logger.log(`Attached Shelly device=${delegate.id}`, { resource: device.id });
+        return delegate;
+    }
+    remove(deviceId) {
+        return this.withDeviceLock(deviceId, () => {
+            this.performRemove(deviceId);
+            return Promise.resolve();
+        });
+    }
+    performRemove(deviceId) {
+        const delegate = this.delegates.get(deviceId);
+        if (!delegate) {
+            return;
+        }
+        const valueHandler = this.delegateValueHandlers.get(delegate.id);
+        const connectionHandler = this.delegateConnectionHandlers.get(delegate.id);
+        if (connectionHandler) {
+            connectionHandler(null);
+        }
+        else {
+            const deviceDbId = this.delegateDeviceIds.get(deviceId) ?? deviceId;
+            void this.deviceConnectivityService
+                .setConnectionState(deviceDbId, { state: devices_constants_1.ConnectionState.UNKNOWN })
+                .catch((err) => {
+                this.logger.warn(`Failed to mark device=${delegate.id} as disconnected while removing delegate`, {
+                    resource: delegate.id,
+                    message: err.message,
+                    stack: err.stack,
+                });
+            });
+        }
+        if (valueHandler) {
+            delegate.off('value', valueHandler);
+        }
+        if (connectionHandler) {
+            delegate.off('connected', connectionHandler);
+        }
+        this.delegateValueHandlers.delete(delegate.id);
+        this.delegateConnectionHandlers.delete(delegate.id);
+        for (const key of Array.from(this.changeHandlers.keys())) {
+            if (key.startsWith(`${deviceId}|`)) {
+                this.changeHandlers.delete(key);
+            }
+        }
+        for (const key of Array.from(this.setPropertiesHandlers.keys())) {
+            if (key.startsWith(`${deviceId}|`)) {
+                this.setPropertiesHandlers.delete(key);
+            }
+        }
+        for (const key of Array.from(this.setChannelsHandlers.keys())) {
+            if (key.startsWith(`${deviceId}|`)) {
+                this.setChannelsHandlers.delete(key);
+            }
+        }
+        const ids = this.propertiesMap.get(deviceId);
+        if (ids) {
+            for (const pid of ids) {
+                clearTimeout(this.pendingWrites.get(pid));
+                this.pendingWrites.delete(pid);
+            }
+            this.propertiesMap.delete(deviceId);
+        }
+        this.delegateDeviceIds.delete(deviceId);
+        this.insertGeneration.delete(deviceId);
+        this.delegates.delete(deviceId);
+        this.logger.log(`Detached Shelly device=${deviceId}`, { resource: deviceId });
+    }
+    async setChannelValue(device, channel, updates) {
+        const handler = this.setChannelsHandlers.get(`${device.identifier}|${channel.id}`);
+        if (!handler) {
+            return Promise.reject(new devices_shelly_ng_exceptions_1.DevicesShellyNgNotImplementedException('Multiple property writes are not supported by the component.'));
+        }
+        const transformedUpdates = updates.map((row) => {
+            const propertyMapping = this.propertyMappingStorage.get(row.property.id);
+            let transformedValue = row.value;
+            if (propertyMapping) {
+                transformedValue = this.applyTransformer(propertyMapping, row.value, 'write');
+                this.logger.debug(`Applied transformer for property=${row.property.id}: ${row.value} -> ${transformedValue}`, {
+                    resource: device.id,
+                });
+            }
+            return { property: row.property, val: transformedValue };
+        });
+        return handler(transformedUpdates);
+    }
+    async setPropertyValue(device, property, value) {
+        const handler = this.setPropertiesHandlers.get(`${device.identifier}|${property.id}`);
+        if (!handler) {
+            this.logger.warn(`Trying to write to device=${device.identifier} to not writable property=${property.id} value=${value}`, { resource: device.id });
+            return Promise.resolve(false);
+        }
+        const propertyMapping = this.propertyMappingStorage.get(property.id);
+        let transformedValue = value;
+        if (propertyMapping) {
+            transformedValue = this.applyTransformer(propertyMapping, value, 'write');
+            this.logger.debug(`Applied transformer for property=${property.id}: ${value} -> ${transformedValue}`, {
+                resource: device.id,
+            });
+        }
+        return handler(transformedValue);
+    }
+    applyTransformer(propertyMapping, value, direction = 'read') {
+        let transformer = null;
+        if (propertyMapping.transformerName) {
+            transformer = this.transformerRegistry.get(propertyMapping.transformerName);
+        }
+        else if (propertyMapping.inlineTransform) {
+            transformer = (0, transformers_1.createInlineTransformer)(propertyMapping.inlineTransform);
+        }
+        if (!transformer) {
+            return value;
+        }
+        if (direction === 'read' && !transformer.canRead()) {
+            this.logger.warn(`Transformer does not support read operation for property mapping`);
+            return value;
+        }
+        if (direction === 'write' && !transformer.canWrite()) {
+            this.logger.warn(`Transformer does not support write operation for property mapping`);
+            return value;
+        }
+        try {
+            return direction === 'read' ? transformer.read(value) : transformer.write(value);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to apply transformer: ${error instanceof Error ? error.message : String(error)}`);
+            return value;
+        }
+    }
+    async handleChange(property, value, immediately = true) {
+        if (immediately) {
+            await this.writeValueToProperty(property, value);
+        }
+        else {
+            this.scheduleWrite(property, value);
+        }
+    }
+    async setDefaultPropertyValue(deviceId, property, value) {
+        try {
+            await this.writeValueToProperty(property, value);
+        }
+        catch (error) {
+            this.logger.warn(`Skipping default value write for property=${property.id} (entity may have been removed)`, {
+                resource: deviceId,
+                message: error.message,
+            });
+            return;
+        }
+        let set = this.propertiesMap.get(deviceId);
+        if (!set) {
+            this.propertiesMap.set(deviceId, (set = new Set()));
+        }
+        set.add(property.id);
+    }
+    determineCategory(delegate) {
+        if (delegate.covers.size > 0) {
+            return devices_constants_1.DeviceCategory.WINDOW_COVERING;
+        }
+        else if (delegate.lights.size > 0 || delegate.rgb.size > 0 || delegate.rgbw.size > 0 || delegate.cct.size > 0) {
+            return devices_constants_1.DeviceCategory.LIGHTING;
+        }
+        else if (delegate.switches.size > 0) {
+            return devices_constants_1.DeviceCategory.SWITCHER;
+        }
+        else if (delegate.inputs.size > 0 ||
+            delegate.temperature.size > 0 ||
+            delegate.humidity.size > 0 ||
+            delegate.pm1.size > 0) {
+            return devices_constants_1.DeviceCategory.SENSOR;
+        }
+        return devices_constants_1.DeviceCategory.GENERIC;
+    }
+    handleNumericChange(compKey, attr, propertyId, val, write, opts) {
+        const n = (0, transform_utils_1.coerceNumberSafe)(val, opts);
+        if (n === null || Number.isNaN(n)) {
+            this.logger.warn(`Dropping invalid numeric update for ${compKey}.${attr} -> ${(0, transform_utils_1.safeToString)(val)} (property=${propertyId})`);
+            return;
+        }
+        void write(n).catch((err) => {
+            this.logger.error(`Failed to set value for component=${compKey} attribute=${attr} property=${propertyId}`, {
+                message: err.message,
+                stack: err.stack,
+            });
+        });
+    }
+    scheduleWrite(property, value) {
+        const existing = this.pendingWrites.get(property.id);
+        if (existing) {
+            clearTimeout(existing);
+        }
+        const t = setTimeout(() => {
+            const current = this.pendingWrites.get(property.id);
+            if (current) {
+                clearTimeout(current);
+                this.pendingWrites.delete(property.id);
+            }
+            this.writeValueToProperty(property, value).catch((err) => {
+                this.logger.error(`Failed to process scheduled write of value=${(0, transform_utils_1.safeToString)(value)} to property=${property.id}`, { message: err.message, stack: err.stack });
+            });
+        }, 250);
+        this.pendingWrites.set(property.id, t);
+    }
+    async writeValueToProperty(property, value) {
+        return await this.channelsPropertiesService.update(property.id, (0, transform_utils_1.toInstance)(update_channel_property_dto_1.UpdateShellyNgChannelPropertyDto, {
+            ...(0, class_transformer_1.instanceToPlain)(property),
+            value,
+        }));
+    }
+    detach() {
+        for (const [deviceId] of this.delegates.entries()) {
+            this.performRemove(deviceId);
+        }
+        this.changeHandlers.clear();
+        this.setPropertiesHandlers.clear();
+        this.setChannelsHandlers.clear();
+        this.propertiesMap.clear();
+        for (const pendingWrite of this.pendingWrites.values()) {
+            clearTimeout(pendingWrite);
+        }
+        this.pendingWrites.clear();
+        this.deviceLocks.clear();
+    }
+    destroy() {
+        this.detach();
+    }
+    async withDeviceLock(deviceId, fn) {
+        const pending = this.deviceLocks.get(deviceId) ?? Promise.resolve();
+        let resolveLock;
+        const lock = new Promise((r) => {
+            resolveLock = r;
+        });
+        this.deviceLocks.set(deviceId, lock);
+        await pending.catch(() => { });
+        try {
+            return await fn();
+        }
+        finally {
+            resolveLock();
+            if (this.deviceLocks.get(deviceId) === lock) {
+                this.deviceLocks.delete(deviceId);
+            }
+        }
+    }
+};
+exports.DelegatesManagerService = DelegatesManagerService;
+exports.DelegatesManagerService = DelegatesManagerService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [devices_service_1.DevicesService,
+        channels_service_1.ChannelsService,
+        channels_properties_service_1.ChannelsPropertiesService,
+        device_connectivity_service_1.DeviceConnectivityService,
+        device_manager_service_1.DeviceManagerService,
+        mappings_1.PropertyMappingStorageService,
+        mappings_1.TransformerRegistry])
+], DelegatesManagerService);
+//# sourceMappingURL=delegates-manager.service.js.map