fix(dcl): resolve OPC UA alarm type NodeId to friendly name so conditionFilter works (#8)

HandleAlarmEvent set AlarmTypeName to the event-type NodeId string ("i=9341"),
but the client-side conditionFilter gate (and the OPC UA WhereClause) use friendly
type names — so a friendly-name filter built a correct server WhereClause yet the
client gate dropped every event (zero alarms delivered). Resolve the event-type
NodeId to its friendly name via an inverse of KnownConditionTypeIds (NodeId-string
fallback for custom types) so both sides agree. Also fix a dead-code ternary in
the SourceName derivation.

src/ZB.MOM.WW.ScadaBridge.DataConnectionLayer/Adapters/RealOpcUaClient.cs

@@ -296,8 +296,12 @@ public class RealOpcUaClient : IOpcUaClient
     /// optional server-side WhereClause (M2.4 / #8). Only standard types appear
     /// here; vendor/custom type names cannot be mapped without browsing the server
     /// type tree, so they are handled by the client-side gate alone.
+    /// <para>
+    /// Single source of truth for both directions: <see cref="ConditionTypeNamesById"/>
+    /// is derived from this map, so the friendly-name and NodeId sides cannot drift.
+    /// </para>
     /// </summary>
-    private static readonly IReadOnlyDictionary<string, NodeId> KnownConditionTypeIds =
+    internal static readonly IReadOnlyDictionary<string, NodeId> KnownConditionTypeIds =
         new Dictionary<string, NodeId>(StringComparer.OrdinalIgnoreCase)
         {
             ["ConditionType"] = ObjectTypeIds.ConditionType,
@@ -322,6 +326,40 @@ public class RealOpcUaClient : IOpcUaClient
             ["CertificateExpirationAlarmType"] = ObjectTypeIds.CertificateExpirationAlarmType,
         };
 
+    /// <summary>
+    /// Inverse of <see cref="KnownConditionTypeIds"/> (NodeId → friendly name), derived
+    /// from it so the two cannot drift (M2.4 / #8). Used by <see cref="ResolveAlarmTypeName"/>
+    /// to translate the event-type NodeId an OPC UA server sends back into the friendly
+    /// type name the conditionFilter gate and server-side WhereClause both key off.
+    /// </summary>
+    private static readonly IReadOnlyDictionary<NodeId, string> ConditionTypeNamesById =
+        KnownConditionTypeIds.ToDictionary(kv => kv.Value, kv => kv.Key);
+
+    /// <summary>
+    /// Resolves an event-type <see cref="NodeId"/> to the friendly condition-type name the
+    /// <c>conditionFilter</c> gate (and the server-side WhereClause) use (M2.4 / #8).
+    ///
+    /// <para>
+    /// Standard A&amp;C types are returned as their friendly name (e.g. <c>i=9341</c> →
+    /// <c>"ExclusiveLevelAlarmType"</c>) so the client-side gate — which compares against
+    /// the friendly names in <see cref="KnownConditionTypeIds"/> — actually matches the
+    /// events the server delivers. Vendor/custom subtypes that are not in the map fall back
+    /// to the NodeId string; that is consistent because the WhereClause is likewise omitted
+    /// for unmapped names, so such a filter can only be expressed (and matched) as the NodeId
+    /// string. A <c>null</c> event type yields the empty string.
+    /// </para>
+    /// </summary>
+    /// <param name="eventType">The event-type NodeId from the A&amp;C notification, or <c>null</c>.</param>
+    /// <returns>The friendly type name when known; otherwise the NodeId string (or "" when null).</returns>
+    internal static string ResolveAlarmTypeName(NodeId? eventType)
+    {
+        if (eventType is null)
+            return "";
+        return ConditionTypeNamesById.TryGetValue(eventType, out var friendly)
+            ? friendly
+            : eventType.ToString();
+    }
+
     /// <summary>
     /// Builds the event filter selecting the base event fields plus the
     /// AlarmConditionType / AcknowledgeableConditionType state sub-variables we mirror,
@@ -446,7 +484,12 @@ public class RealOpcUaClient : IOpcUaClient
             return;
         }
 
-        var sourceName = fields[1].Value is NodeId ? (fields[2].Value as string ?? "") : (fields[2].Value as string ?? "");
+        // Field layout (AlarmStateFields): [1]=SourceNode (NodeId), [2]=SourceName (string).
+        // Prefer the human-readable SourceName; fall back to the SourceNode NodeId string
+        // only when SourceName is absent/empty, so the condition still has a stable key.
+        var sourceName = fields[2].Value as string;
+        if (string.IsNullOrEmpty(sourceName))
+            sourceName = (fields[1].Value as NodeId)?.ToString() ?? "";
         var conditionName = fields.Count > 11 ? fields[11].Value as string : null;
         var sourceObjectRef = sourceName;
         var sourceRef = string.IsNullOrEmpty(conditionName) ? sourceName : $"{sourceName}.{conditionName}";
@@ -476,7 +519,9 @@ public class RealOpcUaClient : IOpcUaClient
         onTransition(new NativeAlarmTransition(
             SourceReference: sourceRef,
             SourceObjectReference: sourceObjectRef,
-            AlarmTypeName: eventType?.ToString() ?? "",
+            // Resolve the event-type NodeId (e.g. "i=9341") to the friendly type name
+            // the conditionFilter gate keys off (M2.4 / #8); NodeId-string for custom types.
+            AlarmTypeName: ResolveAlarmTypeName(eventType),
             Kind: kind,
             Condition: OpcUaAlarmMapper.BuildCondition(active, acked, confirmed, shelve, suppressed, severity),
             Category: "",