feat(scripted-alarms): richer AlarmConditionState bridge to the OPC UA node (T15)

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/OpcUa/OpcUaPublishActor.cs

@@ -30,7 +30,15 @@ public sealed class OpcUaPublishActor : ReceiveActor
     public const string RedundancyStateTopic = "redundancy-state";
 
     public sealed record AttributeValueUpdate(string NodeId, object? Value, OpcUaQuality Quality, DateTime TimestampUtc);
-    public sealed record AlarmStateUpdate(string AlarmNodeId, bool Active, bool Acknowledged, DateTime TimestampUtc);
+
+    /// <summary>Carries the full Part 9 condition state for a scripted alarm to the sink. The
+    /// <paramref name="State"/> snapshot is the Commons projection the Runtime host maps from the engine's
+    /// Core <c>AlarmConditionState</c> + severity/message — the actor stays decoupled from
+    /// <c>Core.ScriptedAlarms</c>.</summary>
+    /// <param name="AlarmNodeId">The alarm node id (== ScriptedAlarmId for materialised conditions).</param>
+    /// <param name="State">The full condition state to project onto the node.</param>
+    /// <param name="TimestampUtc">The source timestamp of the transition in UTC.</param>
+    public sealed record AlarmStateUpdate(string AlarmNodeId, AlarmConditionSnapshot State, DateTime TimestampUtc);
     /// <summary>
     ///     Triggers an address-space rebuild. <paramref name="DeploymentId"/> is the deployment
     ///     just applied by the host; the rebuild loads THAT artifact so materialisation matches the
@@ -167,13 +175,13 @@ public sealed class OpcUaPublishActor : ReceiveActor
     {
         try
         {
-            _sink.WriteAlarmState(msg.AlarmNodeId, msg.Active, msg.Acknowledged, msg.TimestampUtc);
+            _sink.WriteAlarmCondition(msg.AlarmNodeId, msg.State, msg.TimestampUtc);
             Interlocked.Increment(ref _writes);
             OtOpcUaTelemetry.OpcUaSinkWrite.Add(1, new KeyValuePair<string, object?>("kind", "alarm"));
         }
         catch (Exception ex)
         {
-            _log.Warning(ex, "OpcUaPublish: sink.WriteAlarmState threw for {Node}", msg.AlarmNodeId);
+            _log.Warning(ex, "OpcUaPublish: sink.WriteAlarmCondition threw for {Node}", msg.AlarmNodeId);
         }
     }
 

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/ScriptedAlarms/ScriptedAlarmHostActor.cs

@@ -2,6 +2,7 @@ using Akka.Actor;
 using Akka.Cluster.Tools.PublishSubscribe;
 using Akka.Event;
 using ZB.MOM.WW.OtOpcUa.Commons.Messages.Alerts;
+using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
 using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 using ZB.MOM.WW.OtOpcUa.Core.ScriptedAlarms;
 using ZB.MOM.WW.OtOpcUa.OpcUaServer;
@@ -234,13 +235,12 @@ public sealed class ScriptedAlarmHostActor : ReceiveActor
             return;
         }
 
-        // Bridge to OPC UA: drive the alarm node's Active / Acknowledged sub-vars. We use e.AlarmId as
-        // the node id for now — T14 will materialise the real condition node at an aligned NodeId and
-        // this id will line up with it.
+        // Bridge to OPC UA: project the FULL Part 9 condition state (enabled/active/acked/confirmed/
+        // shelving/severity/message) onto the materialised condition node via the Commons snapshot.
+        // e.AlarmId is the materialised condition's NodeId (T14 aligned it to the ScriptedAlarmId).
         _publishActor.Tell(new OpcUaPublishActor.AlarmStateUpdate(
             AlarmNodeId: e.AlarmId,
-            Active: e.Condition.Active == AlarmActiveState.Active,
-            Acknowledged: e.Condition.Acked == AlarmAckedState.Acknowledged,
+            State: ToSnapshot(e),
             TimestampUtc: e.TimestampUtc));
 
         // Publish the transition to the cluster `alerts` topic — the single historization + live
@@ -297,6 +297,29 @@ public sealed class ScriptedAlarmHostActor : ReceiveActor
         HistorizeToAveva: p.HistorizeToAveva,
         Retain: p.Retain);
 
+    /// <summary>Maps a <see cref="ScriptedAlarmEvent"/>'s Core <see cref="AlarmConditionState"/> +
+    /// severity/message down to the Commons <see cref="AlarmConditionSnapshot"/> the SDK sink projects.
+    /// Severity is the OPC UA 1..1000 value <see cref="SeverityToInt"/> derives from the coarse engine
+    /// bucket, cast to the <c>ushort</c> the SDK <c>SetSeverity</c> expects. Shelving's 3-way Core kind
+    /// maps 1:1 onto the Commons <see cref="AlarmShelvingKind"/>.</summary>
+    private static AlarmConditionSnapshot ToSnapshot(ScriptedAlarmEvent e) => new(
+        Active: e.Condition.Active == AlarmActiveState.Active,
+        Acknowledged: e.Condition.Acked == AlarmAckedState.Acknowledged,
+        Confirmed: e.Condition.Confirmed == AlarmConfirmedState.Confirmed,
+        Enabled: e.Condition.Enabled == AlarmEnabledState.Enabled,
+        Shelving: MapShelving(e.Condition.Shelving.Kind),
+        Severity: (ushort)SeverityToInt(e.Severity),
+        Message: e.Message);
+
+    /// <summary>Maps the Core <see cref="ShelvingKind"/> onto the Commons <see cref="AlarmShelvingKind"/>
+    /// mirror (the Commons assembly can't see the Core enum).</summary>
+    private static AlarmShelvingKind MapShelving(ShelvingKind kind) => kind switch
+    {
+        ShelvingKind.OneShot => AlarmShelvingKind.OneShot,
+        ShelvingKind.Timed => AlarmShelvingKind.Timed,
+        _ => AlarmShelvingKind.Unshelved,
+    };
+
     /// <summary>The acting user for an <see cref="AlarmTransitionEvent"/>. Engine-driven
     /// Activated / Cleared transitions are <c>"system"</c>; operator Acknowledged / Confirmed carry the
     /// recorded user from the condition state, falling back to <c>"system"</c> when none was recorded.</summary>