iobroker.lorawan 1.16.2 → 1.16.4

package/README.md

@@ -23,6 +23,13 @@ For now there is documentation in English here: https://wiki.hafenmeister.de
 	Placeholder for the next version (at the beginning of the line):
 	### **WORK IN PROGRESS**
 -->
+### 1.16.4 (2025-09-17)
+* (BenAhrdt) Bridge import foreign states till Adapter is running
+* (BenAhrdt) Bridge delete foreign states till Adapter is running
+
+### 1.16.3 (2025-09-16)
+* (BenAhrdt) nameing of foreign Devices in Bridge
+
 ### 1.16.2 (2025-09-16)
 * (BenAhrdt) bugfix namespace also by calling work from directoryhandler
 

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "lorawan",
-    "version": "1.16.2",
+    "version": "1.16.4",
     "news": {
+      "1.16.4": {
+        "en": "Bridge import foreign states till Adapter is running\nBridge delete foreign states till Adapter is running",
+        "de": "Brücke importiert externe Zustände, solange der Adapter läuft.\nLösche Fremdzustände aus der Datenbank, solange der Adapter aktiv ist.",
+        "ru": "Импортируйте внешние состояния моста до запуска адаптера\nУдаление внешних состояний Bridge, пока работает адаптер.",
+        "pt": "Importar estados externos da ponte até que o adaptador esteja em execução\nExcluir estados estrangeiros da ponte até que o adaptador esteja em execução",
+        "nl": "Importeer externe toestanden van de brug totdat de adapter actief is\nBridge verwijdert externe statussen zolang de adapter actief is",
+        "fr": "Importer les états étrangers du pont tant que l'adaptateur est en cours d'exécution.\nSupprimer les états étrangers du pont tant que l'adaptateur est en cours d'exécution",
+        "it": "Importa gli stati esterni del bridge finché l'adattatore è in esecuzione\nEliminazione dello stato estero del bridge fino a quando l'adattatore è in esecuzione",
+        "es": "Importar estados extranjeros del puente hasta que el adaptador esté en funcionamiento.\nEliminar estados extranjeros del puente hasta que el adaptador esté en funcionamiento",
+        "pl": "Importuj stany mostu do momentu uruchomienia adaptera.\nUsunięto stany obce do momentu uruchomienia adaptera.",
+        "uk": "Міст імпортує зовнішні стани поки адаптер працює\nВидалення зовнішніх станів у мосту доки адаптер працює.",
+        "zh-cn": "桥接器在适配器运行之前导入外部状态\n桥删除外部状态直到适配器运行"
+      },
+      "1.16.3": {
+        "en": "nameing of foreign Devices in Bridge",
+        "de": "Benennung von fremden Geräten in der Brücke",
+        "ru": "Наименование иностранных устройств в мосту",
+        "pt": "Nomenclatura de Dispositivos Estrangeiros na Ponte",
+        "nl": "Benaming van externe apparaten in de bridge",
+        "fr": "Renommage des appareils étrangers dans le pont",
+        "it": "Nominativo dei dispositivi stranieri nel Bridge",
+        "es": "Renombrar dispositivos extranjeros en el puente",
+        "pl": "Nadanie nazw obcym urządzeniom w mostku",
+        "uk": "Перейменування зовнішніх пристроїв у мосту",
+        "zh-cn": "在网桥中给外部设备命名"
+      },
       "1.16.2": {
         "en": "bugfix namespace also by calling work from directoryhandler",
         "de": "Bug behoben: Namensraum auch durch Aufruf von \"Arbeit\" von DirectoryHandler.",
@@ -67,32 +93,6 @@
         "pl": "rozwiązać problem stażysty ds. publikacji",
         "uk": "вирішення питань практиканта з розміщення текстів",
         "zh-cn": "解决发布实习生"
-      },
-      "1.15.6": {
-        "en": "improve handling of state device in case of subfolders",
-        "de": "Verbessere die Handhabung des Gerätestatus bei Unterordnern.",
-        "ru": "Улучшено управление устройствами состояний в случае подпапок.",
-        "pt": "Melhorar o tratamento do dispositivo de estado no caso de subpastas",
-        "nl": "Verbeter de verwerking van apparaatstaten in geval van submappen.",
-        "fr": "Améliorer la gestion de l'appareil d'état en cas de sous-dossiers",
-        "it": "Migliorare la gestione del dispositivo di stato nel caso di sottocartelle",
-        "es": "Mejora en el manejo del dispositivo de estado en caso de subcarpetas",
-        "pl": "Poprawiono obsługę urządzenia stanu w przypadku podfolderów.",
-        "uk": "Поліпшено обробку пристрою стану у випадку підпапок.",
-        "zh-cn": "改进对子文件夹中状态设备的处理"
-      },
-      "1.15.5": {
-        "en": "Bugfix logging removed",
-        "de": "Fehlerbehebung beim Protokollieren entfernt",
-        "ru": "Исправлена ошибка с удалением журнала.",
-        "pt": "Correção de bug: log removido",
-        "nl": "Bugfix logging verwijderd",
-        "fr": "Correctif de bug: suppression du journalisation",
-        "it": "Rimossa la registrazione dei bugfix",
-        "es": "Corregido el registro de errores.",
-        "pl": "Usunięto logowanie błędów",
-        "uk": "Виправлено запис журналів про помилки",
-        "zh-cn": "修复了日志记录问题"
       }
     },
     "titleLang": {

package/lib/modules/bridge.js

@@ -21,6 +21,7 @@ class bridgeClass {
 
         // Structure of actual vaulues in Bridge (till las start of Adapter)
         this.CheckedIds = {};
+        this.OldDiscoveredIds = {};
         this.DiscoveredIds = {};
         this.SubscribedTopics = {};
         this.PublishedIds = {};
@@ -29,6 +30,7 @@ class bridgeClass {
         this.BridgeDiscoveryPrefix = {
             HA: 'homeassistant/',
         };
+        this.ForeignBridgeMembers = {};
         this.MinTime = 100; // ms between publish and subscribe same value
         this.DiscoveryCronjob = {};
         this.EndingSet = '/set';
@@ -306,17 +308,29 @@ class bridgeClass {
                 };
                 let discoveryobject = this.getNotificationDiscoveryObject(deviceIdentifier, this.Words.general);
                 this.Notifications[general.notificationId] = {};
-                if (!this.PublishedIds[general.notificationId]) {
-                    this.PublishedIds[general.notificationId] = { discovery: [] };
-                }
-                this.PublishedIds[general.notificationId].discovery.push({
-                    topic: discoveryobject?.topic,
-                    payload: structuredClone(discoveryobject?.payload),
-                });
-                this.PublishedIds[general.notificationId].state_topic = discoveryobject?.payload.topic;
+                this.assignIdStructure(
+                    this.PublishedIds,
+                    general.notificationId,
+                    {
+                        applicationName: changeInfo.applicationName,
+                        usedApplicationName: changeInfo.usedApplicationName,
+                        deviceId: changeInfo.deviceId,
+                        usedDeviceId: changeInfo.usedDeviceId,
+                    },
+                    discoveryobject?.topic,
+                    discoveryobject?.payload,
+                    discoveryobject?.payload.topic,
+                );
+
                 await this.publishDiscovery(general.notificationId, {
                     topic: discoveryobject?.topic,
                     payload: structuredClone(discoveryobject?.payload),
+                    informations: {
+                        applicationName: changeInfo.applicationName,
+                        usedApplicationName: changeInfo.usedApplicationName,
+                        deviceId: changeInfo.deviceId,
+                        usedDeviceId: changeInfo.usedDeviceId,
+                    },
                 });
 
                 // offline
@@ -326,17 +340,29 @@ class bridgeClass {
                 };
                 discoveryobject = this.getNotificationDiscoveryObject(deviceIdentifier, this.Words.offline);
                 this.Notifications[offline.notificationId] = {};
-                if (!this.PublishedIds[offline.notificationId]) {
-                    this.PublishedIds[offline.notificationId] = { discovery: [] };
-                }
-                this.PublishedIds[offline.notificationId].discovery.push({
-                    topic: discoveryobject?.topic,
-                    payload: structuredClone(discoveryobject?.payload),
-                });
-                this.PublishedIds[offline.notificationId].state_topic = discoveryobject?.payload.topic;
+                this.assignIdStructure(
+                    this.PublishedIds,
+                    offline.notificationId,
+                    {
+                        applicationName: changeInfo.applicationName,
+                        usedApplicationName: changeInfo.usedApplicationName,
+                        deviceId: changeInfo.deviceId,
+                        usedDeviceId: changeInfo.usedDeviceId,
+                    },
+                    discoveryobject?.topic,
+                    discoveryobject?.payload,
+                    discoveryobject?.payload.topic,
+                );
+
                 await this.publishDiscovery(offline.notificationId, {
                     topic: discoveryobject?.topic,
                     payload: structuredClone(discoveryobject?.payload),
+                    informations: {
+                        applicationName: changeInfo.applicationName,
+                        usedApplicationName: changeInfo.usedApplicationName,
+                        deviceId: changeInfo.deviceId,
+                        usedDeviceId: changeInfo.usedDeviceId,
+                    },
                 });
 
                 // online
@@ -346,17 +372,29 @@ class bridgeClass {
                 };
                 discoveryobject = this.getNotificationDiscoveryObject(deviceIdentifier, this.Words.online);
                 this.Notifications[online.notificationId] = {};
-                if (!this.PublishedIds[online.notificationId]) {
-                    this.PublishedIds[online.notificationId] = { discovery: [] };
-                }
-                this.PublishedIds[online.notificationId].discovery.push({
-                    topic: discoveryobject?.topic,
-                    payload: structuredClone(discoveryobject?.payload),
-                });
-                this.PublishedIds[online.notificationId].state_topic = discoveryobject?.payload.topic;
+                this.assignIdStructure(
+                    this.PublishedIds,
+                    online.notificationId,
+                    {
+                        applicationName: changeInfo.applicationName,
+                        usedApplicationName: changeInfo.usedApplicationName,
+                        deviceId: changeInfo.deviceId,
+                        usedDeviceId: changeInfo.usedDeviceId,
+                    },
+                    discoveryobject?.topic,
+                    discoveryobject?.payload,
+                    discoveryobject?.payload.topic,
+                );
+
                 await this.publishDiscovery(online.notificationId, {
                     topic: discoveryobject?.topic,
                     payload: structuredClone(discoveryobject?.payload),
+                    informations: {
+                        applicationName: changeInfo.applicationName,
+                        usedApplicationName: changeInfo.usedApplicationName,
+                        deviceId: changeInfo.deviceId,
+                        usedDeviceId: changeInfo.usedDeviceId,
+                    },
                 });
             }
         } catch (error) {
@@ -379,17 +417,23 @@ class bridgeClass {
             if (!this.Notifications[notificationId]) {
                 const discoveryobject = this.getNotificationDiscoveryObject(this.adapter.namespace, this.Words.general);
                 this.Notifications[notificationId] = {};
-                if (!this.PublishedIds[notificationId]) {
-                    this.PublishedIds[notificationId] = { discovery: [] };
-                }
-                this.PublishedIds[notificationId].discovery.push({
-                    topic: discoveryobject?.topic,
-                    payload: structuredClone(discoveryobject?.payload),
-                });
-                this.PublishedIds[notificationId].state_topic = discoveryobject?.payload.topic;
+                this.assignIdStructure(
+                    this.PublishedIds,
+                    notificationId,
+                    {
+                        usedDeviceId: this.adapter.namespace,
+                    },
+                    discoveryobject?.topic,
+                    discoveryobject?.payload,
+                    discoveryobject?.payload.topic,
+                );
+
                 await this.publishDiscovery(notificationId, {
                     topic: discoveryobject?.topic,
                     payload: structuredClone(discoveryobject?.payload),
+                    informations: {
+                        usedDeviceId: this.adapter.namespace,
+                    },
                 });
             }
         } catch (error) {
@@ -510,84 +554,81 @@ class bridgeClass {
                     };
 
                     // Assign Subscribed Topics
-                    if (!this.SubscribedTopics[`${target.Topic}${this.EndingSet}`]) {
-                        this.SubscribedTopics[`${target.Topic}${this.EndingSet}`] = { discovery: [] };
-                    }
-                    this.SubscribedTopics[`${target.Topic}${this.EndingSet}`].discovery.push({
-                        topic: DiscoveryTopic,
-                        payload: structuredClone(DiscoveryPayload),
-                    });
-                    this.SubscribedTopics[`${target.Topic}${this.EndingSet}`].id = config.climateIds.target;
-                    this.SubscribedTopics[`${target.Topic}${this.EndingSet}`].informations = {
-                        applicationName: target.changeInfo.applicationName,
-                        usedApplicationName: target.changeInfo.usedApplicationName,
-                        deviceId: target.changeInfo.deviceId,
-                        usedDeviceId: target.changeInfo.usedDeviceId,
-                    };
+                    // Target
+                    this.assignTopicStructure(
+                        this.SubscribedTopics,
+                        `${target.Topic}${this.EndingSet}`,
+                        {
+                            applicationName: target.changeInfo.applicationName,
+                            usedApplicationName: target.changeInfo.usedApplicationName,
+                            deviceId: target.changeInfo.deviceId,
+                            usedDeviceId: target.changeInfo.usedDeviceId,
+                        },
+                        DiscoveryTopic,
+                        DiscoveryPayload,
+                        config.climateIds.target,
+                    );
 
-                    if (!this.SubscribedTopics[`${mode.Topic}${this.EndingSet}`]) {
-                        this.SubscribedTopics[`${mode.Topic}${this.EndingSet}`] = { discovery: [] };
-                    }
-                    this.SubscribedTopics[`${mode.Topic}${this.EndingSet}`].discovery.push({
-                        topic: DiscoveryTopic,
-                        payload: structuredClone(DiscoveryPayload),
-                    });
-                    this.SubscribedTopics[`${mode.Topic}${this.EndingSet}`].id = config.climateIds.mode;
-                    this.SubscribedTopics[`${mode.Topic}${this.EndingSet}`].informations = {
-                        applicationName: mode.changeInfo.applicationName,
-                        usedApplicationName: mode.changeInfo.usedApplicationName,
-                        deviceId: mode.changeInfo.deviceId,
-                        usedDeviceId: mode.changeInfo.usedDeviceId,
-                    };
+                    // Mode
+                    this.assignTopicStructure(
+                        this.SubscribedTopics,
+                        `${mode.Topic}${this.EndingSet}`,
+                        {
+                            applicationName: mode.changeInfo.applicationName,
+                            usedApplicationName: mode.changeInfo.usedApplicationName,
+                            deviceId: mode.changeInfo.deviceId,
+                            usedDeviceId: mode.changeInfo.usedDeviceId,
+                        },
+                        DiscoveryTopic,
+                        DiscoveryPayload,
+                        config.climateIds.mode,
+                    );
 
                     // Assign published Topics
                     // Target
-                    if (!this.PublishedIds[config.climateIds.target]) {
-                        this.PublishedIds[config.climateIds.target] = { discovery: [] };
-                    }
-                    this.PublishedIds[config.climateIds.target].discovery.push({
-                        topic: DiscoveryTopic,
-                        payload: structuredClone(DiscoveryPayload),
-                    });
-                    this.PublishedIds[config.climateIds.target].state_topic = `${target.Topic}${this.EndingState}`;
-                    this.PublishedIds[config.climateIds.target].informations = {
-                        applicationName: target.changeInfo.applicationName,
-                        usedApplicationName: target.changeInfo.usedApplicationName,
-                        deviceId: target.changeInfo.deviceId,
-                        usedDeviceId: target.changeInfo.usedDeviceId,
-                    };
+                    this.assignIdStructure(
+                        this.PublishedIds,
+                        config.climateIds.target,
+                        {
+                            applicationName: target.changeInfo.applicationName,
+                            usedApplicationName: target.changeInfo.usedApplicationName,
+                            deviceId: target.changeInfo.deviceId,
+                            usedDeviceId: target.changeInfo.usedDeviceId,
+                        },
+                        DiscoveryTopic,
+                        DiscoveryPayload,
+                        `${target.Topic}${this.EndingState}`,
+                    );
 
                     // Act
-                    if (!this.PublishedIds[config.climateIds.act]) {
-                        this.PublishedIds[config.climateIds.act] = { discovery: [] };
-                    }
-                    this.PublishedIds[config.climateIds.act].discovery.push({
-                        topic: DiscoveryTopic,
-                        payload: structuredClone(DiscoveryPayload),
-                    });
-                    this.PublishedIds[config.climateIds.act].state_topic = `${act.Topic}${this.EndingState}`;
-                    this.PublishedIds[config.climateIds.act].informations = {
-                        applicationName: act.changeInfo.applicationName,
-                        usedApplicationName: act.changeInfo.usedApplicationName,
-                        deviceId: act.changeInfo.deviceId,
-                        usedDeviceId: act.changeInfo.usedDeviceId,
-                    };
+                    this.assignIdStructure(
+                        this.PublishedIds,
+                        config.climateIds.act,
+                        {
+                            applicationName: act.changeInfo.applicationName,
+                            usedApplicationName: act.changeInfo.usedApplicationName,
+                            deviceId: act.changeInfo.deviceId,
+                            usedDeviceId: act.changeInfo.usedDeviceId,
+                        },
+                        DiscoveryTopic,
+                        DiscoveryPayload,
+                        `${act.Topic}${this.EndingState}`,
+                    );
 
                     // Mode
-                    if (!this.PublishedIds[config.climateIds.mode]) {
-                        this.PublishedIds[config.climateIds.mode] = { discovery: [] };
-                    }
-                    this.PublishedIds[config.climateIds.mode].discovery.push({
-                        topic: DiscoveryTopic,
-                        payload: structuredClone(DiscoveryPayload),
-                    });
-                    this.PublishedIds[config.climateIds.mode].state_topic = `${mode.Topic}${this.EndingState}`;
-                    this.PublishedIds[config.climateIds.mode].informations = {
-                        applicationName: mode.changeInfo.applicationName,
-                        usedApplicationName: mode.changeInfo.usedApplicationName,
-                        deviceId: mode.changeInfo.deviceId,
-                        usedDeviceId: mode.changeInfo.usedDeviceId,
-                    };
+                    this.assignIdStructure(
+                        this.PublishedIds,
+                        config.climateIds.mode,
+                        {
+                            applicationName: mode.changeInfo.applicationName,
+                            usedApplicationName: mode.changeInfo.usedApplicationName,
+                            deviceId: mode.changeInfo.deviceId,
+                            usedDeviceId: mode.changeInfo.usedDeviceId,
+                        },
+                        DiscoveryTopic,
+                        DiscoveryPayload,
+                        `${mode.Topic}${this.EndingState}`,
+                    );
 
                     // State to publish for Mode
                     let modeval = undefined;
@@ -809,20 +850,19 @@ class bridgeClass {
                         options.Bridgestate = Bridgestate;
                         const DiscoveryObject = await this.getDiscoveryObject(changeInfo, options);
                         if (Bridgestate.publish) {
-                            if (!this.PublishedIds[id]) {
-                                this.PublishedIds[id] = { discovery: [] };
-                            }
-                            this.PublishedIds[id].discovery.push({
-                                topic: DiscoveryObject?.topic,
-                                payload: structuredClone(DiscoveryObject?.payload),
-                            });
-                            this.PublishedIds[id].state_topic = DiscoveryObject?.payload.state_topic;
-                            this.PublishedIds[id].informations = {
-                                applicationName: changeInfo.applicationName,
-                                usedApplicationName: changeInfo.usedApplicationName,
-                                deviceId: changeInfo.deviceId,
-                                usedDeviceId: changeInfo.usedDeviceId,
-                            };
+                            this.assignIdStructure(
+                                this.PublishedIds,
+                                id,
+                                {
+                                    applicationName: changeInfo.applicationName,
+                                    usedApplicationName: changeInfo.usedApplicationName,
+                                    deviceId: changeInfo.deviceId,
+                                    usedDeviceId: changeInfo.usedDeviceId,
+                                },
+                                DiscoveryObject?.topic,
+                                DiscoveryObject?.payload,
+                                DiscoveryObject?.payload.state_topic,
+                            );
                         }
                         await this.publishDiscovery(id, {
                             topic: DiscoveryObject?.topic,
@@ -869,36 +909,34 @@ class bridgeClass {
                         options.Bridgestate = Bridgestate;
                         const DiscoveryObject = await this.getDiscoveryObject(changeInfo, options);
                         if (Bridgestate.publish) {
-                            if (!this.PublishedIds[id]) {
-                                this.PublishedIds[id] = { discovery: [] };
-                            }
-                            this.PublishedIds[id].discovery.push({
-                                topic: DiscoveryObject?.topic,
-                                payload: structuredClone(DiscoveryObject?.payload),
-                            });
-                            this.PublishedIds[id].state_topic = DiscoveryObject?.payload.state_topic;
-                            this.PublishedIds[id].informations = {
-                                applicationName: changeInfo.applicationName,
-                                usedApplicationName: changeInfo.usedApplicationName,
-                                deviceId: changeInfo.deviceId,
-                                usedDeviceId: changeInfo.usedDeviceId,
-                            };
+                            this.assignIdStructure(
+                                this.PublishedIds,
+                                id,
+                                {
+                                    applicationName: changeInfo.applicationName,
+                                    usedApplicationName: changeInfo.usedApplicationName,
+                                    deviceId: changeInfo.deviceId,
+                                    usedDeviceId: changeInfo.usedDeviceId,
+                                },
+                                DiscoveryObject?.topic,
+                                DiscoveryObject?.payload,
+                                DiscoveryObject?.payload.state_topic,
+                            );
                         }
                         if (Bridgestate.subscribe) {
-                            if (!this.SubscribedTopics[DiscoveryObject?.payload.command_topic]) {
-                                this.SubscribedTopics[DiscoveryObject?.payload.command_topic] = { discovery: [] };
-                            }
-                            this.SubscribedTopics[DiscoveryObject?.payload.command_topic].discovery.push({
-                                topic: DiscoveryObject?.topic,
-                                payload: structuredClone(DiscoveryObject?.payload),
-                            });
-                            this.SubscribedTopics[DiscoveryObject?.payload.command_topic].id = id;
-                            this.SubscribedTopics[DiscoveryObject?.payload.command_topic].informations = {
-                                applicationName: changeInfo.applicationName,
-                                usedApplicationName: changeInfo.usedApplicationName,
-                                deviceId: changeInfo.deviceId,
-                                usedDeviceId: changeInfo.usedDeviceId,
-                            };
+                            this.assignTopicStructure(
+                                this.SubscribedTopics,
+                                DiscoveryObject?.payload.command_topic,
+                                {
+                                    applicationName: changeInfo.applicationName,
+                                    usedApplicationName: changeInfo.usedApplicationName,
+                                    deviceId: changeInfo.deviceId,
+                                    usedDeviceId: changeInfo.usedDeviceId,
+                                },
+                                DiscoveryObject?.topic,
+                                DiscoveryObject?.payload,
+                                id,
+                            );
                         }
                         await this.publishDiscovery(id, {
                             topic: DiscoveryObject?.topic,
@@ -919,6 +957,52 @@ class bridgeClass {
         }
     }
 
+    /*********************************************************************
+     * **************** assign Structur of internal memory ***************
+     * ******************************************************************/
+    /**
+     * @param assignObject object to assign
+     * @param indexId index of the assignable object
+     * @param informations informations about the assign
+     * @param topic dicoverytopic of the assign
+     * @param payload payload of the assign
+     * @param state_topic topic for the  of the assigned state
+     */
+    assignIdStructure(assignObject, indexId, informations, topic, payload, state_topic) {
+        if (!assignObject[indexId]) {
+            assignObject[indexId] = { discovery: [] };
+        }
+        assignObject[indexId].discovery.push({
+            topic: topic,
+            payload: structuredClone(payload),
+        });
+        assignObject[indexId].state_topic = state_topic;
+        assignObject[indexId].informations = structuredClone(informations);
+    }
+
+    /*********************************************************************
+     * **************** assign Structur of internal memory ***************
+     * ******************************************************************/
+    /**
+     * @param assignObject object to assign
+     * @param indexTopic index of the assignable object
+     * @param informations informations about the assign
+     * @param topic dicoverytopic of the assign
+     * @param payload payload of the assign
+     * @param id id for the assign to the foreign state
+     */
+    assignTopicStructure(assignObject, indexTopic, informations, topic, payload, id) {
+        if (!assignObject[indexTopic]) {
+            assignObject[indexTopic] = { discovery: [] };
+        }
+        assignObject[indexTopic].discovery.push({
+            topic: topic,
+            payload: structuredClone(payload),
+        });
+        this.SubscribedTopics[indexTopic].id = id;
+        this.SubscribedTopics[indexTopic].informations = structuredClone(informations);
+    }
+
     /*********************************************************************
      * ******************** Discovery Objekt bilden **********************
      * ******************************************************************/
@@ -1370,6 +1454,9 @@ class bridgeClass {
         const activeFunction = 'bridge.js - checkAllStatesForBridgeWork';
         this.adapter.log.debug(`Function ${activeFunction} started.`);
         try {
+            // get old Discovered ids
+            this.OldDiscoveredIds = JSON.parse((await this.adapter.getStateAsync('info.discoveredIds')).val);
+
             // Get all ids in adapterfolder
             // Generate Infos of all devices and decoded folders
             const adapterObjects = await this.adapter.getAdapterObjectsAsync();
@@ -1394,11 +1481,27 @@ class bridgeClass {
             await this.discoverClimate();
             await this.discoverGeneralNotification();
             await this.getForeignStatesForStandardEntities();
+            await this.checkDiscoveries();
         } catch (error) {
             this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
         }
     }
 
+    /**
+     * check discovery for old entries
+     */
+    async checkDiscoveries() {
+        for (const id in this.OldDiscoveredIds) {
+            if (!this.DiscoveredIds[id]) {
+                this.adapter.log.debug(`The discovered id: ${id} will be removed`);
+                this.DiscoveredIds[id] = this.OldDiscoveredIds[id];
+                this.DiscoveredIds[id].payload = {};
+                await this.publishDiscovery(id, this.DiscoveredIds[id]);
+                delete this.DiscoveredIds[id];
+                await this.adapter.setState('info.discoveredIds', JSON.stringify(this.DiscoveredIds), true);
+            }
+        }
+    }
     // create schedule Jobs for online and historic values
     /**
      * Build the cronJob
@@ -1456,18 +1559,12 @@ class bridgeClass {
         const activeFunction = 'bridge.js - getForeignStatesForStandardEntities';
         this.adapter.log.debug(`Function ${activeFunction} started.`);
         try {
-            const functions = await this.adapter.getEnums('functions');
-            if (functions['enum.functions']['enum.functions.bridge']) {
-                for (const member of functions['enum.functions']['enum.functions.bridge'].common.members) {
-                    const params = {
-                        startkey: member,
-                        endkey: `${member}.\u9999`,
-                    };
-                    const states = await this.adapter.getObjectViewAsync('system', 'state', params);
-                    for (const state of states.rows) {
-                        const common = state.value.common;
-                        await this.discoverForeignStandardEntity(state.id, { common: common });
-                    }
+            const idBridgefunction = 'enum.functions.bridge';
+            await this.adapter.subscribeForeignObjectsAsync('enum.functions.bridge');
+            const bridgeElements = await this.adapter.getForeignObjectAsync(idBridgefunction);
+            if (bridgeElements) {
+                for (const member of bridgeElements.common.members) {
+                    await this.discoverForeignRange(member);
                 }
             }
         } catch (error) {
@@ -1475,6 +1572,43 @@ class bridgeClass {
         }
     }
 
+    /**
+     * @param id id to discover foreign state
+     * @param clear clear the ids from internal memory
+     */
+    async discoverForeignRange(id, clear = false) {
+        const params = {
+            startkey: id,
+            endkey: `${id}.\u9999`,
+        };
+        if (!clear) {
+            this.ForeignBridgeMembers[id] = id;
+        } else {
+            delete this.ForeignBridgeMembers[id];
+        }
+        const states = await this.adapter.getObjectViewAsync('system', 'state', params);
+        for (const state of states.rows) {
+            if (!clear) {
+                const common = state.value.common;
+                await this.discoverForeignStandardEntity(state.id, { common: common });
+            } else {
+                if (
+                    this.DiscoveredIds[id] &&
+                    this.DiscoveredIds[id].payload &&
+                    this.DiscoveredIds[id].payload.command_topic
+                ) {
+                    delete this.SubscribedTopics[this.DiscoveredIds[id].payload.command_topic];
+                }
+                delete this.PublishedIds[id];
+                this.DiscoveredIds[id].payload = {};
+                await this.adapter.unsubscribeForeignStatesAsync(id);
+                await this.publishDiscovery(id, this.DiscoveredIds[id]);
+                delete this.DiscoveredIds[id];
+                await this.adapter.setState('info.discoveredIds', JSON.stringify(this.DiscoveredIds), true);
+            }
+        }
+    }
+
     /**
      * @param id id to discover foreign state
      * @param options options of foreign state
@@ -1484,15 +1618,21 @@ class bridgeClass {
         this.adapter.log.debug(`Function ${activeFunction} started.`);
         try {
             const state = await this.adapter.getForeignStateAsync(id);
-            const parentObject = await this.getParentObject(id);
             let partentId = '';
             let parentName = '';
-            if (typeof parentObject === 'object') {
-                partentId = parentObject._id;
-                parentName = parentObject.common.name;
+            const parentDevice = await this.getParentDevice(id);
+            if (typeof parentDevice === 'string') {
+                const parentChannel = await this.getParentChannel(id);
+                if (typeof parentChannel === 'string') {
+                    partentId = parentChannel;
+                    parentName = partentId;
+                } else {
+                    partentId = parentChannel._id;
+                    parentName = parentChannel.common.name;
+                }
             } else {
-                partentId = parentObject;
-                parentName = partentId;
+                partentId = parentDevice._id;
+                parentName = parentDevice.common.name;
             }
             const deviceIdentifier = parentName;
             const statename = id.substring(partentId.length + 1, id.length);
@@ -1527,66 +1667,110 @@ class bridgeClass {
             }
 
             if (options.Bridgestate.publish) {
-                if (!this.PublishedIds[id]) {
+                this.assignIdStructure(
+                    this.PublishedIds,
+                    id,
+                    {
+                        usedDeviceId: deviceIdentifier,
+                    },
+                    discoveryTopic,
+                    discoveryPayload,
+                    discoveryPayload.state_topic,
+                );
+
+                /*if (!this.PublishedIds[id]) {
                     this.PublishedIds[id] = { discovery: [] };
                 }
                 this.PublishedIds[id].discovery.push({
                     topic: discoveryTopic,
                     payload: structuredClone(discoveryPayload),
                 });
-                this.PublishedIds[id].state_topic = discoveryPayload.state_topic;
+                this.PublishedIds[id].state_topic = discoveryPayload.state_topic;*/
             }
             if (options.Bridgestate.subscribe) {
-                if (!this.SubscribedTopics[discoveryPayload.command_topic]) {
+                this.assignTopicStructure(
+                    this.SubscribedTopics,
+                    discoveryPayload.command_topic,
+                    {
+                        usedDeviceId: deviceIdentifier,
+                    },
+                    discoveryTopic,
+                    discoveryPayload,
+                    id,
+                );
+
+                /*if (!this.SubscribedTopics[discoveryPayload.command_topic]) {
                     this.SubscribedTopics[discoveryPayload.command_topic] = { discovery: [] };
                 }
                 this.SubscribedTopics[discoveryPayload.command_topic].discovery.push({
                     topic: discoveryTopic,
                     payload: structuredClone(discoveryPayload),
                 });
-                this.SubscribedTopics[discoveryPayload.command_topic].id = id;
+                this.SubscribedTopics[discoveryPayload.command_topic].id = id;*/
             }
             await this.publishDiscovery(id, {
                 topic: discoveryTopic,
                 payload: structuredClone(discoveryPayload),
+                informations: {
+                    usedDeviceId: deviceIdentifier,
+                },
             });
             // Delay for publish new entity
             setTimeout(async () => {
                 await this.publishId(id, state.val, {});
             }, 1000);
             // Subscribe state for onStatechange mathode
-            this.adapter.subscribeForeignStatesAsync(id);
+            await this.adapter.subscribeForeignStatesAsync(id);
         } catch (error) {
             this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
         }
     }
 
     /**
-     * @param id id to get parent Object
+     * @param id id to get parent Channel
      */
-    async getParentObject(id) {
-        const activeFunction = 'bridge.js - getParentObject';
+    async getParentDevice(id) {
+        const activeFunction = 'bridge.js - getParentDevice';
         this.adapter.log.debug(`Function ${activeFunction} started.`);
         try {
             const firstIdexOfDot = id.indexOf('.');
             const lastIdexOfDot = id.lastIndexOf('.');
             if (lastIdexOfDot > firstIdexOfDot + 3) {
                 id = id.substring(0, lastIdexOfDot);
-                const firstObj = await this.adapter.getForeignObjectAsync(id);
-                if (!firstObj) {
+                const obj = await this.adapter.getForeignObjectAsync(id);
+                if (!obj) {
                     return undefined;
                 }
-                if (firstObj?.type === 'device') {
-                    return firstObj;
+                if (obj?.type === 'device') {
+                    return obj;
                 }
-                if (firstObj.type === 'channel') {
-                    const secondObj = await this.getParentObject(id);
-                    if (secondObj !== undefined) {
-                        return secondObj;
-                    }
-                    return firstObj;
+                return await this.getParentDevice(id);
+            }
+            return id.substring(0, lastIdexOfDot);
+        } catch (error) {
+            this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
+        }
+    }
+
+    /**
+     * @param id id to get parent Channel
+     */
+    async getParentChannel(id) {
+        const activeFunction = 'bridge.js - getParentChannel';
+        this.adapter.log.debug(`Function ${activeFunction} started.`);
+        try {
+            const firstIdexOfDot = id.indexOf('.');
+            const lastIdexOfDot = id.lastIndexOf('.');
+            if (lastIdexOfDot > firstIdexOfDot + 3) {
+                id = id.substring(0, lastIdexOfDot);
+                const obj = await this.adapter.getForeignObjectAsync(id);
+                if (!obj) {
+                    return undefined;
+                }
+                if (obj?.type === 'channel') {
+                    return obj;
                 }
-                return await this.getParentObject(id);
+                return await this.getParentChannel(id);
             }
             return id.substring(0, lastIdexOfDot);
         } catch (error) {

package/main.js

@@ -23,7 +23,7 @@ class Lorawan extends utils.Adapter {
         });
         this.on('ready', this.onReady.bind(this));
         this.on('stateChange', this.onStateChange.bind(this));
-        //this.on('objectChange', this.onObjectChange.bind(this));
+        this.on('objectChange', this.onObjectChange.bind(this));
         this.on('message', this.onMessage.bind(this));
         this.on('unload', this.onUnload.bind(this));
         this.on('fileChange', this.onFileChange.bind(this));
@@ -77,7 +77,7 @@ class Lorawan extends utils.Adapter {
             await this.messagehandler.setCustomObjectAtStartup();
 
             //Subscribe all configuration and control states
-            this.subscribeStatesAsync('*');
+            await this.subscribeStatesAsync('*');
             //this.subscribeObjectsAsync('*.uplink.decoded.*');
             //this.subscribeObjectsAsync('*.downlink.control.*');
             this.log.debug(`the adapter starts with downlinkconfigs: ${JSON.stringify(this.config.downlinkConfig)}.`);
@@ -420,11 +420,30 @@ class Lorawan extends utils.Adapter {
      * @param id id of the changed object
      * @param obj value and ack of the changed object
      */
-    /*async onObjectChange(id, obj) {
+    async onObjectChange(id, obj) {
         this.log.debug(`${id} is changed into ${JSON.stringify(obj.common)}`);
-        // Erzeugen der HA Bridged für Control
-        await this.messagehandler?.directoryhandler.setCustomForHaBridge(id, obj.common);
-    }*/
+
+        // Only work, if bridge is activ
+        if (this.bridge) {
+            // Erzeugen der HA Bridged für Control
+            // check for new Entry
+            const members = obj.common.members;
+            for (const member of members) {
+                if (!this.bridge.ForeignBridgeMembers[member]) {
+                    await this.bridge?.discoverForeignRange(member);
+                    return;
+                }
+            }
+
+            // check for Entry removed
+            for (const member of Object.values(this.bridge.ForeignBridgeMembers)) {
+                if (!members.includes(member)) {
+                    await this.bridge.discoverForeignRange(member, true);
+                    return;
+                }
+            }
+        }
+    }
 
     /**
      * Is called if a subscribed state changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.lorawan",
-  "version": "1.16.2",
+  "version": "1.16.4",
   "description": "converts the desired lora gateway data to a ioBroker structure",
   "author": {
     "name": "BenAhrdt",