Merge feat/677-aggregates: reverse processed reads SDK-anchored, start-of-data Partial (forward), AggregateConfiguration accept-defaults, IntegralDivisor=1, SDK parity tests (#677)

src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/OtOpcUaNodeManager.cs

@@ -5051,6 +5051,8 @@ public sealed class OtOpcUaNodeManager : CustomNodeManager2
     {
         // OPC UA ProcessingInterval is a Duration in milliseconds — convert once per batch.
         var interval = TimeSpan.FromMilliseconds(details.ProcessingInterval);
+        // #677: a client AggregateConfiguration other than the server defaults is refused per node, never silently ignored.
+        var configurationServable = ServerAggregateConfiguration.IsServable(details.AggregateConfiguration);
         nodesToProcess = AuthorizeHistoryRead(context, nodesToProcess, results, errors);
         WithHistoryReadBatchLimiter(nodesToProcess, results, errors, () =>
         {
@@ -5069,6 +5071,12 @@ public sealed class OtOpcUaNodeManager : CustomNodeManager2
                     continue;
                 }
 
+                if (!configurationServable)
+                {
+                    errors[handle.Index] = StatusCodes.BadAggregateConfigurationRejected;
+                    continue;
+                }
+
                 // Processed is SINGLE-SHOT (no continuation point). Unlike Raw, ReadProcessedDetails carries
                 // NO client count cap (NumValuesPerNode) — the bucket count is deterministic (window / interval)
                 // and the single-shot backend returns every bucket in one read, so there is no "full page ⇒

src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/ServerAggregateConfiguration.cs

@@ -0,0 +1,62 @@
+using Opc.Ua;
+
+namespace ZB.MOM.WW.OtOpcUa.OpcUaServer;
+
+/// <summary>
+///     The Part 13 <see cref="AggregateConfiguration"/> processed reads are evaluated under (#677), and the rule for a
+///     client-supplied one in <c>ReadProcessedDetails</c>.
+/// </summary>
+/// <remarks>
+///     <para>
+///         The aggregate evaluators (<c>AggregateEvaluator</c> / <c>TimeWeightedAggregator</c> in
+///         <c>Driver.Historian.Sql.Common</c>) are written against fixed settings, not parameterised: Uncertain samples and
+///         Uncertain time count as Good (<see cref="TreatUncertainAsBad"/> = false); an interval is Good only when all of
+///         it is (<see cref="PercentDataGood"/> = 100) and Bad only when none of it is non-Bad
+///         (<see cref="PercentDataBad"/> = 100), otherwise <c>UncertainDataSubNormal</c>; the value past the last sample
+///         is held (stepped, <see cref="UseSlopedExtrapolation"/> = false). These are also the SDK's own server defaults
+///         (<c>AggregateManager.GetDefaultConfiguration</c>), which a test pins.
+///     </para>
+///     <para>
+///         A request asking for <c>UseServerCapabilitiesDefaults</c>, or spelling out exactly these values, is served;
+///         any other configuration is refused per node with <c>BadAggregateConfigurationRejected</c> rather than silently
+///         answered under settings the client did not ask for (it used to be ignored).
+///     </para>
+/// </remarks>
+public static class ServerAggregateConfiguration
+{
+    /// <summary>Uncertain data is not treated as Bad.</summary>
+    public const bool TreatUncertainAsBad = false;
+
+    /// <summary>An interval is Bad only when 100 % of it is Bad.</summary>
+    public const byte PercentDataBad = 100;
+
+    /// <summary>An interval is Good only when 100 % of it is Good.</summary>
+    public const byte PercentDataGood = 100;
+
+    /// <summary>The value past the last sample is held (stepped), not sloped.</summary>
+    public const bool UseSlopedExtrapolation = false;
+
+    /// <summary>The server defaults as an <see cref="AggregateConfiguration"/> (explicit values, not "use defaults").</summary>
+    public static AggregateConfiguration Defaults => new()
+    {
+        UseServerCapabilitiesDefaults = false,
+        TreatUncertainAsBad = TreatUncertainAsBad,
+        PercentDataBad = PercentDataBad,
+        PercentDataGood = PercentDataGood,
+        UseSlopedExtrapolation = UseSlopedExtrapolation,
+    };
+
+    /// <summary>
+    ///     True when a processed read with <paramref name="requested"/> can be served: none supplied,
+    ///     <c>UseServerCapabilitiesDefaults</c>, or every setting equal to the server's.
+    /// </summary>
+    /// <param name="requested">The request's configuration (may be null).</param>
+    /// <returns>Whether to serve; false ⇒ <c>BadAggregateConfigurationRejected</c>.</returns>
+    public static bool IsServable(AggregateConfiguration? requested) =>
+        requested is null
+        || requested.UseServerCapabilitiesDefaults
+        || (requested.TreatUncertainAsBad == TreatUncertainAsBad
+            && requested.PercentDataBad == PercentDataBad
+            && requested.PercentDataGood == PercentDataGood
+            && requested.UseSlopedExtrapolation == UseSlopedExtrapolation);
+}