@fastybird/smart-panel-backend 0.1.0-alpha.6 → 0.1.0-alpha.8

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

@@ -24,16 +24,18 @@ const devices_shelly_ng_exceptions_1 = require("../devices-shelly-ng.exceptions"
 const update_channel_property_dto_1 = require("../dto/update-channel-property.dto");
 const mappings_1 = require("../mappings");
 const transformers_1 = require("../mappings/transformers/transformers");
+const device_address_service_1 = require("../services/device-address.service");
 const device_manager_service_1 = require("../services/device-manager.service");
 const transform_utils_2 = require("../utils/transform.utils");
 const shelly_device_delegate_1 = require("./shelly-device.delegate");
 let DelegatesManagerService = class DelegatesManagerService {
-    constructor(devicesService, channelsService, channelsPropertiesService, deviceConnectivityService, deviceManagerService, propertyMappingStorage, transformerRegistry) {
+    constructor(devicesService, channelsService, channelsPropertiesService, deviceConnectivityService, deviceManagerService, deviceAddressService, propertyMappingStorage, transformerRegistry) {
         this.devicesService = devicesService;
         this.channelsService = channelsService;
         this.channelsPropertiesService = channelsPropertiesService;
         this.deviceConnectivityService = deviceConnectivityService;
         this.deviceManagerService = deviceManagerService;
+        this.deviceAddressService = deviceAddressService;
         this.propertyMappingStorage = propertyMappingStorage;
         this.transformerRegistry = transformerRegistry;
         this.logger = (0, logger_1.createExtensionLogger)(devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_PLUGIN_NAME, 'DelegatesManagerService');
@@ -46,8 +48,13 @@ let DelegatesManagerService = class DelegatesManagerService {
         this.pendingWrites = new Map();
         this.propertiesMap = new Map();
         this.delegateDeviceIds = new Map();
+        this.delegateToIdentifier = new Map();
+        this.identifierToDelegates = new Map();
+        this.delegateConnectedState = new Map();
         this.insertGeneration = new Map();
         this.deviceLocks = new Map();
+        this.canonicalMacLocks = new Map();
+        this.connectedDelegatesPerDevice = new Map();
     }
     get(id) {
         return this.delegates.get(id);
@@ -68,34 +75,57 @@ let DelegatesManagerService = class DelegatesManagerService {
         this.insertGeneration.set(shelly.id, generation);
         const delegate = new shelly_device_delegate_1.ShellyDeviceDelegate(shelly);
         this.delegates.set(shelly.id, delegate);
-        const hostname = shelly.wifi?.sta_ip ?? shelly.ethernet?.ip ?? null;
-        if (hostname === null) {
+        const wifiIp = shelly.wifi?.sta_ip ?? null;
+        const ethernetIp = shelly.ethernet?.ip ?? null;
+        if (ethernetIp === null && wifiIp === null) {
             throw new devices_shelly_ng_exceptions_1.DevicesShellyNgException('Missing device hostname or IP address');
         }
-        let device = await this.devicesService.findOneBy('identifier', shelly.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
-        let isNewDevice = false;
-        if (device === null) {
-            try {
-                device = await this.devicesService.create({
-                    type: devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE,
-                    category: this.determineCategory(delegate),
-                    identifier: shelly.id,
-                    hostname,
-                    name: shelly.system.config.device.name ?? shelly.modelName,
-                });
-                isNewDevice = true;
+        const canonicalMac = shelly.system?.config?.device?.mac ?? null;
+        const { device: resolvedDevice, isNewDevice } = await this.withCanonicalMacLock(canonicalMac, async () => {
+            let dev = await this.devicesService.findOneBy('identifier', shelly.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            if (!dev && canonicalMac) {
+                dev = (await this.deviceAddressService.findDeviceByCanonicalMac(canonicalMac)) ?? null;
+                if (dev) {
+                    this.logger.log(`Device=${shelly.id} matched existing device=${dev.identifier} by canonical MAC=${canonicalMac} (multi-interface merge)`, { resource: dev.id });
+                }
             }
-            catch (error) {
-                device = await this.devicesService.findOneBy('identifier', shelly.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
-                if (device === null) {
-                    throw error;
+            let created = false;
+            if (dev === null) {
+                try {
+                    dev = await this.devicesService.create({
+                        type: devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE,
+                        category: this.determineCategory(delegate),
+                        identifier: shelly.id,
+                        name: shelly.system.config.device.name ?? shelly.modelName,
+                    });
+                    created = true;
+                }
+                catch (error) {
+                    dev = await this.devicesService.findOneBy('identifier', shelly.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+                    if (!dev && canonicalMac) {
+                        dev = (await this.deviceAddressService.findDeviceByCanonicalMac(canonicalMac)) ?? null;
+                    }
+                    if (dev === null) {
+                        throw error;
+                    }
                 }
             }
-        }
+            if (canonicalMac && dev.canonicalMac !== (0, device_address_service_1.normalizeMac)(canonicalMac)) {
+                await this.deviceAddressService.setCanonicalMac(dev.id, canonicalMac);
+            }
+            return { device: dev, isNewDevice: created };
+        });
+        let device = resolvedDevice;
         this.delegateDeviceIds.set(delegate.id, device.id);
-        if (isNewDevice) {
+        this.delegateToIdentifier.set(delegate.id, device.identifier);
+        const delegateSet = this.identifierToDelegates.get(device.identifier) ?? new Set();
+        delegateSet.add(delegate.id);
+        this.identifierToDelegates.set(device.identifier, delegateSet);
+        await this.deviceAddressService.syncAddresses(device.id, wifiIp, ethernetIp);
+        const existingChannel = await this.channelsService.findOneBy('category', devices_constants_1.ChannelCategory.DEVICE_INFORMATION, device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+        if (isNewDevice || existingChannel === null) {
             await this.deviceManagerService.createOrUpdate(device.id);
-            device = await this.devicesService.findOneBy('identifier', shelly.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
+            device = await this.devicesService.findOne(device.id, devices_shelly_ng_constants_1.DEVICES_SHELLY_NG_TYPE);
             if (device === null) {
                 throw new devices_shelly_ng_exceptions_1.DevicesShellyNgException('Device not found after provisioning');
             }
@@ -839,27 +869,84 @@ let DelegatesManagerService = class DelegatesManagerService {
         delegate.on('value', valueHandler);
         this.delegateValueHandlers.set(delegate.id, valueHandler);
         const connectionHandler = (state) => {
-            this.deviceConnectivityService
-                .setConnectionState(device.id, {
-                state: state === null ? devices_constants_1.ConnectionState.UNKNOWN : state ? devices_constants_1.ConnectionState.CONNECTED : devices_constants_1.ConnectionState.DISCONNECTED,
-            })
-                .then(() => {
-                if (state) {
+            const deviceDbId = this.delegateDeviceIds.get(delegate.id) ?? device.id;
+            const wasConnected = this.delegateConnectedState.get(delegate.id) ?? false;
+            if (state === true) {
+                if (wasConnected)
+                    return;
+                this.delegateConnectedState.set(delegate.id, true);
+                const count = (this.connectedDelegatesPerDevice.get(deviceDbId) ?? 0) + 1;
+                this.connectedDelegatesPerDevice.set(deviceDbId, count);
+                this.deviceConnectivityService
+                    .setConnectionState(deviceDbId, { state: devices_constants_1.ConnectionState.CONNECTED })
+                    .catch((err) => {
+                    this.logger.error(`Failed to set state=${devices_constants_1.ConnectionState.CONNECTED} for device=${delegate.id}`, {
+                        resource: deviceDbId,
+                        message: err.message,
+                        stack: err.stack,
+                    });
+                });
+            }
+            else if (state === false) {
+                if (!wasConnected)
+                    return;
+                this.delegateConnectedState.set(delegate.id, false);
+                const count = Math.max(0, (this.connectedDelegatesPerDevice.get(deviceDbId) ?? 1) - 1);
+                this.connectedDelegatesPerDevice.set(deviceDbId, count);
+                if (count === 0) {
+                    this.deviceConnectivityService
+                        .setConnectionState(deviceDbId, { state: devices_constants_1.ConnectionState.DISCONNECTED })
+                        .catch((err) => {
+                        this.logger.error(`Failed to set state=DISCONNECTED for device=${delegate.id}`, {
+                            resource: deviceDbId,
+                            message: err.message,
+                            stack: err.stack,
+                        });
+                    });
                 }
                 else {
+                    this.logger.debug(`Device=${delegate.id} disconnected but ${count} other delegate(s) still connected`, {
+                        resource: deviceDbId,
+                    });
                 }
-            })
-                .catch((err) => {
-                this.logger.error(`Failed to set state=${state ? devices_constants_1.ConnectionState.CONNECTED : devices_constants_1.ConnectionState.DISCONNECTED} for device=${delegate.id}`, {
-                    resource: device.id,
-                    message: err.message,
-                    stack: err.stack,
-                });
-            });
+            }
+            else {
+                const identifier = this.delegateToIdentifier.get(delegate.id);
+                const siblingDelegates = identifier ? this.identifierToDelegates.get(identifier) : undefined;
+                const otherDelegatesRemain = siblingDelegates ? siblingDelegates.size > 1 : false;
+                const targetState = otherDelegatesRemain ? devices_constants_1.ConnectionState.DISCONNECTED : devices_constants_1.ConnectionState.UNKNOWN;
+                if (wasConnected) {
+                    const count = Math.max(0, (this.connectedDelegatesPerDevice.get(deviceDbId) ?? 1) - 1);
+                    this.connectedDelegatesPerDevice.set(deviceDbId, count);
+                    if (count === 0) {
+                        this.deviceConnectivityService
+                            .setConnectionState(deviceDbId, { state: targetState })
+                            .catch((err) => {
+                            this.logger.error(`Failed to set state=${targetState} for device=${delegate.id}`, {
+                                resource: deviceDbId,
+                                message: err.message,
+                                stack: err.stack,
+                            });
+                        });
+                    }
+                }
+                else if ((this.connectedDelegatesPerDevice.get(deviceDbId) ?? 0) === 0) {
+                    this.deviceConnectivityService.setConnectionState(deviceDbId, { state: targetState }).catch((err) => {
+                        this.logger.error(`Failed to set state=${targetState} for device=${delegate.id}`, {
+                            resource: deviceDbId,
+                            message: err.message,
+                            stack: err.stack,
+                        });
+                    });
+                }
+                this.delegateConnectedState.delete(delegate.id);
+            }
         };
         delegate.on('connected', connectionHandler);
         this.delegateConnectionHandlers.set(delegate.id, connectionHandler);
-        connectionHandler(true);
+        if (delegate.connected) {
+            connectionHandler(true);
+        }
         this.logger.log(`Attached Shelly device=${delegate.id}`, { resource: device.id });
         return delegate;
     }
@@ -881,15 +968,21 @@ let DelegatesManagerService = class DelegatesManagerService {
         }
         else {
             const deviceDbId = this.delegateDeviceIds.get(deviceId) ?? deviceId;
-            void this.deviceConnectivityService
-                .setConnectionState(deviceDbId, { state: devices_constants_1.ConnectionState.UNKNOWN })
-                .catch((err) => {
-                this.logger.warn(`Failed to mark device=${delegate.id} as disconnected while removing delegate`, {
-                    resource: delegate.id,
-                    message: err.message,
-                    stack: err.stack,
+            if ((this.connectedDelegatesPerDevice.get(deviceDbId) ?? 0) === 0) {
+                const identifier = this.delegateToIdentifier.get(deviceId);
+                const siblingDelegates = identifier ? this.identifierToDelegates.get(identifier) : undefined;
+                const otherDelegatesRemain = siblingDelegates ? siblingDelegates.size > 1 : false;
+                const targetState = otherDelegatesRemain ? devices_constants_1.ConnectionState.DISCONNECTED : devices_constants_1.ConnectionState.UNKNOWN;
+                void this.deviceConnectivityService
+                    .setConnectionState(deviceDbId, { state: targetState })
+                    .catch((err) => {
+                    this.logger.warn(`Failed to mark device=${delegate.id} as ${targetState} while removing delegate`, {
+                        resource: delegate.id,
+                        message: err.message,
+                        stack: err.stack,
+                    });
                 });
-            });
+            }
         }
         if (valueHandler) {
             delegate.off('value', valueHandler);
@@ -914,6 +1007,20 @@ let DelegatesManagerService = class DelegatesManagerService {
                 this.setChannelsHandlers.delete(key);
             }
         }
+        const identifier = this.delegateToIdentifier.get(deviceId);
+        if (identifier) {
+            const delegateSet = this.identifierToDelegates.get(identifier);
+            if (delegateSet) {
+                delegateSet.delete(deviceId);
+                if (delegateSet.size === 0) {
+                    this.identifierToDelegates.delete(identifier);
+                    const deviceDbId = this.delegateDeviceIds.get(deviceId);
+                    if (deviceDbId) {
+                        this.connectedDelegatesPerDevice.delete(deviceDbId);
+                    }
+                }
+            }
+        }
         const ids = this.propertiesMap.get(deviceId);
         if (ids) {
             for (const pid of ids) {
@@ -923,12 +1030,13 @@ let DelegatesManagerService = class DelegatesManagerService {
             this.propertiesMap.delete(deviceId);
         }
         this.delegateDeviceIds.delete(deviceId);
+        this.delegateToIdentifier.delete(deviceId);
         this.insertGeneration.delete(deviceId);
         this.delegates.delete(deviceId);
         this.logger.log(`Detached Shelly device=${deviceId}`, { resource: deviceId });
     }
     async setChannelValue(device, channel, updates) {
-        const handler = this.setChannelsHandlers.get(`${device.identifier}|${channel.id}`);
+        const handler = this.resolveChannelHandler(device.identifier, channel.id);
         if (!handler) {
             return Promise.reject(new devices_shelly_ng_exceptions_1.DevicesShellyNgNotImplementedException('Multiple property writes are not supported by the component.'));
         }
@@ -946,7 +1054,7 @@ let DelegatesManagerService = class DelegatesManagerService {
         return handler(transformedUpdates);
     }
     async setPropertyValue(device, property, value) {
-        const handler = this.setPropertiesHandlers.get(`${device.identifier}|${property.id}`);
+        const handler = this.resolvePropertyHandler(device.identifier, property.id);
         if (!handler) {
             this.logger.warn(`Trying to write to device=${device.identifier} to not writable property=${property.id} value=${value}`, { resource: device.id });
             return Promise.resolve(false);
@@ -1067,10 +1175,51 @@ let DelegatesManagerService = class DelegatesManagerService {
             value,
         }));
     }
+    resolvePropertyHandler(deviceIdentifier, propertyId) {
+        const delegateIds = this.identifierToDelegates.get(deviceIdentifier);
+        if (!delegateIds)
+            return undefined;
+        let fallback;
+        for (const delegateId of delegateIds) {
+            const handler = this.setPropertiesHandlers.get(`${delegateId}|${propertyId}`);
+            if (!handler)
+                continue;
+            if (this.delegateConnectedState.get(delegateId))
+                return handler;
+            fallback ??= handler;
+        }
+        return fallback;
+    }
+    resolveChannelHandler(deviceIdentifier, channelId) {
+        const delegateIds = this.identifierToDelegates.get(deviceIdentifier);
+        if (!delegateIds)
+            return undefined;
+        let fallback;
+        for (const delegateId of delegateIds) {
+            const handler = this.setChannelsHandlers.get(`${delegateId}|${channelId}`);
+            if (!handler)
+                continue;
+            if (this.delegateConnectedState.get(delegateId))
+                return handler;
+            fallback ??= handler;
+        }
+        return fallback;
+    }
     detach() {
-        for (const [deviceId] of this.delegates.entries()) {
-            this.performRemove(deviceId);
+        for (const [, delegate] of this.delegates.entries()) {
+            const valueHandler = this.delegateValueHandlers.get(delegate.id);
+            const connectionHandler = this.delegateConnectionHandlers.get(delegate.id);
+            if (valueHandler) {
+                delegate.off('value', valueHandler);
+            }
+            if (connectionHandler) {
+                delegate.off('connected', connectionHandler);
+            }
         }
+        this.delegates.clear();
+        this.delegateValueHandlers.clear();
+        this.delegateConnectionHandlers.clear();
+        this.delegateDeviceIds.clear();
         this.changeHandlers.clear();
         this.setPropertiesHandlers.clear();
         this.setChannelsHandlers.clear();
@@ -1080,10 +1229,37 @@ let DelegatesManagerService = class DelegatesManagerService {
         }
         this.pendingWrites.clear();
         this.deviceLocks.clear();
+        this.canonicalMacLocks.clear();
+        this.connectedDelegatesPerDevice.clear();
+        this.delegateToIdentifier.clear();
+        this.identifierToDelegates.clear();
+        this.delegateConnectedState.clear();
+        this.insertGeneration.clear();
     }
     destroy() {
         this.detach();
     }
+    async withCanonicalMacLock(canonicalMac, fn) {
+        if (!canonicalMac) {
+            return fn();
+        }
+        const pending = this.canonicalMacLocks.get(canonicalMac) ?? Promise.resolve();
+        let resolveLock;
+        const lock = new Promise((r) => {
+            resolveLock = r;
+        });
+        this.canonicalMacLocks.set(canonicalMac, lock);
+        await pending.catch(() => { });
+        try {
+            return await fn();
+        }
+        finally {
+            resolveLock();
+            if (this.canonicalMacLocks.get(canonicalMac) === lock) {
+                this.canonicalMacLocks.delete(canonicalMac);
+            }
+        }
+    }
     async withDeviceLock(deviceId, fn) {
         const pending = this.deviceLocks.get(deviceId) ?? Promise.resolve();
         let resolveLock;
@@ -1111,6 +1287,7 @@ exports.DelegatesManagerService = DelegatesManagerService = __decorate([
         channels_properties_service_1.ChannelsPropertiesService,
         device_connectivity_service_1.DeviceConnectivityService,
         device_manager_service_1.DeviceManagerService,
+        device_address_service_1.DeviceAddressService,
         mappings_1.PropertyMappingStorageService,
         mappings_1.TransformerRegistry])
 ], DelegatesManagerService);