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

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

@@ -0,0 +1,1130 @@
+"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.DeviceManagerService = void 0;
+const common_1 = require("@nestjs/common");
+const logger_1 = require("../../../common/logger");
+const http_utils_1 = require("../../../common/utils/http.utils");
+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_provision_queue_service_1 = require("../../../modules/devices/services/device-provision-queue.service");
+const devices_service_1 = require("../../../modules/devices/services/devices.service");
+const channels_1 = require("../../../spec/channels");
+const devices_shelly_ng_constants_1 = require("../devices-shelly-ng.constants");
+const devices_shelly_ng_exceptions_1 = require("../devices-shelly-ng.exceptions");
+const mappings_1 = require("../mappings");
+const transformers_1 = require("../mappings/transformers/transformers");
+const transform_utils_2 = require("../utils/transform.utils");
+const device_address_service_1 = require("./device-address.service");
+const shelly_rpc_client_service_1 = require("./shelly-rpc-client.service");
+let DeviceManagerService = class DeviceManagerService {
+    constructor(shellyRpcClientService, devicesService, channelsService, channelsPropertiesService, mappingLoaderService, transformerRegistry, propertyMappingStorage, provisionQueue, deviceAddressService) {
+        this.shellyRpcClientService = shellyRpcClientService;
+        this.devicesService = devicesService;
+        this.channelsService = channelsService;
+        this.channelsPropertiesService = channelsPropertiesService;
+        this.mappingLoaderService = mappingLoaderService;
+        this.transformerRegistry = transformerRegistry;
+        this.propertyMappingStorage = propertyMappingStorage;
+        this.provisionQueue = provisionQueue;
+        this.deviceAddressService = deviceAddressService;
+        this.logger = (0, logger_1.createExtensionLogger)(devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_PLUGIN_NAME, 'DeviceManagerService');
+        this.defaultManager = (() => {
+            const candidate = this.channelsService.dataSource?.manager ??
+                this.channelsPropertiesService.dataSource?.manager;
+            return candidate;
+        })();
+        this.strictSchema = false;
+        this.timeoutSec = 30;
+        this.rpcConcurrency = 1;
+    }
+    async getDeviceInfo(hostname, password) {
+        const deviceInfo = await this.shellyRpcClientService.getDeviceInfo(hostname, { password });
+        const deviceProvidedComponents = await this.shellyRpcClientService.getComponents(hostname, { password });
+        const systemConfig = await this.shellyRpcClientService.getSystemConfig(hostname, { password });
+        const groups = {};
+        for (const { key } of deviceProvidedComponents) {
+            const [type, rest] = key.split(':', 2);
+            const g = (groups[type] ??= { ids: [], keys: [] });
+            g.keys.push(key);
+            if (typeof rest === 'string' && rest.length > 0) {
+                const id = Number(rest);
+                if (Number.isFinite(id) && !g.ids.includes(id)) {
+                    g.ids.push(id);
+                }
+            }
+        }
+        for (const g of Object.values(groups)) {
+            g.keys = Array.from(new Set(g.keys)).sort();
+            g.ids.sort((a, b) => a - b);
+        }
+        const components = Object.entries(groups)
+            .map(([type, g]) => ({ type, ids: g.ids }))
+            .sort((a, b) => a.type.localeCompare(b.type));
+        return {
+            ...deviceInfo,
+            name: systemConfig.device.name,
+            components,
+        };
+    }
+    async createOrUpdate(id) {
+        return this.provisionQueue.enqueue(id, async () => {
+            const device = await this.devicesService.findOne(id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (device === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgException('Device not found.');
+            }
+            const hostname = await this.deviceAddressService.getPreferredAddressOrMigrate(device.id);
+            if (hostname === null) {
+                this.logger.debug(`No network address found yet for device=${device.id}, skipping provision`);
+                return device;
+            }
+            const deviceInfo = await this.getDeviceInfo(hostname, device.password);
+            const deviceSpec = this.getSpecification(deviceInfo.model);
+            if (deviceSpec === null) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgException(`Provided device is not supported hostname=${hostname} model=${deviceInfo.model}`);
+            }
+            const specHasEthernet = deviceSpec.system.some((s) => s.type === devices_shelly_ng_constants_1.ComponentType.ETHERNET);
+            if (device.hasEthernet !== specHasEthernet) {
+                device.hasEthernet = specHasEthernet;
+                await this.deviceAddressService.setHasEthernet(device.id, specHasEthernet);
+            }
+            const channelsIds = [];
+            const deviceInformation = await this.ensureChannel(device, 'category', devices_constants_1.ChannelCategory.DEVICE_INFORMATION, devices_constants_1.ChannelCategory.DEVICE_INFORMATION, 'Device information');
+            channelsIds.push(deviceInformation.id);
+            await this.ensureProperty(deviceInformation, devices_constants_1.PropertyCategory.MANUFACTURER, 'category', devices_constants_1.PropertyCategory.MANUFACTURER, 'Shelly');
+            await this.ensureProperty(deviceInformation, devices_constants_1.PropertyCategory.MODEL, 'category', devices_constants_1.PropertyCategory.MODEL, deviceInfo.model);
+            await this.ensureProperty(deviceInformation, devices_constants_1.PropertyCategory.SERIAL_NUMBER, 'category', devices_constants_1.PropertyCategory.SERIAL_NUMBER, deviceInfo.id);
+            await this.ensureProperty(deviceInformation, devices_constants_1.PropertyCategory.FIRMWARE_REVISION, 'category', devices_constants_1.PropertyCategory.FIRMWARE_REVISION, deviceInfo.ver);
+            await this.ensureProperty(deviceInformation, devices_constants_1.PropertyCategory.STATUS, 'category', devices_constants_1.PropertyCategory.STATUS, devices_constants_1.ConnectionState.UNKNOWN, {
+                format: [devices_constants_1.ConnectionState.CONNECTED, devices_constants_1.ConnectionState.DISCONNECTED, devices_constants_1.ConnectionState.UNKNOWN],
+            });
+            try {
+                const wifiInfo = await this.shellyRpcClientService.getWifiStatus(hostname, {
+                    password: device.password,
+                });
+                await this.ensureProperty(deviceInformation, devices_constants_1.PropertyCategory.LINK_QUALITY, 'category', devices_constants_1.PropertyCategory.LINK_QUALITY, (0, transform_utils_2.rssiToQuality)(wifiInfo.rssi));
+            }
+            catch {
+            }
+            const deviceComponents = deviceInfo.components.reduce((acc, group) => {
+                acc[group.type] = group.ids;
+                return acc;
+            }, {});
+            const limit = (0, http_utils_1.pLimit)(this.rpcConcurrency);
+            const host = hostname;
+            const password = device.password;
+            for (const [type, ids] of Object.entries(deviceComponents)) {
+                if (type === String(devices_shelly_ng_constants_1.ComponentType.SWITCH) &&
+                    (!deviceInfo.profile || deviceInfo.profile === String(devices_shelly_ng_constants_1.DeviceProfile.SWITCH))) {
+                    const tasks = ids.map((key) => limit(async () => {
+                        const [switchConfig, switchStatus] = await (0, http_utils_1.retry)(() => (0, http_utils_1.withTimeout)(Promise.all([
+                            this.shellyRpcClientService.getSwitchConfig(host, key, { password }),
+                            this.shellyRpcClientService.getSwitchStatus(host, key, { password }),
+                        ]), this.timeoutSec * 1000, `Switch.GetConfig+Switch.GetStatus - ${key}`), { retries: 2, baseMs: 300, factor: 2 }).catch((err) => {
+                            this.logger.error(`Failed load for switch=${key} on device=${device.id}`, {
+                                resource: device.id,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                            throw err;
+                        });
+                        const mappingContext = {
+                            componentType: devices_shelly_ng_constants_1.ComponentType.SWITCH,
+                            componentKey: key,
+                            deviceCategory: device.category,
+                            model: deviceInfo.model,
+                            profile: deviceInfo.profile ?? undefined,
+                        };
+                        const mapping = this.mappingLoaderService.findMatchingMapping(mappingContext);
+                        if (!mapping || mapping.channels.length === 0) {
+                            this.logger.warn(`No mapping found for switch component key=${key} device=${device.id} category=${device.category}. Using default SWITCHER channel.`, {
+                                resource: device.id,
+                                componentKey: key,
+                                deviceCategory: device.category,
+                            });
+                            const chan = await this.ensureChannel(device, 'identifier', `switch:${key}`, devices_constants_1.ChannelCategory.SWITCHER, switchConfig.name ?? `Switch: ${key}`);
+                            channelsIds.push(chan.id);
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.ON, 'identifier', 'output', !!switchStatus.output);
+                            return;
+                        }
+                        const channelDef = mapping.channels[0];
+                        const cat = channelDef.category;
+                        const chanName = switchConfig.name ??
+                            this.mappingLoaderService.interpolateTemplate(channelDef.name ?? `Switch: {key}`, mappingContext);
+                        const chan = await this.ensureChannel(device, 'identifier', `switch:${key}`, cat, chanName);
+                        channelsIds.push(chan.id);
+                        const onPropertyMapping = this.findPropertyMapping(channelDef, devices_constants_1.PropertyCategory.ON);
+                        const transformedOutput = this.applyTransformer(onPropertyMapping, switchStatus.output, 'read');
+                        await this.ensureProperty(chan, devices_constants_1.PropertyCategory.ON, 'identifier', onPropertyMapping?.shellyProperty ?? 'output', transformedOutput, undefined, onPropertyMapping);
+                        if (cat === devices_constants_1.ChannelCategory.VALVE) {
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.TYPE, 'identifier', 'output', 'generic', {
+                                format: ['generic', 'irrigation', 'shower_head', 'water_faucet'],
+                            });
+                        }
+                        const energyName = switchConfig.name
+                            ? `Consumption: ${switchConfig.name}`
+                            : `${cat === devices_constants_1.ChannelCategory.LIGHT ? 'Light' : cat === devices_constants_1.ChannelCategory.FAN ? 'Fan' : cat === devices_constants_1.ChannelCategory.VALVE ? 'Valve' : 'Switch'} consumption: ${key}`;
+                        const powerName = switchConfig.name
+                            ? `Power: ${switchConfig.name}`
+                            : `${cat === devices_constants_1.ChannelCategory.LIGHT ? 'Light' : cat === devices_constants_1.ChannelCategory.FAN ? 'Fan' : cat === devices_constants_1.ChannelCategory.VALVE ? 'Valve' : 'Switch'} power: ${key}`;
+                        const ee = await this.ensureElectricalEnergy(device, key, switchStatus, energyName, chan.id);
+                        if (ee) {
+                            channelsIds.push(ee.channel.id);
+                        }
+                        const ep = await this.ensureElectricalPower(device, key, switchStatus, powerName, chan.id);
+                        if (ep) {
+                            channelsIds.push(ep.channel.id);
+                        }
+                    }));
+                    const settled = await Promise.allSettled(tasks);
+                    const failed = settled.filter((r) => r.status === 'rejected').length;
+                    if (failed) {
+                        this.logger.warn(`${failed}/${ids.length} switch component(s) failed for device=${device.id}`, {
+                            resource: device.id,
+                        });
+                    }
+                }
+                else if (type === String(devices_shelly_ng_constants_1.ComponentType.COVER) && deviceInfo.profile === String(devices_shelly_ng_constants_1.DeviceProfile.COVER)) {
+                    const tasks = ids.map((key) => limit(async () => {
+                        const [coverConfig, coverStatus] = await (0, http_utils_1.retry)(() => (0, http_utils_1.withTimeout)(Promise.all([
+                            this.shellyRpcClientService.getCoverConfig(host, key, { password }),
+                            this.shellyRpcClientService.getCoverStatus(host, key, { password }),
+                        ]), this.timeoutSec * 1000, `Cover.GetConfig+Cover.GetStatus - ${key}`), { retries: 2, baseMs: 300, factor: 2 }).catch((err) => {
+                            this.logger.error(`Failed load for cover=${key} on device=${device.id}`, {
+                                resource: device.id,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                            throw err;
+                        });
+                        const coverMappingContext = {
+                            componentType: devices_shelly_ng_constants_1.ComponentType.COVER,
+                            componentKey: key,
+                            deviceCategory: device.category,
+                            model: deviceInfo.model,
+                            profile: deviceInfo.profile ?? undefined,
+                        };
+                        const coverMapping = this.mappingLoaderService.findMatchingMapping(coverMappingContext);
+                        if (!coverMapping || coverMapping.channels.length === 0) {
+                            this.logger.warn(`No mapping found for cover component key=${key} device=${device.id} category=${device.category}. Using default WINDOW_COVERING channel.`, {
+                                resource: device.id,
+                                componentKey: key,
+                                deviceCategory: device.category,
+                            });
+                            const chan = await this.ensureChannel(device, 'identifier', `cover:${key}`, devices_constants_1.ChannelCategory.WINDOW_COVERING, coverConfig.name ?? `Cover: ${key}`);
+                            channelsIds.push(chan.id);
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.STATUS, 'identifier', 'state', coverStatus.state);
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.POSITION, 'identifier', 'current_pos', coverStatus.current_pos);
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COMMAND, 'category', devices_constants_1.PropertyCategory.COMMAND, 'stop');
+                            return;
+                        }
+                        const coverChannelDef = coverMapping.channels[0];
+                        const coverCat = coverChannelDef.category;
+                        const coverChanName = coverConfig.name ??
+                            this.mappingLoaderService.interpolateTemplate(coverChannelDef.name ?? `Cover: {key}`, coverMappingContext);
+                        const chan = await this.ensureChannel(device, 'identifier', `cover:${key}`, coverCat, coverChanName);
+                        channelsIds.push(chan.id);
+                        const statusPropertyMapping = this.findPropertyMapping(coverChannelDef, devices_constants_1.PropertyCategory.STATUS);
+                        const transformedState = this.applyTransformer(statusPropertyMapping, coverStatus.state, 'read');
+                        await this.ensureProperty(chan, devices_constants_1.PropertyCategory.STATUS, 'identifier', statusPropertyMapping?.shellyProperty ?? 'state', transformedState, undefined, statusPropertyMapping);
+                        const positionPropertyMapping = this.findPropertyMapping(coverChannelDef, devices_constants_1.PropertyCategory.POSITION);
+                        const transformedPosition = this.applyTransformer(positionPropertyMapping, coverStatus.current_pos, 'read');
+                        await this.ensureProperty(chan, devices_constants_1.PropertyCategory.POSITION, 'identifier', positionPropertyMapping?.shellyProperty ?? 'current_pos', transformedPosition, undefined, positionPropertyMapping);
+                        if (coverChannelDef.staticProperties) {
+                            for (const staticProp of coverChannelDef.staticProperties) {
+                                await this.ensureProperty(chan, staticProp.identifier, 'category', staticProp.identifier, staticProp.value, {
+                                    data_type: staticProp.dataType,
+                                    format: staticProp.format,
+                                });
+                            }
+                        }
+                        if (coverChannelDef.derivedProperties) {
+                            for (const derivedProp of coverChannelDef.derivedProperties) {
+                                const sourceProp = await this.channelsPropertiesService.findOneBy('category', derivedProp.sourceProperty, chan.id);
+                                if (sourceProp && sourceProp.value?.value !== null && sourceProp.value?.value !== undefined) {
+                                    const derivedValue = this.applyDerivation(derivedProp.derivationName
+                                        ? this.mappingLoaderService.getDerivation(derivedProp.derivationName)?.rule
+                                        : derivedProp.inlineDerivation, sourceProp.value?.value);
+                                    if (derivedValue !== undefined) {
+                                        await this.ensureProperty(chan, derivedProp.identifier, 'category', derivedProp.identifier, derivedValue, {
+                                            data_type: derivedProp.dataType,
+                                            format: derivedProp.format,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                        const ee = await this.ensureElectricalEnergy(device, key, coverStatus, coverConfig.name ? `Consumption: ${coverConfig.name}` : `Cover consumption: ${key}`, chan.id);
+                        if (ee) {
+                            channelsIds.push(ee.channel.id);
+                        }
+                        const ep = await this.ensureElectricalPower(device, key, coverStatus, coverConfig.name ? `Power: ${coverConfig.name}` : `Cover power: ${key}`, chan.id);
+                        if (ep) {
+                            channelsIds.push(ep.channel.id);
+                        }
+                    }));
+                    const settled = await Promise.allSettled(tasks);
+                    const failed = settled.filter((r) => r.status === 'rejected').length;
+                    if (failed) {
+                        this.logger.warn(`${failed}/${ids.length} cover component(s) failed for device=${device.id}`, {
+                            resource: device.id,
+                        });
+                    }
+                }
+                else if (type === String(devices_shelly_ng_constants_1.ComponentType.LIGHT)) {
+                    const tasks = ids.map((key) => limit(async () => {
+                        const [lightConfig, lightStatus] = await (0, http_utils_1.retry)(() => (0, http_utils_1.withTimeout)(Promise.all([
+                            this.shellyRpcClientService.getLightConfig(host, key, { password }),
+                            this.shellyRpcClientService.getLightStatus(host, key, { password }),
+                        ]), this.timeoutSec * 1000, `Light.GetConfig+Light.GetStatus - ${key}`), { retries: 2, baseMs: 300, factor: 2 }).catch((err) => {
+                            this.logger.error(`Failed load for light=${key} on device=${device.id}`, {
+                                resource: device.id,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                            throw err;
+                        });
+                        const lightMappingContext = {
+                            componentType: devices_shelly_ng_constants_1.ComponentType.LIGHT,
+                            componentKey: key,
+                            deviceCategory: device.category,
+                            model: deviceInfo.model,
+                            profile: deviceInfo.profile ?? undefined,
+                        };
+                        const lightMapping = this.mappingLoaderService.findMatchingMapping(lightMappingContext);
+                        if (!lightMapping || lightMapping.channels.length === 0) {
+                            this.logger.warn(`No mapping found for light component key=${key} device=${device.id} category=${device.category}. Using default LIGHT channel.`, {
+                                resource: device.id,
+                                componentKey: key,
+                                deviceCategory: device.category,
+                            });
+                            const chan = await this.ensureChannel(device, 'identifier', `light:${key}`, devices_constants_1.ChannelCategory.LIGHT, lightConfig.name ?? `Light: ${key}`);
+                            channelsIds.push(chan.id);
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.ON, 'identifier', 'output', lightStatus.output);
+                            if (typeof lightStatus.brightness !== 'undefined') {
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.BRIGHTNESS, 'identifier', 'brightness', lightStatus.brightness);
+                            }
+                            return;
+                        }
+                        const lightChannelDef = lightMapping.channels[0];
+                        const lightCat = lightChannelDef.category;
+                        const lightChanName = lightConfig.name ??
+                            this.mappingLoaderService.interpolateTemplate(lightChannelDef.name ?? `Light: {key}`, lightMappingContext);
+                        const chan = await this.ensureChannel(device, 'identifier', `light:${key}`, lightCat, lightChanName);
+                        channelsIds.push(chan.id);
+                        const onPropertyMapping = this.findPropertyMapping(lightChannelDef, devices_constants_1.PropertyCategory.ON);
+                        const transformedOutput = this.applyTransformer(onPropertyMapping, lightStatus.output, 'read');
+                        await this.ensureProperty(chan, devices_constants_1.PropertyCategory.ON, 'identifier', onPropertyMapping?.shellyProperty ?? 'output', transformedOutput, undefined, onPropertyMapping);
+                        if (typeof lightStatus.brightness !== 'undefined') {
+                            const brightnessPropertyMapping = this.findPropertyMapping(lightChannelDef, devices_constants_1.PropertyCategory.BRIGHTNESS);
+                            const transformedBrightness = this.applyTransformer(brightnessPropertyMapping, lightStatus.brightness, 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.BRIGHTNESS, 'identifier', brightnessPropertyMapping?.shellyProperty ?? 'brightness', transformedBrightness, undefined, brightnessPropertyMapping);
+                        }
+                        const ee = await this.ensureElectricalEnergy(device, key, lightStatus, lightConfig.name ? `Consumption: ${lightConfig.name}` : `Light consumption: ${key}`, chan.id);
+                        if (ee) {
+                            channelsIds.push(ee.channel.id);
+                        }
+                        const ep = await this.ensureElectricalPower(device, key, lightStatus, lightConfig.name ? `Power: ${lightConfig.name}` : `Light power: ${key}`, chan.id);
+                        if (ep) {
+                            channelsIds.push(ep.channel.id);
+                        }
+                    }));
+                    const settled = await Promise.allSettled(tasks);
+                    const failed = settled.filter((r) => r.status === 'rejected').length;
+                    if (failed) {
+                        this.logger.warn(`${failed}/${ids.length} light component(s) failed for device=${device.id}`, {
+                            resource: device.id,
+                        });
+                    }
+                }
+                else if (type === String(devices_shelly_ng_constants_1.ComponentType.RGB)) {
+                    const tasks = ids.map((key) => limit(async () => {
+                        const [rgbConfig, rgbStatus] = await (0, http_utils_1.retry)(() => (0, http_utils_1.withTimeout)(Promise.all([
+                            this.shellyRpcClientService.getRgbConfig(host, key, { password }),
+                            this.shellyRpcClientService.getRgbStatus(host, key, { password }),
+                        ]), this.timeoutSec * 1000, `RGB.GetConfig+RGB.GetStatus - ${key}`), { retries: 2, baseMs: 300, factor: 2 }).catch((err) => {
+                            this.logger.error(`Failed load for rgb=${key} on device=${device.id}`, {
+                                resource: device.id,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                            throw err;
+                        });
+                        const rgbMappingContext = {
+                            componentType: devices_shelly_ng_constants_1.ComponentType.RGB,
+                            componentKey: key,
+                            deviceCategory: device.category,
+                            model: deviceInfo.model,
+                            profile: deviceInfo.profile ?? undefined,
+                        };
+                        const rgbMapping = this.mappingLoaderService.findMatchingMapping(rgbMappingContext);
+                        if (!rgbMapping || rgbMapping.channels.length === 0) {
+                            this.logger.warn(`No mapping found for rgb component key=${key} device=${device.id} category=${device.category}. Using default LIGHT channel.`, {
+                                resource: device.id,
+                                componentKey: key,
+                                deviceCategory: device.category,
+                            });
+                            const chan = await this.ensureChannel(device, 'identifier', `rgb:${key}`, devices_constants_1.ChannelCategory.LIGHT, rgbConfig.name ?? `RGB: ${key}`);
+                            channelsIds.push(chan.id);
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.ON, 'identifier', 'output', rgbStatus.output);
+                            if (typeof rgbStatus.brightness !== 'undefined') {
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.BRIGHTNESS, 'identifier', 'brightness', rgbStatus.brightness);
+                            }
+                            if (typeof rgbStatus.rgb !== 'undefined' &&
+                                Array.isArray(rgbStatus.rgb) &&
+                                rgbStatus.rgb.length === 3) {
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_RED, 'identifier', 'rgb:red', rgbStatus.rgb[0]);
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_GREEN, 'identifier', 'rgb:green', rgbStatus.rgb[1]);
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_BLUE, 'identifier', 'rgb:blue', rgbStatus.rgb[2]);
+                            }
+                            return;
+                        }
+                        const rgbChannelDef = rgbMapping.channels[0];
+                        const rgbCat = rgbChannelDef.category;
+                        const rgbChanName = rgbConfig.name ??
+                            this.mappingLoaderService.interpolateTemplate(rgbChannelDef.name ?? `RGB: {key}`, rgbMappingContext);
+                        const chan = await this.ensureChannel(device, 'identifier', `rgb:${key}`, rgbCat, rgbChanName);
+                        channelsIds.push(chan.id);
+                        const onPropertyMapping = this.findPropertyMapping(rgbChannelDef, devices_constants_1.PropertyCategory.ON);
+                        const transformedOutput = this.applyTransformer(onPropertyMapping, rgbStatus.output, 'read');
+                        await this.ensureProperty(chan, devices_constants_1.PropertyCategory.ON, 'identifier', onPropertyMapping?.shellyProperty ?? 'output', transformedOutput, undefined, onPropertyMapping);
+                        if (typeof rgbStatus.brightness !== 'undefined') {
+                            const brightnessPropertyMapping = this.findPropertyMapping(rgbChannelDef, devices_constants_1.PropertyCategory.BRIGHTNESS);
+                            const transformedBrightness = this.applyTransformer(brightnessPropertyMapping, rgbStatus.brightness, 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.BRIGHTNESS, 'identifier', brightnessPropertyMapping?.shellyProperty ?? 'brightness', transformedBrightness, undefined, brightnessPropertyMapping);
+                        }
+                        if (typeof rgbStatus.rgb !== 'undefined' && Array.isArray(rgbStatus.rgb) && rgbStatus.rgb.length === 3) {
+                            const redPropertyMapping = this.findPropertyMapping(rgbChannelDef, devices_constants_1.PropertyCategory.COLOR_RED);
+                            const transformedRed = this.applyTransformer(redPropertyMapping, rgbStatus.rgb[0], 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_RED, 'identifier', redPropertyMapping?.shellyProperty ?? 'rgb:red', transformedRed, undefined, redPropertyMapping);
+                            const greenPropertyMapping = this.findPropertyMapping(rgbChannelDef, devices_constants_1.PropertyCategory.COLOR_GREEN);
+                            const transformedGreen = this.applyTransformer(greenPropertyMapping, rgbStatus.rgb[1], 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_GREEN, 'identifier', greenPropertyMapping?.shellyProperty ?? 'rgb:green', transformedGreen, undefined, greenPropertyMapping);
+                            const bluePropertyMapping = this.findPropertyMapping(rgbChannelDef, devices_constants_1.PropertyCategory.COLOR_BLUE);
+                            const transformedBlue = this.applyTransformer(bluePropertyMapping, rgbStatus.rgb[2], 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_BLUE, 'identifier', bluePropertyMapping?.shellyProperty ?? 'rgb:blue', transformedBlue, undefined, bluePropertyMapping);
+                        }
+                        const ee = await this.ensureElectricalEnergy(device, key, rgbStatus, rgbConfig.name ? `Consumption: ${rgbConfig.name}` : `RGB consumption: ${key}`, chan.id);
+                        if (ee) {
+                            channelsIds.push(ee.channel.id);
+                        }
+                        const ep = await this.ensureElectricalPower(device, key, rgbStatus, rgbConfig.name ? `Power: ${rgbConfig.name}` : `RGB power: ${key}`, chan.id);
+                        if (ep) {
+                            channelsIds.push(ep.channel.id);
+                        }
+                    }));
+                    const settled = await Promise.allSettled(tasks);
+                    const failed = settled.filter((r) => r.status === 'rejected').length;
+                    if (failed) {
+                        this.logger.warn(`${failed}/${ids.length} rgb component(s) failed for device=${device.id}`, {
+                            resource: device.id,
+                        });
+                    }
+                }
+                else if (type === String(devices_shelly_ng_constants_1.ComponentType.RGBW)) {
+                    const tasks = ids.map((key) => limit(async () => {
+                        const [rgbwConfig, rgbwStatus] = await (0, http_utils_1.retry)(() => (0, http_utils_1.withTimeout)(Promise.all([
+                            this.shellyRpcClientService.getRgbwConfig(host, key, { password }),
+                            this.shellyRpcClientService.getRgbwStatus(host, key, { password }),
+                        ]), this.timeoutSec * 1000, `RGBW.GetConfig+RGBW.GetStatus - ${key}`), { retries: 2, baseMs: 300, factor: 2 }).catch((err) => {
+                            this.logger.error(`Failed load for rgbw=${key} on device=${device.id}`, {
+                                resource: device.id,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                            throw err;
+                        });
+                        const rgbwMappingContext = {
+                            componentType: devices_shelly_ng_constants_1.ComponentType.RGBW,
+                            componentKey: key,
+                            deviceCategory: device.category,
+                            model: deviceInfo.model,
+                            profile: deviceInfo.profile ?? undefined,
+                        };
+                        const rgbwMapping = this.mappingLoaderService.findMatchingMapping(rgbwMappingContext);
+                        if (!rgbwMapping || rgbwMapping.channels.length === 0) {
+                            this.logger.warn(`No mapping found for rgbw component key=${key} device=${device.id} category=${device.category}. Using default LIGHT channel.`, {
+                                resource: device.id,
+                                componentKey: key,
+                                deviceCategory: device.category,
+                            });
+                            const chan = await this.ensureChannel(device, 'identifier', `rgbw:${key}`, devices_constants_1.ChannelCategory.LIGHT, rgbwConfig.name ?? `RGBW: ${key}`);
+                            channelsIds.push(chan.id);
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.ON, 'identifier', 'output', rgbwStatus.output);
+                            if (typeof rgbwStatus.brightness !== 'undefined') {
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.BRIGHTNESS, 'identifier', 'brightness', rgbwStatus.brightness);
+                            }
+                            if (typeof rgbwStatus.rgb !== 'undefined' &&
+                                Array.isArray(rgbwStatus.rgb) &&
+                                rgbwStatus.rgb.length === 3) {
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_RED, 'identifier', 'rgb:red', rgbwStatus.rgb[0]);
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_GREEN, 'identifier', 'rgb:green', rgbwStatus.rgb[1]);
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_BLUE, 'identifier', 'rgb:blue', rgbwStatus.rgb[2]);
+                            }
+                            if (typeof rgbwStatus.white !== 'undefined') {
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_WHITE, 'identifier', 'white', rgbwStatus.white);
+                            }
+                            return;
+                        }
+                        const rgbwChannelDef = rgbwMapping.channels[0];
+                        const rgbwCat = rgbwChannelDef.category;
+                        const rgbwChanName = rgbwConfig.name ??
+                            this.mappingLoaderService.interpolateTemplate(rgbwChannelDef.name ?? `RGBW: {key}`, rgbwMappingContext);
+                        const chan = await this.ensureChannel(device, 'identifier', `rgbw:${key}`, rgbwCat, rgbwChanName);
+                        channelsIds.push(chan.id);
+                        const onPropertyMapping = this.findPropertyMapping(rgbwChannelDef, devices_constants_1.PropertyCategory.ON);
+                        const transformedOutput = this.applyTransformer(onPropertyMapping, rgbwStatus.output, 'read');
+                        await this.ensureProperty(chan, devices_constants_1.PropertyCategory.ON, 'identifier', onPropertyMapping?.shellyProperty ?? 'output', transformedOutput, undefined, onPropertyMapping);
+                        if (typeof rgbwStatus.brightness !== 'undefined') {
+                            const brightnessPropertyMapping = this.findPropertyMapping(rgbwChannelDef, devices_constants_1.PropertyCategory.BRIGHTNESS);
+                            const transformedBrightness = this.applyTransformer(brightnessPropertyMapping, rgbwStatus.brightness, 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.BRIGHTNESS, 'identifier', brightnessPropertyMapping?.shellyProperty ?? 'brightness', transformedBrightness, undefined, brightnessPropertyMapping);
+                        }
+                        if (typeof rgbwStatus.rgb !== 'undefined' &&
+                            Array.isArray(rgbwStatus.rgb) &&
+                            rgbwStatus.rgb.length === 3) {
+                            const redPropertyMapping = this.findPropertyMapping(rgbwChannelDef, devices_constants_1.PropertyCategory.COLOR_RED);
+                            const transformedRed = this.applyTransformer(redPropertyMapping, rgbwStatus.rgb[0], 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_RED, 'identifier', redPropertyMapping?.shellyProperty ?? 'rgb:red', transformedRed, undefined, redPropertyMapping);
+                            const greenPropertyMapping = this.findPropertyMapping(rgbwChannelDef, devices_constants_1.PropertyCategory.COLOR_GREEN);
+                            const transformedGreen = this.applyTransformer(greenPropertyMapping, rgbwStatus.rgb[1], 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_GREEN, 'identifier', greenPropertyMapping?.shellyProperty ?? 'rgb:green', transformedGreen, undefined, greenPropertyMapping);
+                            const bluePropertyMapping = this.findPropertyMapping(rgbwChannelDef, devices_constants_1.PropertyCategory.COLOR_BLUE);
+                            const transformedBlue = this.applyTransformer(bluePropertyMapping, rgbwStatus.rgb[2], 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_BLUE, 'identifier', bluePropertyMapping?.shellyProperty ?? 'rgb:blue', transformedBlue, undefined, bluePropertyMapping);
+                        }
+                        if (typeof rgbwStatus.white !== 'undefined') {
+                            const whitePropertyMapping = this.findPropertyMapping(rgbwChannelDef, devices_constants_1.PropertyCategory.COLOR_WHITE);
+                            const transformedWhite = this.applyTransformer(whitePropertyMapping, rgbwStatus.white, 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_WHITE, 'identifier', whitePropertyMapping?.shellyProperty ?? 'white', transformedWhite, undefined, whitePropertyMapping);
+                        }
+                        const ee = await this.ensureElectricalEnergy(device, key, rgbwStatus, rgbwConfig.name ? `Consumption: ${rgbwConfig.name}` : `RGBW consumption: ${key}`, chan.id);
+                        if (ee) {
+                            channelsIds.push(ee.channel.id);
+                        }
+                        const ep = await this.ensureElectricalPower(device, key, rgbwStatus, rgbwConfig.name ? `Power: ${rgbwConfig.name}` : `RGBW power: ${key}`, chan.id);
+                        if (ep) {
+                            channelsIds.push(ep.channel.id);
+                        }
+                    }));
+                    const settled = await Promise.allSettled(tasks);
+                    const failed = settled.filter((r) => r.status === 'rejected').length;
+                    if (failed) {
+                        this.logger.warn(`${failed}/${ids.length} rgbw component(s) failed for device=${device.id}`, {
+                            resource: device.id,
+                        });
+                    }
+                }
+                else if (type === String(devices_shelly_ng_constants_1.ComponentType.CCT)) {
+                    const tasks = ids.map((key) => limit(async () => {
+                        const [cctConfig, cctStatus] = await (0, http_utils_1.retry)(() => (0, http_utils_1.withTimeout)(Promise.all([
+                            this.shellyRpcClientService.getCctConfig(host, key, { password }),
+                            this.shellyRpcClientService.getCctStatus(host, key, { password }),
+                        ]), this.timeoutSec * 1000, `CCT.GetConfig+CCT.GetStatus - ${key}`), { retries: 2, baseMs: 300, factor: 2 }).catch((err) => {
+                            this.logger.error(`Failed load for cct=${key} on device=${device.id}`, {
+                                resource: device.id,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                            throw err;
+                        });
+                        const cctMappingContext = {
+                            componentType: devices_shelly_ng_constants_1.ComponentType.CCT,
+                            componentKey: key,
+                            deviceCategory: device.category,
+                            model: deviceInfo.model,
+                            profile: deviceInfo.profile ?? undefined,
+                        };
+                        const cctMapping = this.mappingLoaderService.findMatchingMapping(cctMappingContext);
+                        if (!cctMapping || cctMapping.channels.length === 0) {
+                            this.logger.warn(`No mapping found for cct component key=${key} device=${device.id} category=${device.category}. Using default LIGHT channel.`, {
+                                resource: device.id,
+                                componentKey: key,
+                                deviceCategory: device.category,
+                            });
+                            const chan = await this.ensureChannel(device, 'identifier', `cct:${key}`, devices_constants_1.ChannelCategory.LIGHT, cctConfig.name ?? `CCT: ${key}`);
+                            channelsIds.push(chan.id);
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.ON, 'identifier', 'output', cctStatus.output);
+                            if (typeof cctStatus.brightness !== 'undefined') {
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.BRIGHTNESS, 'identifier', 'brightness', cctStatus.brightness);
+                            }
+                            if (typeof cctStatus.ct !== 'undefined') {
+                                await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_TEMPERATURE, 'identifier', 'temperature', cctStatus.ct);
+                            }
+                            return;
+                        }
+                        const cctChannelDef = cctMapping.channels[0];
+                        const cctCat = cctChannelDef.category;
+                        const cctChanName = cctConfig.name ??
+                            this.mappingLoaderService.interpolateTemplate(cctChannelDef.name ?? `CCT: {key}`, cctMappingContext);
+                        const chan = await this.ensureChannel(device, 'identifier', `cct:${key}`, cctCat, cctChanName);
+                        channelsIds.push(chan.id);
+                        const onPropertyMapping = this.findPropertyMapping(cctChannelDef, devices_constants_1.PropertyCategory.ON);
+                        const transformedOutput = this.applyTransformer(onPropertyMapping, cctStatus.output, 'read');
+                        await this.ensureProperty(chan, devices_constants_1.PropertyCategory.ON, 'identifier', onPropertyMapping?.shellyProperty ?? 'output', transformedOutput, undefined, onPropertyMapping);
+                        if (typeof cctStatus.brightness !== 'undefined') {
+                            const brightnessPropertyMapping = this.findPropertyMapping(cctChannelDef, devices_constants_1.PropertyCategory.BRIGHTNESS);
+                            const transformedBrightness = this.applyTransformer(brightnessPropertyMapping, cctStatus.brightness, 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.BRIGHTNESS, 'identifier', brightnessPropertyMapping?.shellyProperty ?? 'brightness', transformedBrightness, undefined, brightnessPropertyMapping);
+                        }
+                        if (typeof cctStatus.ct !== 'undefined') {
+                            const ctPropertyMapping = this.findPropertyMapping(cctChannelDef, devices_constants_1.PropertyCategory.COLOR_TEMPERATURE);
+                            const transformedCt = this.applyTransformer(ctPropertyMapping, cctStatus.ct, 'read');
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.COLOR_TEMPERATURE, 'identifier', ctPropertyMapping?.shellyProperty ?? 'temperature', transformedCt, undefined, ctPropertyMapping);
+                        }
+                        const ee = await this.ensureElectricalEnergy(device, key, cctStatus, cctConfig.name ? `Consumption: ${cctConfig.name}` : `CCT consumption: ${key}`, chan.id);
+                        if (ee) {
+                            channelsIds.push(ee.channel.id);
+                        }
+                        const ep = await this.ensureElectricalPower(device, key, cctStatus, cctConfig.name ? `Power: ${cctConfig.name}` : `CCT power: ${key}`, chan.id);
+                        if (ep) {
+                            channelsIds.push(ep.channel.id);
+                        }
+                    }));
+                    const settled = await Promise.allSettled(tasks);
+                    const failed = settled.filter((r) => r.status === 'rejected').length;
+                    if (failed) {
+                        this.logger.warn(`${failed}/${ids.length} cct component(s) failed for device=${device.id}`, {
+                            resource: device.id,
+                        });
+                    }
+                }
+                else if (type === String(devices_shelly_ng_constants_1.ComponentType.INPUT)) {
+                    const tasks = ids.map((key) => limit(async () => {
+                        await (0, http_utils_1.retry)(() => (0, http_utils_1.withTimeout)(Promise.all([
+                            this.shellyRpcClientService.getInputConfig(host, key, { password }),
+                            this.shellyRpcClientService.getInputStatus(host, key, { password }),
+                        ]), this.timeoutSec * 1000, `Input.GetConfig+Input.GetStatus - ${key}`), { retries: 2, baseMs: 300, factor: 2 }).catch((err) => {
+                            this.logger.error(`Failed load for input=${key} on device=${device.id}`, {
+                                resource: device.id,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                            throw err;
+                        });
+                    }));
+                    const settled = await Promise.allSettled(tasks);
+                    const failed = settled.filter((r) => r.status === 'rejected').length;
+                    if (failed) {
+                        this.logger.warn(`${failed}/${ids.length} input component(s) failed for device=${device.id}`, {
+                            resource: device.id,
+                        });
+                    }
+                }
+                else if (type === String(devices_shelly_ng_constants_1.ComponentType.DEVICE_POWER)) {
+                    for (const key of ids) {
+                        let devicePowerStatus;
+                        try {
+                            devicePowerStatus = await this.shellyRpcClientService.getDevicePowerStatus(host, key, {
+                                password: device.password,
+                            });
+                        }
+                        catch (error) {
+                            const err = error;
+                            this.logger.error(`Failed to load device power status for device=${device.id} and devicePower=${key}`, {
+                                resource: device.id,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                            continue;
+                        }
+                        if (typeof devicePowerStatus.battery !== 'undefined') {
+                            const batteryMappingContext = {
+                                componentType: devices_shelly_ng_constants_1.ComponentType.DEVICE_POWER,
+                                componentKey: key,
+                                deviceCategory: device.category,
+                                model: deviceInfo.model,
+                                profile: deviceInfo.profile ?? undefined,
+                            };
+                            const batteryMapping = this.mappingLoaderService.findMatchingMapping(batteryMappingContext);
+                            if (!batteryMapping || batteryMapping.channels.length === 0) {
+                                this.logger.warn(`No mapping found for device power component key=${key} device=${device.id} category=${device.category}. Using default BATTERY channel.`, {
+                                    resource: device.id,
+                                    componentKey: key,
+                                    deviceCategory: device.category,
+                                });
+                                const battery = await this.ensureChannel(device, 'identifier', `devicePower:${key}`, devices_constants_1.ChannelCategory.BATTERY, `Device power: ${key}`);
+                                channelsIds.push(battery.id);
+                                await this.ensureProperty(battery, devices_constants_1.PropertyCategory.PERCENTAGE, 'identifier', 'battery', devicePowerStatus.battery.percent);
+                                continue;
+                            }
+                            const batteryChannelDef = batteryMapping.channels[0];
+                            const batteryCat = batteryChannelDef.category;
+                            const batteryChanName = this.mappingLoaderService.interpolateTemplate(batteryChannelDef.name ?? `Battery: {key}`, batteryMappingContext);
+                            const battery = await this.ensureChannel(device, 'identifier', `devicePower:${key}`, batteryCat, batteryChanName);
+                            channelsIds.push(battery.id);
+                            const percentagePropertyMapping = this.findPropertyMapping(batteryChannelDef, devices_constants_1.PropertyCategory.PERCENTAGE);
+                            const transformedPercentage = this.applyTransformer(percentagePropertyMapping, devicePowerStatus.battery.percent, 'read');
+                            await this.ensureProperty(battery, devices_constants_1.PropertyCategory.PERCENTAGE, 'identifier', percentagePropertyMapping?.shellyProperty ?? 'battery', transformedPercentage, undefined, percentagePropertyMapping);
+                            if (batteryChannelDef.derivedProperties) {
+                                for (const derivedProp of batteryChannelDef.derivedProperties) {
+                                    const sourceProp = await this.channelsPropertiesService.findOneBy('category', derivedProp.sourceProperty, battery.id);
+                                    if (sourceProp && sourceProp.value?.value !== null && sourceProp.value?.value !== undefined) {
+                                        const derivedValue = this.applyDerivation(derivedProp.derivationName
+                                            ? this.mappingLoaderService.getDerivation(derivedProp.derivationName)?.rule
+                                            : derivedProp.inlineDerivation, sourceProp.value?.value);
+                                        if (derivedValue !== undefined) {
+                                            await this.ensureProperty(battery, derivedProp.identifier, 'category', derivedProp.identifier, derivedValue, {
+                                                data_type: derivedProp.dataType,
+                                                format: derivedProp.format,
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (type === String(devices_shelly_ng_constants_1.ComponentType.HUMIDITY)) {
+                    const tasks = ids.map((key) => limit(async () => {
+                        const [humidityConfig, humidityStatus] = await (0, http_utils_1.retry)(() => (0, http_utils_1.withTimeout)(Promise.all([
+                            this.shellyRpcClientService.getHumidityConfig(host, key, { password }),
+                            this.shellyRpcClientService.getHumidityStatus(host, key, { password }),
+                        ]), this.timeoutSec * 1000, `Humidity.GetConfig+Humidity.GetStatus - ${key}`), { retries: 2, baseMs: 300, factor: 2 }).catch((err) => {
+                            this.logger.error(`Failed load for humidity=${key} on device=${device.id}`, {
+                                resource: device.id,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                            throw err;
+                        });
+                        const humidityMappingContext = {
+                            componentType: devices_shelly_ng_constants_1.ComponentType.HUMIDITY,
+                            componentKey: key,
+                            deviceCategory: device.category,
+                            model: deviceInfo.model,
+                            profile: deviceInfo.profile ?? undefined,
+                        };
+                        const humidityMapping = this.mappingLoaderService.findMatchingMapping(humidityMappingContext);
+                        if (!humidityMapping || humidityMapping.channels.length === 0) {
+                            this.logger.warn(`No mapping found for humidity component key=${key} device=${device.id} category=${device.category}. Using default HUMIDITY channel.`, {
+                                resource: device.id,
+                                componentKey: key,
+                                deviceCategory: device.category,
+                            });
+                            const chan = await this.ensureChannel(device, 'identifier', `humidity:${key}`, devices_constants_1.ChannelCategory.HUMIDITY, humidityConfig.name ?? `Humidity: ${key}`);
+                            channelsIds.push(chan.id);
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.HUMIDITY, 'identifier', 'rh', humidityStatus.rh);
+                            return;
+                        }
+                        const humidityChannelDef = humidityMapping.channels[0];
+                        const humidityCat = humidityChannelDef.category;
+                        const humidityChanName = humidityConfig.name ??
+                            this.mappingLoaderService.interpolateTemplate(humidityChannelDef.name ?? `Humidity: {key}`, humidityMappingContext);
+                        const chan = await this.ensureChannel(device, 'identifier', `humidity:${key}`, humidityCat, humidityChanName);
+                        channelsIds.push(chan.id);
+                        const humidityPropertyMapping = this.findPropertyMapping(humidityChannelDef, devices_constants_1.PropertyCategory.HUMIDITY);
+                        const transformedHumidity = this.applyTransformer(humidityPropertyMapping, humidityStatus.rh, 'read');
+                        await this.ensureProperty(chan, devices_constants_1.PropertyCategory.HUMIDITY, 'identifier', humidityPropertyMapping?.shellyProperty ?? 'rh', transformedHumidity, undefined, humidityPropertyMapping);
+                    }));
+                    const settled = await Promise.allSettled(tasks);
+                    const failed = settled.filter((r) => r.status === 'rejected').length;
+                    if (failed) {
+                        this.logger.warn(`${failed}/${ids.length} humidity component(s) failed for device=${device.id}`, {
+                            resource: device.id,
+                        });
+                    }
+                }
+                else if (type === String(devices_shelly_ng_constants_1.ComponentType.TEMPERATURE)) {
+                    const tasks = ids.map((key) => limit(async () => {
+                        const [temperatureConfig, temperatureStatus] = await (0, http_utils_1.retry)(() => (0, http_utils_1.withTimeout)(Promise.all([
+                            this.shellyRpcClientService.getTemperatureConfig(host, key, { password }),
+                            this.shellyRpcClientService.getTemperatureStatus(host, key, { password }),
+                        ]), this.timeoutSec * 1000, `Temperature.GetConfig+Temperature.GetStatus - ${key}`), { retries: 2, baseMs: 300, factor: 2 }).catch((err) => {
+                            this.logger.error(`Failed load for temperature=${key} on device=${device.id}`, {
+                                resource: device.id,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                            throw err;
+                        });
+                        const temperatureMappingContext = {
+                            componentType: devices_shelly_ng_constants_1.ComponentType.TEMPERATURE,
+                            componentKey: key,
+                            deviceCategory: device.category,
+                            model: deviceInfo.model,
+                            profile: deviceInfo.profile ?? undefined,
+                        };
+                        const temperatureMapping = this.mappingLoaderService.findMatchingMapping(temperatureMappingContext);
+                        if (!temperatureMapping || temperatureMapping.channels.length === 0) {
+                            this.logger.warn(`No mapping found for temperature component key=${key} device=${device.id} category=${device.category}. Using default TEMPERATURE channel.`, {
+                                resource: device.id,
+                                componentKey: key,
+                                deviceCategory: device.category,
+                            });
+                            const chan = await this.ensureChannel(device, 'identifier', `temperature:${key}`, devices_constants_1.ChannelCategory.TEMPERATURE, temperatureConfig.name ?? `Temperature: ${key}`);
+                            channelsIds.push(chan.id);
+                            await this.ensureProperty(chan, devices_constants_1.PropertyCategory.TEMPERATURE, 'identifier', 'tC', temperatureStatus.tC);
+                            return;
+                        }
+                        const temperatureChannelDef = temperatureMapping.channels[0];
+                        const temperatureCat = temperatureChannelDef.category;
+                        const temperatureChanName = temperatureConfig.name ??
+                            this.mappingLoaderService.interpolateTemplate(temperatureChannelDef.name ?? `Temperature: {key}`, temperatureMappingContext);
+                        const chan = await this.ensureChannel(device, 'identifier', `temperature:${key}`, temperatureCat, temperatureChanName);
+                        channelsIds.push(chan.id);
+                        const temperaturePropertyMapping = this.findPropertyMapping(temperatureChannelDef, devices_constants_1.PropertyCategory.TEMPERATURE);
+                        const transformedTemperature = this.applyTransformer(temperaturePropertyMapping, temperatureStatus.tC, 'read');
+                        await this.ensureProperty(chan, devices_constants_1.PropertyCategory.TEMPERATURE, 'identifier', temperaturePropertyMapping?.shellyProperty ?? 'tC', transformedTemperature, undefined, temperaturePropertyMapping);
+                    }));
+                    const settled = await Promise.allSettled(tasks);
+                    const failed = settled.filter((r) => r.status === 'rejected').length;
+                    if (failed) {
+                        this.logger.warn(`${failed}/${ids.length} temperature component(s) failed for device=${device.id}`, {
+                            resource: device.id,
+                        });
+                    }
+                }
+                else if (type === String(devices_shelly_ng_constants_1.ComponentType.PM1)) {
+                    const tasks = ids.map((key) => limit(async () => {
+                        const [pm1Config, pm1Status] = await (0, http_utils_1.retry)(() => (0, http_utils_1.withTimeout)(Promise.all([
+                            this.shellyRpcClientService.getPm1Config(host, key, { password }),
+                            this.shellyRpcClientService.getPm1Status(host, key, { password }),
+                        ]), this.timeoutSec * 1000, `Pm1.GetConfig+Pm1.GetStatus - ${key}`), { retries: 2, baseMs: 300, factor: 2 }).catch((err) => {
+                            this.logger.error(`Failed load for pm1=${key} on device=${device.id}`, {
+                                resource: device.id,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                            throw err;
+                        });
+                        const eeResult = await this.ensureElectricalEnergy(device, key, pm1Status, pm1Config.name ?? undefined);
+                        if (eeResult) {
+                            channelsIds.push(eeResult.channel.id);
+                        }
+                        const epResult = await this.ensureElectricalPower(device, key, pm1Status, pm1Config.name ?? undefined);
+                        if (epResult) {
+                            channelsIds.push(epResult.channel.id);
+                        }
+                    }));
+                    const settled = await Promise.allSettled(tasks);
+                    const failed = settled.filter((r) => r.status === 'rejected').length;
+                    if (failed) {
+                        this.logger.warn(`${failed}/${ids.length} pm1 component(s) failed for device=${device.id}`, {
+                            resource: device.id,
+                        });
+                    }
+                }
+            }
+            const allChannels = await this.channelsService.findAll(device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            for (const channel of allChannels) {
+                if (!channelsIds.includes(channel.id)) {
+                    try {
+                        if (this.defaultManager) {
+                            await this.channelsService.remove(channel.id, this.defaultManager);
+                        }
+                        else {
+                            await this.channelsService.remove(channel.id);
+                        }
+                    }
+                    catch (error) {
+                        const err = error;
+                        this.logger.warn(`Failed to remove stale channel id=${channel.id}: ${err.message}`, {
+                            resource: device.id,
+                        });
+                    }
+                }
+            }
+            return device;
+        });
+    }
+    async ensureChannel(device, column, identifierOrCategory, category, name, parent) {
+        if (column === 'category') {
+            if (identifierOrCategory !== category) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgException(`Provided channel category is mismatched with searched: ${category} vs ${identifierOrCategory}`);
+            }
+        }
+        let channel = await this.channelsService.findOneBy(column, identifierOrCategory, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+        if (channel === null) {
+            const channelSpec = channels_1.channelsSchema[category];
+            if (!channelSpec || typeof channelSpec !== 'object') {
+                this.logger.warn(`Missing or invalid schema for channel category=${category}. Falling back to minimal channel`, {
+                    resource: device.id,
+                });
+                if (this.strictSchema) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgException('Failed to load specification for channel category');
+                }
+            }
+            channel = await this.channelsService.create({
+                type: devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE,
+                category,
+                identifier: column === 'identifier' ? identifierOrCategory : null,
+                name,
+                device: device.id,
+                parent: parent ?? null,
+            });
+        }
+        else {
+            channel = await this.channelsService.update(channel.id, {
+                type: devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE,
+                category,
+                identifier: column === 'identifier' ? identifierOrCategory : channel.identifier,
+                parent: parent ?? null,
+            });
+        }
+        return channel;
+    }
+    applyTransformer(propertyMapping, shellyValue, direction = 'read') {
+        if (!propertyMapping) {
+            return shellyValue;
+        }
+        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 shellyValue;
+        }
+        if (direction === 'read' && !transformer.canRead()) {
+            this.logger.warn(`Transformer does not support read operation for property mapping`);
+            return shellyValue;
+        }
+        if (direction === 'write' && !transformer.canWrite()) {
+            this.logger.warn(`Transformer does not support write operation for property mapping`);
+            return shellyValue;
+        }
+        try {
+            return direction === 'read' ? transformer.read(shellyValue) : transformer.write(shellyValue);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to apply transformer: ${error instanceof Error ? error.message : String(error)}`);
+            return shellyValue;
+        }
+    }
+    findPropertyMapping(channelDef, propertyIdentifier) {
+        return channelDef.properties?.find((p) => p.panel.identifier === propertyIdentifier);
+    }
+    applyDerivation(derivation, sourceValue) {
+        if (!derivation) {
+            return undefined;
+        }
+        try {
+            switch (derivation.type) {
+                case 'threshold': {
+                    if (typeof sourceValue !== 'number') {
+                        return undefined;
+                    }
+                    for (const threshold of derivation.thresholds) {
+                        const min = threshold.min ?? Number.NEGATIVE_INFINITY;
+                        const max = threshold.max ?? Number.POSITIVE_INFINITY;
+                        if (sourceValue >= min && sourceValue <= max) {
+                            return threshold.value;
+                        }
+                    }
+                    return undefined;
+                }
+                case 'boolean_map': {
+                    const boolValue = Boolean(sourceValue);
+                    return boolValue ? derivation.true_value : derivation.false_value;
+                }
+                case 'position_status': {
+                    if (typeof sourceValue !== 'number') {
+                        return undefined;
+                    }
+                    if (sourceValue === 0) {
+                        return derivation.closed_value;
+                    }
+                    else if (sourceValue === 100) {
+                        return derivation.opened_value;
+                    }
+                    else {
+                        return derivation.partial_value ?? derivation.closed_value;
+                    }
+                }
+                default:
+                    return undefined;
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to apply derivation: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    }
+    async ensureProperty(channel, category, column, identifierOrCategory, value, options, propertyMapping) {
+        if (column === 'category') {
+            if (identifierOrCategory !== category) {
+                throw new devices_shelly_ng_exceptions_1.DevicesShellyNgException(`Provided channel property category is mismatched with searched: ${category} vs ${identifierOrCategory}`);
+            }
+        }
+        const channelSpec = channels_1.channelsSchema[channel.category];
+        const schemaPropertySpec = this.getSchemaPropertySpec(channelSpec, category);
+        const mappingPropertySpec = this.getMappingPropertySpec(propertyMapping);
+        const resolvedFormat = options?.format ?? mappingPropertySpec?.format ?? schemaPropertySpec?.format ?? null;
+        const normalizedValue = this.normalizeValue(value, { format: resolvedFormat });
+        const inferredDataType = typeof normalizedValue === 'number'
+            ? devices_constants_1.DataTypeType.FLOAT
+            : typeof normalizedValue === 'boolean'
+                ? devices_constants_1.DataTypeType.BOOL
+                : typeof normalizedValue === 'string'
+                    ? devices_constants_1.DataTypeType.STRING
+                    : devices_constants_1.DataTypeType.UNKNOWN;
+        const resolvedDataType = options?.data_type ?? mappingPropertySpec?.data_type ?? schemaPropertySpec?.data_type ?? inferredDataType;
+        const resolvedPermissions = options?.permissions ??
+            mappingPropertySpec?.permissions ??
+            schemaPropertySpec?.permissions ?? [devices_constants_1.PermissionType.READ_WRITE];
+        let prop = await this.channelsPropertiesService.findOneBy(column, identifierOrCategory, channel.id);
+        if (prop === null) {
+            if (!channelSpec || typeof channelSpec !== 'object') {
+                this.logger.warn(`Missing or invalid schema for channel category=${channel.category}. Falling back to minimal channel`);
+                if (this.strictSchema) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgException('Failed to load specification for channel category');
+                }
+            }
+            if (!schemaPropertySpec && !mappingPropertySpec && !options) {
+                this.logger.warn(`Missing or invalid schema for property category=${category}. Falling back to minimal property.`);
+                if (this.strictSchema) {
+                    throw new devices_shelly_ng_exceptions_1.DevicesShellyNgException('Failed to load specification for channel property category');
+                }
+            }
+            prop = await this.channelsPropertiesService.create(channel.id, {
+                ...{
+                    permissions: resolvedPermissions,
+                    data_type: resolvedDataType,
+                    format: resolvedFormat ?? null,
+                },
+                type: devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE,
+                category,
+                identifier: column === 'identifier' ? identifierOrCategory : null,
+                value: normalizedValue,
+                ...options,
+            });
+        }
+        else {
+            prop = await this.channelsPropertiesService.update(prop.id, {
+                type: devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE,
+                category,
+                identifier: column === 'identifier' ? identifierOrCategory : null,
+                value: normalizedValue,
+                permissions: resolvedPermissions,
+                data_type: resolvedDataType,
+                format: resolvedFormat ?? null,
+            });
+        }
+        return prop;
+    }
+    getSchemaPropertySpec(channelSpec, category) {
+        if (!channelSpec || typeof channelSpec !== 'object') {
+            return null;
+        }
+        const properties = channelSpec.properties;
+        const rawSpec = properties?.[category];
+        if (!rawSpec || typeof rawSpec !== 'object') {
+            return null;
+        }
+        if ('data_type' in rawSpec) {
+            const typed = rawSpec;
+            return {
+                permissions: typed.permissions,
+                data_type: typed.data_type,
+                unit: typed.unit ?? null,
+                format: typed.format ?? null,
+            };
+        }
+        if ('data_types' in rawSpec && Array.isArray(rawSpec.data_types)) {
+            const [primaryVariant] = rawSpec.data_types;
+            if (primaryVariant) {
+                return {
+                    permissions: rawSpec.permissions,
+                    data_type: primaryVariant.data_type,
+                    unit: primaryVariant.unit ?? null,
+                    format: primaryVariant.format ?? null,
+                };
+            }
+        }
+        return null;
+    }
+    getMappingPropertySpec(propertyMapping) {
+        if (!propertyMapping) {
+            return null;
+        }
+        return {
+            permissions: [propertyMapping.panel.settable ? devices_constants_1.PermissionType.READ_WRITE : devices_constants_1.PermissionType.READ_ONLY],
+            data_type: propertyMapping.panel.dataType,
+            unit: propertyMapping.panel.unit ?? null,
+            format: propertyMapping.panel.format ?? null,
+        };
+    }
+    normalizeValue(value, propertySpec, options) {
+        if (typeof value !== 'number') {
+            return value;
+        }
+        const range = this.getNumericRange(options?.format ?? propertySpec?.format);
+        if (range) {
+            return (0, transform_utils_1.clampNumber)(value, range.min, range.max);
+        }
+        return value;
+    }
+    getNumericRange(format) {
+        if (!Array.isArray(format)) {
+            return null;
+        }
+        if (format.length === 2 && format.every((n) => typeof n === 'number' && Number.isFinite(n))) {
+            return { min: Number(format[0]), max: Number(format[1]) };
+        }
+        return null;
+    }
+    async ensureElectricalEnergy(device, key, status, name, parent) {
+        if (typeof status.aenergy !== 'undefined') {
+            const electricalEnergy = await this.ensureChannel(device, 'identifier', `energy:${key}`, devices_constants_1.ChannelCategory.ELECTRICAL_ENERGY, name ?? `Consumption: ${key}`, parent);
+            const consumption = await this.ensureProperty(electricalEnergy, devices_constants_1.PropertyCategory.CONSUMPTION, 'identifier', 'aenergy', (0, transform_utils_2.toEnergy)(status.aenergy));
+            return {
+                channel: electricalEnergy,
+                properties: [consumption],
+            };
+        }
+        return null;
+    }
+    async ensureElectricalPower(device, key, status, name, parent) {
+        if (typeof status.apower !== 'undefined') {
+            const electricalPower = await this.ensureChannel(device, 'identifier', `power:${key}`, devices_constants_1.ChannelCategory.ELECTRICAL_POWER, name ?? `Power: ${key}`, parent);
+            const power = await this.ensureProperty(electricalPower, devices_constants_1.PropertyCategory.POWER, 'identifier', 'apower', status.apower);
+            const properties = [power];
+            if (typeof status.voltage !== 'undefined') {
+                properties.push(await this.ensureProperty(electricalPower, devices_constants_1.PropertyCategory.VOLTAGE, 'identifier', 'voltage', status.voltage));
+            }
+            if (typeof status.current !== 'undefined') {
+                properties.push(await this.ensureProperty(electricalPower, devices_constants_1.PropertyCategory.CURRENT, 'identifier', 'current', status.current));
+            }
+            return {
+                channel: electricalPower,
+                properties,
+            };
+        }
+        return null;
+    }
+    getSpecification(model) {
+        for (const DESCRIPTOR of Object.values(devices_shelly_ng_constants_1.DESCRIPTORS)) {
+            if (DESCRIPTOR.models.includes(model.toUpperCase())) {
+                return DESCRIPTOR;
+            }
+        }
+        return null;
+    }
+};
+exports.DeviceManagerService = DeviceManagerService;
+exports.DeviceManagerService = DeviceManagerService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [shelly_rpc_client_service_1.ShellyRpcClientService,
+        devices_service_1.DevicesService,
+        channels_service_1.ChannelsService,
+        channels_properties_service_1.ChannelsPropertiesService,
+        mappings_1.MappingLoaderService,
+        mappings_1.TransformerRegistry,
+        mappings_1.PropertyMappingStorageService,
+        device_provision_queue_service_1.DeviceProvisionQueueService,
+        device_address_service_1.DeviceAddressService])
+], DeviceManagerService);
+//# sourceMappingURL=device-manager.service.js.map