@fastybird/smart-panel-backend 1.1.0-alpha.4 → 1.1.0-alpha.41

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

@@ -99,6 +99,7 @@ let DeviceManagerService = class DeviceManagerService {
                 await this.deviceAddressService.setHasEthernet(device.id, specHasEthernet);
             }
             const channelsIds = [];
+            let hasComponentFailures = false;
             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');
@@ -189,6 +190,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} switch component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -276,6 +278,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} cover component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -342,6 +345,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} light component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -426,6 +430,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} rgb component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -520,6 +525,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} rgbw component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -594,6 +600,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} cct component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -601,21 +608,138 @@ let DeviceManagerService = class DeviceManagerService {
                 }
                 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) => {
+                        let inputConfig;
+                        let inputStatus;
+                        try {
+                            [inputConfig, inputStatus] = 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) {
+                            const error = err;
                             this.logger.error(`Failed load for input=${key} on device=${device.id}`, {
                                 resource: device.id,
-                                message: err.message,
-                                stack: err.stack,
+                                message: error.message,
+                                stack: error.stack,
                             });
+                            const existing = await this.channelsService.findOneBy('identifier', `input:${key}`, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+                            if (existing) {
+                                channelsIds.push(existing.id);
+                            }
                             throw err;
-                        });
+                        }
+                        const inputMode = inputConfig?.type ?? 'button';
+                        const mappingContext = {
+                            componentType: devices_shelly_ng_constants_1.ComponentType.INPUT,
+                            componentKey: key,
+                            deviceCategory: device.category,
+                            inputMode,
+                            model: deviceInfo.model,
+                            profile: deviceInfo.profile ?? undefined,
+                        };
+                        const mapping = this.mappingLoaderService.findMatchingMapping(mappingContext);
+                        let channelCategory = devices_constants_1.ChannelCategory.BUTTON;
+                        let defaultChannelName = `Button: ${key}`;
+                        if (mapping && mapping.channels.length > 0) {
+                            channelCategory = mapping.channels[0].category;
+                            defaultChannelName = this.mappingLoaderService.interpolateTemplate(mapping.channels[0].name ?? `Input: {key}`, mappingContext);
+                        }
+                        else {
+                            if (inputMode === 'switch') {
+                                channelCategory = devices_constants_1.ChannelCategory.BINARY_INPUT;
+                                defaultChannelName = `Switch Input: ${key}`;
+                            }
+                            else if (inputMode === 'analog' || inputMode === 'count') {
+                                channelCategory = devices_constants_1.ChannelCategory.ANALOG_INPUT;
+                                defaultChannelName = inputMode === 'count' ? `Counter: ${key}` : `Analog Input: ${key}`;
+                            }
+                        }
+                        const channelName = inputConfig.name && inputConfig.name.trim() !== '' ? inputConfig.name : defaultChannelName;
+                        const channel = await this.ensureChannel(device, 'identifier', `input:${key}`, channelCategory, channelName);
+                        channelsIds.push(channel.id);
+                        const existingProps = await this.channelsPropertiesService.findAll(channel.id);
+                        const validCategories = channelCategory === devices_constants_1.ChannelCategory.BUTTON
+                            ? [devices_constants_1.PropertyCategory.EVENT, devices_constants_1.PropertyCategory.DETECTED, devices_constants_1.PropertyCategory.ACTIVE]
+                            : channelCategory === devices_constants_1.ChannelCategory.BINARY_INPUT
+                                ? [devices_constants_1.PropertyCategory.STATE, devices_constants_1.PropertyCategory.ACTIVE]
+                                : [devices_constants_1.PropertyCategory.VALUE, devices_constants_1.PropertyCategory.UNIT, devices_constants_1.PropertyCategory.ACTIVE];
+                        for (const prop of existingProps) {
+                            if (!validCategories.includes(prop.category)) {
+                                try {
+                                    await this.channelsPropertiesService.remove(prop.id);
+                                }
+                                catch (error) {
+                                    if (error?.name === 'EntityNotFoundError' ||
+                                        error?.status === 404) {
+                                    }
+                                    else {
+                                        throw error;
+                                    }
+                                }
+                            }
+                        }
+                        const isActive = inputConfig.enable !== false && (!inputStatus.errors || inputStatus.errors.length === 0);
+                        if (channelCategory === devices_constants_1.ChannelCategory.BUTTON) {
+                            await this.ensureProperty(channel, devices_constants_1.PropertyCategory.EVENT, 'category', devices_constants_1.PropertyCategory.EVENT, undefined, {
+                                data_type: devices_constants_1.DataTypeType.ENUM,
+                                permissions: [devices_constants_1.PermissionType.EVENT_ONLY],
+                                format: ['press', 'double_press', 'triple_press', 'long_press', 'down', 'up'],
+                            });
+                            await this.ensureProperty(channel, devices_constants_1.PropertyCategory.DETECTED, 'category', devices_constants_1.PropertyCategory.DETECTED, typeof inputStatus.state === 'boolean' ? inputStatus.state : false, {
+                                data_type: devices_constants_1.DataTypeType.BOOL,
+                                permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                            });
+                            await this.ensureProperty(channel, devices_constants_1.PropertyCategory.ACTIVE, 'category', devices_constants_1.PropertyCategory.ACTIVE, isActive, {
+                                data_type: devices_constants_1.DataTypeType.BOOL,
+                                permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                            });
+                        }
+                        else if (channelCategory === devices_constants_1.ChannelCategory.BINARY_INPUT) {
+                            await this.ensureProperty(channel, devices_constants_1.PropertyCategory.STATE, 'category', devices_constants_1.PropertyCategory.STATE, Boolean(inputStatus.state), {
+                                data_type: devices_constants_1.DataTypeType.BOOL,
+                                permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                            });
+                            await this.ensureProperty(channel, devices_constants_1.PropertyCategory.ACTIVE, 'category', devices_constants_1.PropertyCategory.ACTIVE, isActive, {
+                                data_type: devices_constants_1.DataTypeType.BOOL,
+                                permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                            });
+                        }
+                        else if (channelCategory === devices_constants_1.ChannelCategory.ANALOG_INPUT) {
+                            const hasExtendedCount = inputMode === 'count' && typeof inputStatus.counts?.xtotal === 'number';
+                            const hasExtendedPercent = inputMode === 'analog' && typeof inputStatus.xpercent === 'number';
+                            const analogValue = inputMode === 'count'
+                                ? hasExtendedCount
+                                    ? inputStatus.counts.xtotal
+                                    : (inputStatus.counts?.total ?? 0)
+                                : hasExtendedPercent
+                                    ? inputStatus.xpercent
+                                    : (inputStatus.percent ?? 0);
+                            const unitValue = inputMode === 'count'
+                                ? hasExtendedCount
+                                    ? inputConfig.xcounts?.unit || 'counts'
+                                    : 'counts'
+                                : hasExtendedPercent
+                                    ? inputConfig.xpercent?.unit || '%'
+                                    : '%';
+                            await this.ensureProperty(channel, devices_constants_1.PropertyCategory.VALUE, 'category', devices_constants_1.PropertyCategory.VALUE, analogValue, {
+                                data_type: devices_constants_1.DataTypeType.FLOAT,
+                                permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                            });
+                            await this.ensureProperty(channel, devices_constants_1.PropertyCategory.UNIT, 'category', devices_constants_1.PropertyCategory.UNIT, unitValue, {
+                                data_type: devices_constants_1.DataTypeType.STRING,
+                                permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                            });
+                            await this.ensureProperty(channel, devices_constants_1.PropertyCategory.ACTIVE, 'category', devices_constants_1.PropertyCategory.ACTIVE, isActive, {
+                                data_type: devices_constants_1.DataTypeType.BOOL,
+                                permissions: [devices_constants_1.PermissionType.READ_ONLY],
+                            });
+                        }
                     }));
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} input component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -631,6 +755,7 @@ let DeviceManagerService = class DeviceManagerService {
                         }
                         catch (error) {
                             const err = error;
+                            hasComponentFailures = true;
                             this.logger.error(`Failed to load device power status for device=${device.id} and devicePower=${key}`, {
                                 resource: device.id,
                                 message: err.message,
@@ -730,6 +855,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} humidity component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -780,6 +906,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} temperature component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -810,6 +937,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} pm1 component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -874,6 +1002,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} em component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -938,6 +1067,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} emdata component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -969,6 +1099,7 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} em1 component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
@@ -1003,15 +1134,29 @@ let DeviceManagerService = class DeviceManagerService {
                     const settled = await Promise.allSettled(tasks);
                     const failed = settled.filter((r) => r.status === 'rejected').length;
                     if (failed) {
+                        hasComponentFailures = true;
                         this.logger.warn(`${failed}/${ids.length} em1data component(s) failed for device=${device.id}`, {
                             resource: device.id,
                         });
                     }
                 }
             }
+            if (hasComponentFailures) {
+                this.logger.warn(`Skipping stale-channel removal after partial provisioning for device=${device.id}`, {
+                    resource: device.id,
+                });
+                return device;
+            }
             const allChannels = await this.channelsService.findAll(device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            const descriptorInputKeys = new Set((deviceSpec?.components ?? [])
+                .filter((c) => c.type === devices_shelly_ng_constants_1.ComponentType.INPUT)
+                .flatMap((c) => (c.ids ?? []).map((inputKey) => `input:${inputKey}`)));
             for (const channel of allChannels) {
                 if (!channelsIds.includes(channel.id)) {
+                    if (descriptorInputKeys.has(channel.identifier)) {
+                        this.logger.debug(`Preserving descriptor-declared input channel=${channel.identifier} for device=${device.id}`);
+                        continue;
+                    }
                     try {
                         if (this.defaultManager) {
                             await this.channelsService.remove(channel.id, this.defaultManager);
@@ -1207,7 +1352,7 @@ let DeviceManagerService = class DeviceManagerService {
                 data_type: resolvedDataType,
                 format: resolvedFormat ?? null,
                 step: resolvedStep,
-            });
+            }, { skipUnchangedMetadata: true });
         }
         return prop;
     }