dohertj2/scadalink-design
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat(ui): rich AlarmTriggerEditor in instance override modal

Browse Source 
Replaces the per-row JSON textbox with an Edit button that opens a modal
hosting the full AlarmTriggerEditor. The editor pre-populates with the
merged inherited + override config so the operator sees the effective
state, not the override delta.

On Save:
  - HiLo: diff against inherited, store only changed keys
  - Binary trigger types: whole-replace if the edited config differs

Value comparison in the diff is type-aware (decoded strings, numeric
GetDouble) so JSON-escape differences (e.g., literal em-dash vs —)
don't produce false-positive diffs that pollute the override JSON.

FlatteningService.MergeHiLoConfig is now public so the UI can pre-merge
the editor seed; new public DiffHiLoConfig handles the symmetric
direction. +2 encoding tests cover the new equivalence behavior.

The override row's summary column shows the diff'd keys + priority chip
so operators see what's overridden at a glance.
This commit is contained in:
Joseph Doherty
2026-05-13 04:05:08 -04:00
parent 4e446a7170
commit 164d914ba8
3 changed files with 421 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

352
src/ScadaLink.CentralUI/Components/Pages/Deployment/InstanceConfigure.razor
View File

@@ -5,6 +5,7 @@
@using ScadaLink.Commons.Entities.Templates
@using ScadaLink.Commons.Interfaces.Repositories
@using ScadaLink.Commons.Types.Enums
@using ScadaLink.TemplateEngine.Flattening
@using ScadaLink.TemplateEngine.Services
@attribute [Authorize(Policy = AuthorizationPolicies.RequireDeployment)]
@inject ITemplateEngineRepository TemplateEngineRepository
@@ -170,8 +171,8 @@
<div class="card-header py-2">
<strong>Alarm Overrides</strong>
<small class="text-muted ms-2">
For HiLo alarms, override JSON merges into the inherited config setpoint-by-setpoint.
For binary trigger types, override JSON replaces the whole config. Leave both fields empty to inherit.
Click <em>Edit</em> to override an alarm's trigger configuration or priority.
HiLo overrides merge into the inherited setpoints; other trigger types replace the whole config.
</small>
</div>
<div class="card-body p-0">
@@ -187,9 +188,8 @@
<th>Alarm</th>
<th style="width: 110px;">Trigger</th>
<th>Inherited Config</th>
<th style="width: 320px;">Override JSON</th>
<th style="width: 120px;">Priority</th>
<th style="width: 80px;"></th>
<th style="width: 280px;">Override</th>
<th style="width: 140px;">Actions</th>
</tr>
</thead>
<tbody>
@@ -204,19 +204,21 @@
title="@alarm.TriggerConfiguration">
@(alarm.TriggerConfiguration ?? "—")
</td>
<td>
<input type="text" class="form-control form-control-sm font-monospace"
placeholder='@GetAlarmJsonPlaceholder(alarm.TriggerType)'
value="@GetAlarmOverrideJson(alarm.Name)"
@onchange="(e) => OnAlarmOverrideJsonChanged(alarm.Name, e)" />
</td>
<td>
<input type="number" min="0" max="1000" class="form-control form-control-sm"
placeholder="@alarm.PriorityLevel"
value="@GetAlarmOverridePriority(alarm.Name)"
@onchange="(e) => OnAlarmOverridePriorityChanged(alarm.Name, e)" />
<td class="small">
@if (HasOverride(alarm.Name))
{
<span class="badge bg-warning text-dark me-1" title="Override is set">●</span>
<span class="text-muted">@OverrideSummary(alarm.Name)</span>
}
else
{
<span class="text-muted fst-italic">inherited</span>
}
</td>
<td>
<button class="btn btn-outline-primary btn-sm me-1"
@onclick="() => BeginEditOverride(alarm)"
disabled="@_saving">Edit</button>
@if (HasOverride(alarm.Name))
{
<button class="btn btn-outline-danger btn-sm"
@@ -228,13 +230,73 @@
}
</tbody>
</table>
<div class="p-2">
<button class="btn btn-success btn-sm" @onclick="SaveAlarmOverrides" disabled="@_saving">Save Alarm Overrides</button>
</div>
}
</div>
</div>
@* Override edit modal *@
@if (_editingAlarm != null)
{
<div class="modal show d-block" tabindex="-1" style="background: rgba(0,0,0,0.4);">
<div class="modal-dialog modal-dialog-scrollable modal-lg">
<div class="modal-content">
<div class="modal-header">
<h6 class="modal-title">
Edit override: @_editingAlarm.Name
<span class="badge bg-light text-dark border ms-1">@_editingAlarm.TriggerType</span>
</h6>
<button type="button" class="btn-close" aria-label="Close" @onclick="CancelEditOverride"></button>
</div>
<div class="modal-body">
<div class="mb-3 small">
<div class="text-muted text-uppercase fw-semibold mb-1">Inherited from template</div>
<code class="d-block bg-light p-2 rounded text-break">@(_editingAlarm.TriggerConfiguration ?? "(none)")</code>
</div>
<div class="mb-3">
<div class="text-muted text-uppercase small fw-semibold mb-1">Configuration</div>
<AlarmTriggerEditor TriggerType="@_editingAlarm.TriggerType"
Value="@_editingOverrideValue"
ValueChanged="@(v => _editingOverrideValue = v)"
AvailableAttributes="@_editingAvailableAttributes"
FallbackPriority="@_editingAlarm.PriorityLevel" />
</div>
<div class="row g-2">
<div class="col-md-6">
<label class="form-label small text-uppercase text-muted fw-semibold mb-1">
Priority override
</label>
<input type="number" min="0" max="1000" class="form-control form-control-sm"
placeholder="@_editingAlarm.PriorityLevel"
@bind="_editingPriorityText" @bind:event="oninput" />
</div>
</div>
@if (_editingError != null)
{
<div class="alert alert-danger small mt-2 mb-0">@_editingError</div>
}
</div>
<div class="modal-footer justify-content-between">
<div>
@if (HasOverride(_editingAlarm.Name))
{
<button class="btn btn-outline-danger btn-sm"
@onclick="() => ClearFromModal()"
disabled="@_saving">Clear Override</button>
}
</div>
<div>
<button class="btn btn-outline-secondary btn-sm" @onclick="CancelEditOverride">Cancel</button>
<button class="btn btn-success btn-sm" @onclick="SaveOverrideFromModal" disabled="@_saving">Save Override</button>
</div>
</div>
</div>
</div>
</div>
}
@* Area Assignment *@
<div class="card mb-3">
<div class="card-header py-2">
@@ -278,14 +340,18 @@
private List<TemplateAttribute> _overrideAttrs = new();
private Dictionary<string, string?> _overrideValues = new();
// Alarm overrides — keyed by alarm name. Dirty rows live in
// _alarmOverrideJson / _alarmOverridePriority; existing overrides are
// loaded via _existingAlarmOverrides so the UI can show inherited
// placeholders correctly.
// Alarm overrides — read-only state pulled from the repo. The edit modal
// is the only mutation path (one alarm at a time).
private List<TemplateAlarm> _overridableAlarms = new();
private Dictionary<string, InstanceAlarmOverride> _existingAlarmOverrides = new();
private Dictionary<string, string?> _alarmOverrideJson = new();
private Dictionary<string, int?> _alarmOverridePriority = new();
// Override edit modal state — non-null while the modal is open.
private TemplateAlarm? _editingAlarm;
private string? _editingOverrideValue; // current Value parameter for AlarmTriggerEditor
private string? _editingInheritedValue; // the inherited config snapshot we diff against on save
private string? _editingPriorityText;
private string? _editingError;
private IReadOnlyList<AlarmAttributeChoice> _editingAvailableAttributes = Array.Empty<AlarmAttributeChoice>();
// Area
private List<Area> _siteAreas = new();
@@ -338,8 +404,6 @@
foreach (var o in alarmOverrides)
{
_existingAlarmOverrides[o.AlarmCanonicalName] = o;
_alarmOverrideJson[o.AlarmCanonicalName] = o.TriggerConfigurationOverride;
_alarmOverridePriority[o.AlarmCanonicalName] = o.PriorityLevelOverride;
}
}
catch (Exception ex)
@@ -430,42 +494,158 @@
private bool HasOverride(string alarmName) =>
_existingAlarmOverrides.ContainsKey(alarmName);
private string? GetAlarmOverrideJson(string alarmName) =>
_alarmOverrideJson.GetValueOrDefault(alarmName);
private string? GetAlarmOverridePriority(string alarmName) =>
_alarmOverridePriority.GetValueOrDefault(alarmName)?.ToString();
/// <summary>
/// Placeholder hint shown in the JSON override input. Encourages the
/// HiLo "partial JSON" idiom (e.g. {"hi":90}) vs. the binary-trigger
/// "whole-config" idiom.
/// Human-readable summary of the currently-saved override. Lists the
/// HiLo keys that differ from the inherited config plus a priority chip.
/// Used by the row's "Override" column.
/// </summary>
private static string GetAlarmJsonPlaceholder(AlarmTriggerType type) => type switch
private string OverrideSummary(string alarmName)
{
AlarmTriggerType.HiLo => "{\"hi\":90} — partial keys merge",
_ => "{\"attributeName\":\"...\"} — whole-replace"
};
if (!_existingAlarmOverrides.TryGetValue(alarmName, out var ovr))
return "";
private void OnAlarmOverrideJsonChanged(string alarmName, ChangeEventArgs e)
{
var val = e.Value?.ToString();
if (string.IsNullOrWhiteSpace(val))
_alarmOverrideJson.Remove(alarmName);
else
_alarmOverrideJson[alarmName] = val;
var parts = new List<string>();
if (!string.IsNullOrWhiteSpace(ovr.TriggerConfigurationOverride))
{
try
{
using var doc = System.Text.Json.JsonDocument.Parse(ovr.TriggerConfigurationOverride);
if (doc.RootElement.ValueKind == System.Text.Json.JsonValueKind.Object)
{
parts.AddRange(doc.RootElement.EnumerateObject().Select(p => p.Name));
}
}
catch (System.Text.Json.JsonException)
{
parts.Add("(invalid JSON)");
}
}
if (ovr.PriorityLevelOverride.HasValue)
parts.Add($"priority={ovr.PriorityLevelOverride.Value}");
return parts.Count == 0 ? "(empty)" : string.Join(", ", parts);
}
private void OnAlarmOverridePriorityChanged(string alarmName, ChangeEventArgs e)
/// <summary>
/// Opens the override editor modal pre-populated with the merged
/// (inherited + existing override) config so the user sees the effective
/// state — not just the override delta.
/// </summary>
private void BeginEditOverride(TemplateAlarm alarm)
{
var raw = e.Value?.ToString();
if (string.IsNullOrWhiteSpace(raw))
_editingAlarm = alarm;
_editingError = null;
_editingInheritedValue = alarm.TriggerConfiguration;
var existing = _existingAlarmOverrides.GetValueOrDefault(alarm.Name);
// HiLo: merge inherited + override so the editor shows the effective
// setpoints. Binary: pre-fill with the override if present, else the
// inherited config — same idea.
_editingOverrideValue = alarm.TriggerType == AlarmTriggerType.HiLo
? FlatteningService.MergeHiLoConfig(alarm.TriggerConfiguration, existing?.TriggerConfigurationOverride)
: (existing?.TriggerConfigurationOverride ?? alarm.TriggerConfiguration);
_editingPriorityText = existing?.PriorityLevelOverride?.ToString();
_editingAvailableAttributes = _overrideAttrs
.Select(a => new AlarmAttributeChoice(a.Name, MapDataType(a.DataType), "Direct"))
.ToList();
}
private void CancelEditOverride()
{
_editingAlarm = null;
_editingError = null;
}
private async Task SaveOverrideFromModal()
{
if (_editingAlarm == null) return;
_saving = true;
try
{
_alarmOverridePriority.Remove(alarmName);
return;
int? priority = null;
if (!string.IsNullOrWhiteSpace(_editingPriorityText))
{
if (!int.TryParse(_editingPriorityText, out var p))
{
_editingError = "Priority must be an integer.";
_saving = false;
return;
}
priority = p;
}
// Compute the override JSON. For HiLo, diff against inherited so we
// store only the changed keys (matches the merge-on-flatten flow).
// For binary, whole-replace if the edited config differs from
// inherited.
string? overrideJson;
if (_editingAlarm.TriggerType == AlarmTriggerType.HiLo)
{
overrideJson = FlatteningService.DiffHiLoConfig(_editingInheritedValue, _editingOverrideValue);
}
else
{
overrideJson = _editingOverrideValue == _editingInheritedValue
? null
: _editingOverrideValue;
}
var user = await GetCurrentUserAsync();
var alarmName = _editingAlarm.Name;
// No diff + no priority → clear any existing override and close.
if (string.IsNullOrWhiteSpace(overrideJson) && !priority.HasValue)
{
if (_existingAlarmOverrides.ContainsKey(alarmName))
{
var del = await InstanceService.DeleteAlarmOverrideAsync(Id, alarmName, user);
if (!del.IsSuccess)
{
_editingError = del.Error;
_saving = false;
return;
}
_existingAlarmOverrides.Remove(alarmName);
_toast.ShowSuccess($"Cleared override on '{alarmName}'.");
}
else
{
_toast.ShowSuccess("No change.");
}
}
else
{
var result = await InstanceService.SetAlarmOverrideAsync(
Id, alarmName, overrideJson, priority, user);
if (!result.IsSuccess)
{
_editingError = result.Error;
_saving = false;
return;
}
_existingAlarmOverrides[alarmName] = result.Value!;
_toast.ShowSuccess($"Saved override on '{alarmName}'.");
}
_editingAlarm = null;
_editingError = null;
}
if (int.TryParse(raw, out var p))
_alarmOverridePriority[alarmName] = p;
catch (Exception ex)
{
_editingError = ex.Message;
}
_saving = false;
}
private async Task ClearFromModal()
{
if (_editingAlarm == null) return;
var name = _editingAlarm.Name;
await ClearAlarmOverride(name);
_editingAlarm = null;
}
private async Task ClearAlarmOverride(string alarmName)
@@ -478,8 +658,6 @@
if (result.IsSuccess)
{
_existingAlarmOverrides.Remove(alarmName);
_alarmOverrideJson.Remove(alarmName);
_alarmOverridePriority.Remove(alarmName);
_toast.ShowSuccess($"Cleared override on '{alarmName}'.");
}
else
@@ -494,54 +672,22 @@
_saving = false;
}
private async Task SaveAlarmOverrides()
/// <summary>
/// Mirrors TemplateEdit.MapDataType — converts the persisted DataType enum
/// to the canonical SCADA type string the AlarmTriggerEditor compares
/// against (Boolean / Integer / Float / String / Object).
/// </summary>
private static string MapDataType(DataType dt) => dt switch
{
_saving = true;
try
{
var user = await GetCurrentUserAsync();
var touched = _alarmOverrideJson.Keys
.Union(_alarmOverridePriority.Keys, StringComparer.Ordinal)
.Distinct()
.ToList();
var saved = 0;
foreach (var alarmName in touched)
{
var json = _alarmOverrideJson.GetValueOrDefault(alarmName);
var priority = _alarmOverridePriority.GetValueOrDefault(alarmName);
// If both fields are empty AND there's an existing override,
// clear it. Otherwise upsert (allows priority-only or json-only).
if (string.IsNullOrWhiteSpace(json) && !priority.HasValue)
{
if (_existingAlarmOverrides.ContainsKey(alarmName))
{
await InstanceService.DeleteAlarmOverrideAsync(Id, alarmName, user);
_existingAlarmOverrides.Remove(alarmName);
}
continue;
}
var result = await InstanceService.SetAlarmOverrideAsync(
Id, alarmName, json, priority, user);
if (!result.IsSuccess)
{
_toast.ShowError($"Save failed for '{alarmName}': {result.Error}");
continue;
}
_existingAlarmOverrides[alarmName] = result.Value!;
saved++;
}
if (saved > 0) _toast.ShowSuccess($"Saved {saved} alarm override(s).");
}
catch (Exception ex)
{
_toast.ShowError($"Save alarm overrides failed: {ex.Message}");
}
_saving = false;
}
DataType.Boolean => "Boolean",
DataType.Int32 => "Integer",
DataType.Float => "Float",
DataType.Double => "Float",
DataType.String => "String",
DataType.DateTime => "String",
DataType.Binary => "Object",
_ => "Object"
};
// ── Area ────────────────────────────────────────────────

79
src/ScadaLink.TemplateEngine/Flattening/FlatteningService.cs
View File

@@ -407,7 +407,7 @@ public class FlatteningService
/// Returns the derived config verbatim on parse failure of either input —
/// the existing whole-replace behavior is the safe fallback.
/// </summary>
internal static string? MergeHiLoConfig(string? inheritedJson, string? derivedJson)
public static string? MergeHiLoConfig(string? inheritedJson, string? derivedJson)
{
if (string.IsNullOrWhiteSpace(inheritedJson)) return derivedJson;
if (string.IsNullOrWhiteSpace(derivedJson)) return inheritedJson;
@@ -455,6 +455,83 @@ public class FlatteningService
}
}
/// <summary>
/// Computes the minimal HiLo override JSON given the inherited config and
/// an edited config — returns only the top-level keys whose values differ
/// from the inherited config. Returns <c>null</c> when no keys differ (the
/// caller should treat that as "no override").
///
/// Value comparison is type-aware so that JSON-escape differences (e.g.,
/// a literal em-dash in the inherited config vs. <c>—</c> in the
/// editor's serialized output) don't produce false-positive diffs. On
/// parse failure of either input, returns <paramref name="editedJson"/>
/// verbatim — safe fallback that matches the existing whole-replace
/// semantics.
/// </summary>
public static string? DiffHiLoConfig(string? inheritedJson, string? editedJson)
{
if (string.IsNullOrWhiteSpace(editedJson)) return null;
if (string.IsNullOrWhiteSpace(inheritedJson)) return editedJson;
try
{
using var inheritedDoc = JsonDocument.Parse(inheritedJson);
using var editedDoc = JsonDocument.Parse(editedJson);
if (inheritedDoc.RootElement.ValueKind != JsonValueKind.Object
|| editedDoc.RootElement.ValueKind != JsonValueKind.Object)
{
return editedJson;
}
var changed = new List<JsonProperty>();
foreach (var prop in editedDoc.RootElement.EnumerateObject())
{
if (!inheritedDoc.RootElement.TryGetProperty(prop.Name, out var inhProp))
{
changed.Add(prop);
continue;
}
if (!ValuesEquivalent(prop.Value, inhProp))
changed.Add(prop);
}
if (changed.Count == 0) return null;
using var stream = new MemoryStream();
using (var writer = new Utf8JsonWriter(stream))
{
writer.WriteStartObject();
foreach (var p in changed) p.WriteTo(writer);
writer.WriteEndObject();
}
return System.Text.Encoding.UTF8.GetString(stream.ToArray());
}
catch (JsonException)
{
return editedJson;
}
}
/// <summary>
/// Compares two JSON values by their decoded meaning rather than their
/// raw text. Strings are unescaped before comparison so equivalent values
/// in different escape forms (e.g., a literal "—" vs. "—") match.
/// Numbers compare by their double value so trailing-zero differences
/// don't produce false diffs.
/// </summary>
private static bool ValuesEquivalent(JsonElement a, JsonElement b)
{
if (a.ValueKind != b.ValueKind) return false;
return a.ValueKind switch
{
JsonValueKind.String => a.GetString() == b.GetString(),
JsonValueKind.Number => a.GetDouble() == b.GetDouble(),
JsonValueKind.True or JsonValueKind.False or JsonValueKind.Null => true,
_ => a.GetRawText() == b.GetRawText()
};
}
private static void ResolveComposedAlarms(
IReadOnlyList<Template> templateChain,
IReadOnlyDictionary<int, IReadOnlyList<TemplateComposition>> compositionMap,

94
tests/ScadaLink.TemplateEngine.Tests/Flattening/FlatteningServiceMergeTests.cs
View File

@@ -94,6 +94,100 @@ public class FlatteningServiceMergeTests
Assert.Equal(3, doc.RootElement.GetProperty("hiDeadband").GetDouble());
}
// ── DiffHiLoConfig ─────────────────────────────────────────────────────
[Fact]
public void DiffHiLoConfig_NoChanges_ReturnsNull()
{
const string both = @"{""attributeName"":""Temp"",""hi"":80}";
Assert.Null(FlatteningService.DiffHiLoConfig(both, both));
}
[Fact]
public void DiffHiLoConfig_ChangedKey_ReturnsOnlyChangedKey()
{
const string inherited = @"{""attributeName"":""Temp"",""loLo"":0,""lo"":10,""hi"":80,""hiHi"":100}";
const string edited = @"{""attributeName"":""Temp"",""loLo"":0,""lo"":10,""hi"":90,""hiHi"":100}";
var diff = FlatteningService.DiffHiLoConfig(inherited, edited);
Assert.NotNull(diff);
using var doc = JsonDocument.Parse(diff!);
var prop = Assert.Single(doc.RootElement.EnumerateObject());
Assert.Equal("hi", prop.Name);
Assert.Equal(90, prop.Value.GetDouble());
}
[Fact]
public void DiffHiLoConfig_NewKey_AddedToDiff()
{
const string inherited = @"{""attributeName"":""Temp"",""hi"":80}";
const string edited = @"{""attributeName"":""Temp"",""hi"":80,""hiDeadband"":3}";
var diff = FlatteningService.DiffHiLoConfig(inherited, edited);
Assert.NotNull(diff);
using var doc = JsonDocument.Parse(diff!);
Assert.Equal(3, doc.RootElement.GetProperty("hiDeadband").GetDouble());
Assert.False(doc.RootElement.TryGetProperty("hi", out _));
}
[Fact]
public void DiffHiLoConfig_NullInherited_ReturnsEditedVerbatim()
{
const string edited = @"{""attributeName"":""Temp"",""hi"":80}";
Assert.Equal(edited, FlatteningService.DiffHiLoConfig(null, edited));
}
[Fact]
public void DiffHiLoConfig_NullEdited_ReturnsNull()
{
Assert.Null(FlatteningService.DiffHiLoConfig(@"{""hi"":80}", null));
}
[Fact]
public void DiffHiLoConfig_IgnoresStringEscapeDifferences()
{
// Inherited has literal em-dash; edited has the unicode-escaped form.
// Decoded values are identical, so the key should NOT be in the diff.
const string inherited = @"{""attributeName"":""Temp"",""hi"":80,""hiMessage"":""High — investigate""}";
const string edited = @"{""attributeName"":""Temp"",""hi"":80,""hiMessage"":""High — investigate""}";
var diff = FlatteningService.DiffHiLoConfig(inherited, edited);
Assert.Null(diff); // no real change once values are decoded
}
[Fact]
public void DiffHiLoConfig_IgnoresNumericFormatDifferences()
{
// 85 vs 85.0 are the same number — should not produce a diff.
const string inherited = @"{""hi"":85}";
const string edited = @"{""hi"":85.0}";
Assert.Null(FlatteningService.DiffHiLoConfig(inherited, edited));
}
[Fact]
public void DiffHiLoConfig_RoundTripsThroughMerge()
{
// Merge(inherited, Diff(inherited, edited)) ≡ edited — when the
// edited config is itself a superset/equivalent of inherited.
const string inherited = @"{""attributeName"":""Temp"",""hi"":80,""hiHi"":100}";
const string edited = @"{""attributeName"":""Temp"",""hi"":90,""hiHi"":100,""hiDeadband"":5}";
var diff = FlatteningService.DiffHiLoConfig(inherited, edited);
var merged = FlatteningService.MergeHiLoConfig(inherited, diff);
using var origDoc = JsonDocument.Parse(edited);
using var mergedDoc = JsonDocument.Parse(merged!);
Assert.Equal(origDoc.RootElement.GetProperty("hi").GetDouble(),
mergedDoc.RootElement.GetProperty("hi").GetDouble());
Assert.Equal(origDoc.RootElement.GetProperty("hiHi").GetDouble(),
mergedDoc.RootElement.GetProperty("hiHi").GetDouble());
Assert.Equal(origDoc.RootElement.GetProperty("hiDeadband").GetDouble(),
mergedDoc.RootElement.GetProperty("hiDeadband").GetDouble());
}
// ── Instance-level alarm override (end-to-end Flatten) ─────────────────
private static (Template, Instance) BuildHiLoFixture(string inheritedJson, InstanceAlarmOverride? ovr = null, bool locked = false)