feat(mqtt): make req_id optional for all MQTT command payloads

The 'req_id' field in MQTT command payloads is now optional. This required
changes to the JSON schema validation and the response handling logic.

- Updates `BASE_SCHEMA` and `SEND_MSG_SCHEMA` in `signalduino/commands.py` to remove the `req_id` requirement.
- Modifies `MqttCommandDispatcher.dispatch` to return `None` for `req_id` if not present in the payload.
- Adjusts `MqttPublisher._handle_command` to correctly extract the optional `req_id` for success and error responses.
- Adds `test_controller_handles_get_frequency_without_req_id` to verify the new optional behavior.
- Updates `docs/architecture/proposals/mqtt_set_commands.adoc` to document the optional nature of `req_id`.

Author: sidey79

.vscode/settings.json

@@ -52,7 +52,7 @@
             "host": "mqtt",
             "port": 1883,
             "clientId": "vsmqtt_client_db93",
-            "savedSubscriptions": ['signalduino/v1/responses','signalduino/v1/commands','signalduino/v1/errors']
+            "savedSubscriptions": ['signalduino/v1/responses','signalduino/v1/messages','signalduino/v1/errors']
         }
     ]
 }

docs/architecture/proposals/mqtt_set_commands.adoc

@@ -93,6 +93,13 @@ Die Methoden in `SignalduinoCommands` sind für die Umrechnung und das Senden de
 * **Befehlssatz:** Verwendet den generischen Register-Write-Befehl `W1D`. Die Umrechnungslogik von dB-Wert in den Registerindex (`00`-`07`) erfolgt in der Python-Implementierung.
 * **Serial Command:** `W1D<Index>`, gefolgt von `cc1101_write_init()`.
 
+=== 3.2. MQTT Payload und `req_id`-Behandlung
+
+Das Feld `req_id` in allen MQTT-Command-Payloads (sowohl `set/...` als auch `get/...` und `command/...`) ist ab sofort *optional*.
+
+* **Anfrage:** Wird `req_id` nicht in der Anfrage gesendet, darf die Payload-Validierung nicht fehlschlagen.
+* **Antwort:** Bei Fehlen der `req_id` in der Anfrage wird das Feld `req_id` in der Antwort-Payload (Topics `responses` und `errors`) den Wert `null` (JSON null) annehmen.
+
 == 4. Fehlerbehandlung und Validierung
 1. **Validierung (Dispatcher):** Die MQTT-Payloads werden durch das in [`SignalduinoCommands.COMMAND_MAP`](signalduino/commands.py) definierte `schema` (z.B. `FREQ_SCHEMA`, `DATARATE_SCHEMA`) vor dem Aufruf der Controller-Methode validiert.
 2. **Serial-Kommunikation:** `SignalduinoCommands._send_command` wird bei Timeout eine `SignalduinoCommandTimeout` werfen. Diese wird im `SignalduinoController` gefangen und als NACK-Statusmeldung zurückgegeben.

signalduino/commands.py

@@ -416,7 +416,7 @@ async def cc1101_write_init(self) -> None:
         "value": {"type": ["string", "number", "boolean", "null"], "description": "Main value for SET commands."},
         "parameters": {"type": "object", "description": "Additional parameters for complex commands (e.g., sendMsg)."},
     },
-    "required": ["req_id"],
+    "required": [], # req_id ist jetzt optional
     "additionalProperties": False
 }
 
@@ -425,8 +425,8 @@ def create_value_schema(value_schema: Dict[str, Any]) -> Dict[str, Any]:
     schema = BASE_SCHEMA.copy()
     schema['properties'] = BASE_SCHEMA['properties'].copy()
     schema['properties']['value'] = value_schema
-    # Erstelle eine neue 'required'-Liste, um das Problem der flachen Kopie und der Mutationen zu beheben
-    schema['required'] = BASE_SCHEMA['required'] + ['value']
+    # Da BASE_SCHEMA['required'] jetzt leer ist, fügen wir nur 'value' hinzu
+    schema['required'] = ['value']
     return schema
 
 # --- CC1101 SPEZIFISCHE SCHEMATA (PHASE 2) ---
@@ -492,7 +492,7 @@ def create_value_schema(value_schema: Dict[str, Any]) -> Dict[str, Any]:
             "additionalProperties": False,
         }
     },
-    "required": ["req_id", "parameters"],
+    "required": ["parameters"],
     "additionalProperties": False
 }
 
@@ -598,6 +598,6 @@ async def dispatch(self, command_path: str, payload: str) -> Dict[str, Any]:
         # 4. Prepare Response
         return {
             "status": "OK",
-            "req_id": payload_dict["req_id"],
+            "req_id": payload_dict.get("req_id", None), # req_id ist jetzt optional
             "data": result
         }

signalduino/mqtt.py

@@ -162,17 +162,29 @@ async def _handle_command(self, command_name: str, payload: str) -> None:
 
         self.logger.info("Handling command: %s with payload: %s", command_name, payload)
 
-        req_id = "NO_REQ_ID" # Standard-req_id, falls das Parsing fehlschlägt
+        req_id: Optional[str] = None
+        
+        # Versuche, req_id aus dem Payload zu extrahieren, falls es sich um gültiges JSON handelt.
+        try:
+            payload_dict = json.loads(payload)
+            req_id = payload_dict.get("req_id")
+        except json.JSONDecodeError:
+            # Der Payload ist kein gültiges JSON. req_id bleibt None, und der Dispatcher
+            # wird dies als CommandValidationError behandeln, wenn er json.loads erneut aufruft.
+            pass
 
         try:
             # Der Dispatcher gibt ein Ergebnis-Dictionary mit 'status', 'req_id', 'data' zurück.
             result = await self.dispatcher.dispatch(command_name, payload)
-            req_id = result.get("req_id", req_id)
+            
+            # Der Dispatcher kann req_id als None zurückgeben, wenn sie nicht im Payload war.
+            # Wir überschreiben req_id mit dem Ergebnis, um Konsistenz zu gewährleisten.
+            req_id = result.get("req_id") # Kann None sein
 
             response_payload = {
                 "command": command_name,
                 "success": True,
-                "req_id": req_id,
+                "req_id": req_id, # Kann None sein, was in JSON zu null wird
                 "payload": result.get("data"),
             }
 
@@ -185,33 +197,27 @@ async def _handle_command(self, command_name: str, payload: str) -> None:
 
         except (CommandValidationError, SignalduinoCommandTimeout) as e:
             self.logger.warning("Command failed (Validation/Timeout): %s: %s", command_name, e)
-            # req_id kann von der Validierung extrahiert werden, falls der Payload gültiges JSON ist
-            try:
-                # Da der Dispatcher JSON.loads(payload) aufruft und fehlschlagen kann, wenn JSON ungültig ist,
-                # müssen wir hier vorsichtiger sein. Ist der Payload gültig, holen wir die req_id.
-                payload_dict = json.loads(payload)
-                req_id = payload_dict.get("req_id", req_id)
-            except json.JSONDecodeError:
-                pass # req_id bleibt "NO_REQ_ID"
 
             await self.publish_simple(
                 subtopic="errors",
                 payload=json.dumps({
                     "command": command_name,
                     "success": False,
-                    "req_id": req_id,
+                    "req_id": req_id, # Verwendet die oben extrahierte (oder None)
                     "error": str(e),
                 }),
                 retain=False
             )
         except Exception:
+            # Wenn ein interner Fehler auftritt (z.B. im Controller),
+            # verwenden wir die zuvor extrahierte req_id.
             self.logger.exception("Internal error during command dispatching: %s", command_name)
             await self.publish_simple(
                 subtopic="errors",
                 payload=json.dumps({
                     "command": command_name,
                     "success": False,
-                    "req_id": req_id,
+                    "req_id": req_id, # Verwendet die oben extrahierte (oder None)
                     "error": "Internal server error during command execution.",
                 }),
                 retain=False

tests/test_mqtt_commands.py

@@ -299,6 +299,63 @@ async def test_controller_handles_get_frequency(signalduino_controller, mock_aio
             call(command='C0F', expect_response=True, timeout=2.0, response_pattern=expected_pattern),
         ])
 
+@pytest.mark.asyncio
+async def test_controller_handles_get_frequency_without_req_id(signalduino_controller, mock_aiomqtt_client_cls, mock_logger):
+    """
+    Testet den 'get/cc1101/frequency' MQTT-Befehl, wenn keine req_id gesendet wird.
+    Die resultierende Response sollte eine req_id von None enthalten (was in JSON zu null wird).
+    """
+    # Wir benötigen 'call' aus unittest.mock, das am Anfang der Datei importiert wurde.
+
+    # Simuliere die Antworten für die drei Register-Lesebefehle (C0D, C0E, C0F)
+    # FREQ2 (0D) -> 0x21
+    # FREQ1 (0E) -> 0x62
+    # FREQ0 (0F) -> 0x00
+    mock_responses = [
+        "C0D = 21", # FREQ2
+        "C0E = 62", # FREQ1
+        "C0F = 00", # FREQ0
+    ]
+    
+    send_command_mock = AsyncMock(side_effect=mock_responses)
+    
+    # Überschreibe die interne Referenz im Commands-Objekt, da es sich um ein gebundenes Callable handelt
+    signalduino_controller.commands._send_command = send_command_mock
+
+    # 1. Dispatcher und Payload vorbereiten (keine req_id!)
+    command_path = "get/cc1101/frequency"
+    mqtt_payload = '{}'
+    
+    dispatcher = MqttCommandDispatcher(controller=signalduino_controller)
+
+    # 2. Asynchronen Kontext des Controllers starten
+    async with signalduino_controller:
+    
+        # 3. Dispatch ausführen
+        result = await dispatcher.dispatch(command_path, mqtt_payload)
+        
+        # 4. Assertions
+        
+        # Berechne erwartete Frequenz
+        FXOSC = 26.0
+        DIVIDER = 65536.0
+        f_reg = (0x21 << 16) | (0x62 << 8) | 0x00
+        expected_frequency = (FXOSC / DIVIDER) * f_reg
+        expected_frequency_rounded = round(expected_frequency, 4)
+        
+        assert result['status'] == "OK"
+        assert result['req_id'] is None # <- CRITICAL: Überprüfe, dass req_id None ist
+        assert result['data']['frequency_mhz'] == expected_frequency_rounded
+        
+        # Überprüfe, ob send_command mit den korrekten Argumenten aufgerufen wurde (gleiche Calls wie zuvor)
+        expected_pattern = re.compile(r'C[A-Fa-f0-9]{2}\s=\s[0-9A-Fa-f]+$|ccreg 00:')
+
+        send_command_mock.assert_has_calls([
+            call(command='C0D', expect_response=True, timeout=2.0, response_pattern=expected_pattern),
+            call(command='C0E', expect_response=True, timeout=2.0, response_pattern=expected_pattern),
+            call(command='C0F', expect_response=True, timeout=2.0, response_pattern=expected_pattern),
+        ])
+
 @pytest.mark.asyncio
 async def test_controller_handles_set_factory_reset(signalduino_controller, mock_aiomqtt_client_cls, mock_logger):
     """Test handling of the 'set/factory_reset' command, ensuring the 'e' command is sent."""