Fix event parsing: use correct PlantEventDTO field names

The coordinator was mapping non-existent API fields (message,
timestamp, circuitPath, isActive) instead of the actual PlantEventDTO
fields (description, timeOccurred, sourcePath, timeResolved). This
caused all event sensors to show None and the error binary sensor
to never trigger.

Changes:
- Map correct API fields: description, timeOccurred, timeResolved,
  sourcePath, code
- Derive is_active from timeResolved (null = active) instead of
  non-existent isActive field
- Add warning events to has_error detection (was only blocking/locking)
- Extract _parse_event() helper for DRY event parsing
- Update sensor value_fn lambdas for renamed dataclass fields
- Update diagnostics PII redaction for renamed fields
- Add 7 tests for event parsing and is_active logic

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: trcyberoptic

CLAUDE.md

@@ -30,7 +30,7 @@ The integration lives in `custom_components/hoval_connect/`. User setup is email
 - `fan.py` — Fan entity for HV ventilation: 0–100% speed slider (`FanEntityFeature.SET_SPEED`), on/off toggle (standby ↔ temporary-change), debounced slider input (1.5s), proper cleanup via `async_will_remove_from_hass`. Only created for HV circuits.
 - `select.py` — Select entity for program selection (week1/week2/ecoMode/standby/constant). Shows user-defined program names from the API (`circuit.program_names`), falls back to `DEFAULT_NAMES`. Bidirectional mapping via `_display_name()` / `_api_key_from_display()`. Only created for HV/HK circuits.
 - `sensor.py` — 9 sensor entities per circuit (outside temp, exhaust temp, air volume, humidity actual/target, operation mode, active week/day program, program air volume) + 6 plant-level sensors (latest event type/message/time, active event count, weather condition/temperature). Diagnostic sensors use `EntityCategory.DIAGNOSTIC`.
-- `binary_sensor.py` — 2 binary sensors per plant (online status with connectivity class, error status with problem class)
+- `binary_sensor.py` — 2 binary sensors per plant (online status with connectivity class, error/warning status with problem class — triggers on active blocking/locking/warning events)
 - `diagnostics.py` — Diagnostic data export with automatic PII redaction
 - `const.py` — Constants: API URLs, OAuth client ID, token TTLs (25min ID, 12min PAT), polling interval (configurable, default 60s), circuit types + human-readable names, operation modes, duration enums (FOUR/MIDNIGHT)
 - `__init__.py` — Entry setup, runtime data, platform forwarding (binary_sensor, climate, fan, select, sensor), DeviceInfo helpers (`plant_device_info`, `circuit_device_info`), options update listener for dynamic polling interval changes
@@ -92,6 +92,8 @@ HK (heating), BL (boiler), WW (warm water), FRIWA (fresh water), HV (ventilation
 - v3 `activeProgram` enum: `constant`, `ecoMode`, `standby`, `week1`, `week2`, `manual`, `externalConstant`
 - The integration fetches circuits via v1 but controls via v3 — coordinator normalizes v1 values to v3 via `_V1_PROGRAM_MAP`
 - Weather forecast available via `get_weather()` — returns condition + temperature
+- `PlantEventDTO` fields: `eventType`, `description`, `timeOccurred`, `timeResolved`, `sourcePath`, `code`, `module`, `functionGroup`, `function`, `category` — event is active when `timeResolved` is null
+- Event types: `locking`, `blocking`, `warning`, `info`, `offline`, `ok` — the error binary sensor triggers on active `blocking`, `locking`, or `warning` events
 
 ## HA Compatibility Notes
 

custom_components/hoval_connect/coordinator.py

@@ -83,10 +83,16 @@ class HovalEventData:
     """Parsed data for a plant event."""
 
     event_type: str | None = None
-    message: str | None = None
-    timestamp: str | None = None
-    circuit_path: str | None = None
-    is_active: bool = False
+    description: str | None = None
+    time_occurred: str | None = None
+    time_resolved: str | None = None
+    source_path: str | None = None
+    code: int | None = None
+
+    @property
+    def is_active(self) -> bool:
+        """Event is active when it has not been resolved."""
+        return self.time_resolved is None
 
 
 @dataclass
@@ -140,6 +146,18 @@ class HovalData:
     plants: dict[str, HovalPlantData] = field(default_factory=dict)
 
 
+def _parse_event(raw: dict) -> HovalEventData:
+    """Parse a PlantEventDTO dict into HovalEventData."""
+    return HovalEventData(
+        event_type=raw.get("eventType"),
+        description=raw.get("description"),
+        time_occurred=raw.get("timeOccurred"),
+        time_resolved=raw.get("timeResolved"),
+        source_path=raw.get("sourcePath"),
+        code=raw.get("code"),
+    )
+
+
 DEFAULT_FAN_SPEED = 40
 
 
@@ -387,17 +405,12 @@ async def _fetch_circuit(
                 # Process latest event
                 latest_result = all_results[latest_idx]
                 if not isinstance(latest_result, BaseException) and latest_result:
-                    plant_data.latest_event = HovalEventData(
-                        event_type=latest_result.get("eventType"),
-                        message=latest_result.get("message"),
-                        timestamp=latest_result.get("timestamp"),
-                        circuit_path=latest_result.get("circuitPath"),
-                        is_active=latest_result.get("isActive", False),
-                    )
+                    plant_data.latest_event = _parse_event(latest_result)
                     _LOGGER.debug(
-                        "Latest event: type=%s active=%s",
-                        latest_result.get("eventType"),
-                        latest_result.get("isActive"),
+                        "Latest event: type=%s active=%s desc=%s",
+                        plant_data.latest_event.event_type,
+                        plant_data.latest_event.is_active,
+                        plant_data.latest_event.description,
                     )
                 elif isinstance(latest_result, BaseException):
                     _LOGGER.debug("Events endpoint not available for %s", plant_id)
@@ -406,17 +419,13 @@ async def _fetch_circuit(
                 events_result = all_results[events_idx]
                 if not isinstance(events_result, BaseException) and events_result:
                     for ev in events_result[:10]:
-                        plant_data.events.append(
-                            HovalEventData(
-                                event_type=ev.get("eventType"),
-                                message=ev.get("message"),
-                                timestamp=ev.get("timestamp"),
-                                circuit_path=ev.get("circuitPath"),
-                                is_active=ev.get("isActive", False),
-                            )
-                        )
+                        plant_data.events.append(_parse_event(ev))
                     for ev in plant_data.events:
-                        if ev.is_active and ev.event_type in ("blocking", "locking"):
+                        if ev.is_active and ev.event_type in (
+                            "blocking",
+                            "locking",
+                            "warning",
+                        ):
                             plant_data.has_error = True
                             break
                 elif isinstance(events_result, BaseException):

custom_components/hoval_connect/diagnostics.py

@@ -19,8 +19,7 @@
     "plantExternalId",
     "name",
     "description",
-    "circuit_path",
-    "message",
+    "source_path",
 }
 
 

custom_components/hoval_connect/sensor.py

@@ -122,14 +122,14 @@ class HovalPlantSensorEntityDescription(SensorEntityDescription):
         translation_key="latest_event_message",
         icon="mdi:message-alert-outline",
         entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda p: p.latest_event.message if p.latest_event else None,
+        value_fn=lambda p: p.latest_event.description if p.latest_event else None,
     ),
     HovalPlantSensorEntityDescription(
         key="latest_event_time",
         translation_key="latest_event_time",
         device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda p: p.latest_event.timestamp if p.latest_event else None,
+        value_fn=lambda p: p.latest_event.time_occurred if p.latest_event else None,
     ),
     HovalPlantSensorEntityDescription(
         key="active_events",

tests/test_coordinator.py

@@ -31,6 +31,8 @@
 from custom_components.hoval_connect.coordinator import (  # noqa: E402
     _V1_PROGRAM_MAP,
     HovalCircuitData,
+    HovalEventData,
+    _parse_event,
     _resolve_active_program_value,
     resolve_fan_speed,
 )
@@ -229,3 +231,56 @@ def test_v3_values_pass_through(self):
 
     def test_none_passes_through(self):
         assert _V1_PROGRAM_MAP.get(None, None) is None
+
+
+class TestParseEvent:
+    """Tests for _parse_event() and HovalEventData."""
+
+    def test_parse_full_event(self):
+        raw = {
+            "eventType": "warning",
+            "description": "Filterwechsel erforderlich",
+            "timeOccurred": "2026-02-17T10:30:00Z",
+            "timeResolved": None,
+            "sourcePath": "520.50.0",
+            "code": 12345,
+        }
+        ev = _parse_event(raw)
+        assert ev.event_type == "warning"
+        assert ev.description == "Filterwechsel erforderlich"
+        assert ev.time_occurred == "2026-02-17T10:30:00Z"
+        assert ev.time_resolved is None
+        assert ev.source_path == "520.50.0"
+        assert ev.code == 12345
+
+    def test_active_when_not_resolved(self):
+        ev = _parse_event({"eventType": "warning", "timeResolved": None})
+        assert ev.is_active is True
+
+    def test_inactive_when_resolved(self):
+        ev = _parse_event({"eventType": "warning", "timeResolved": "2026-02-17T12:00:00Z"})
+        assert ev.is_active is False
+
+    def test_active_when_time_resolved_missing(self):
+        """If API doesn't return timeResolved at all, event is active."""
+        ev = _parse_event({"eventType": "blocking"})
+        assert ev.is_active is True
+
+    def test_parse_empty_dict(self):
+        ev = _parse_event({})
+        assert ev.event_type is None
+        assert ev.description is None
+        assert ev.time_occurred is None
+        assert ev.time_resolved is None
+        assert ev.source_path is None
+        assert ev.code is None
+        assert ev.is_active is True  # no timeResolved → active
+
+    def test_default_event_data_is_active(self):
+        """Default HovalEventData has no timeResolved so is active."""
+        ev = HovalEventData()
+        assert ev.is_active is True
+
+    def test_resolved_event_data(self):
+        ev = HovalEventData(time_resolved="2026-02-17T12:00:00Z")
+        assert ev.is_active is False

tests/test_diagnostics.py

@@ -49,5 +49,4 @@ def test_coordinator_redacts_pii(self):
         """Verify that names/descriptions that could identify the user are redacted."""
         assert "name" in REDACT_COORDINATOR
         assert "description" in REDACT_COORDINATOR
-        assert "circuit_path" in REDACT_COORDINATOR
-        assert "message" in REDACT_COORDINATOR
+        assert "source_path" in REDACT_COORDINATOR