From 6dc5af7aa25caadbc04317b7b8ca0027476165e5 Mon Sep 17 00:00:00 2001 From: Joseph Doherty Date: Thu, 16 Jul 2026 05:53:52 -0400 Subject: [PATCH 01/10] v3 Batch 3 contracts: IEffectiveNameGuard authoring-time uniqueness seam Wave-A shared contract. WP2 implements + registers the guard; WP1 consumes it in UnsTreeService reference/VirtualTag/ScriptedAlarm mutations. Ordinal, mirrors the deploy-time DraftValidator UnsEffectiveNameCollision rule. Claude-Session: https://claude.ai/code/session_01LVneM3eh1UtJxEisFXgmox --- .../Uns/IEffectiveNameGuard.cs | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/IEffectiveNameGuard.cs diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/IEffectiveNameGuard.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/IEffectiveNameGuard.cs new file mode 100644 index 00000000..959d8acd --- /dev/null +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/IEffectiveNameGuard.cs @@ -0,0 +1,61 @@ +namespace ZB.MOM.WW.OtOpcUa.AdminUI.Uns; + +/// +/// Which authoring surface a proposed effective name comes from. Used to word the collision +/// error and to exclude the correct same-kind self-row on an edit (rename / override change). +/// +public enum EffectiveNameSourceKind +{ + /// A (effective name = + /// DisplayNameOverride else the backing raw tag's Name). + Reference, + + /// An equipment-bound (effective name = Name). + VirtualTag, + + /// An equipment-bound (effective name = Name). + ScriptedAlarm, +} + +/// +/// v3 Batch 3 authoring-time guard for the UNS effective-name uniqueness rule. Within an +/// equipment the EFFECTIVE leaf name must be unique across its UnsTagReferences +/// (DisplayNameOverride else the backing raw tag's Name), its VirtualTags +/// (Name), and its ScriptedAlarms (Name) — the three share the equipment's +/// UNS NodeId space ({EquipmentId}/{EffectiveName}). This is the authoring mirror of the +/// deploy-time DraftValidator UnsEffectiveNameCollision rule; comparison is +/// to match NodeId semantics and the validator. +/// +/// +/// Injectable (registered Scoped, its own pooled context per call — the same pattern +/// UnsTreeService uses). Consumed by UnsTreeService's reference / virtual-tag / +/// scripted-alarm mutations, which call before persisting and surface a +/// non-null result as the mutation's readable failure. The deploy gate remains the backstop for +/// rename-induced collisions the authoring check never saw. +/// +public interface IEffectiveNameGuard +{ + /// + /// Tests whether would collide with an existing + /// effective name within . + /// + /// The owning equipment's logical id. + /// The effective name to be authored (override else raw name for a reference; Name for a VT/alarm). + /// Which surface the proposed name is for (words the error; identifies the self-row kind to exclude). + /// + /// On an edit, the logical id of the row being changed (its UnsTagReferenceId / + /// VirtualTagId / ScriptedAlarmId) so it is excluded from the collision set; + /// on a create. + /// + /// Cancellation token. + /// + /// when the name is free; otherwise a readable error naming the + /// colliding existing source and the equipment. + /// + Task CheckAsync( + string equipmentId, + string proposedEffectiveName, + EffectiveNameSourceKind kind, + string? excludeSourceId, + CancellationToken ct = default); +} From b68c3133727c79b5a0a774a6527b8517bb964039 Mon Sep 17 00:00:00 2001 From: Joseph Doherty Date: Thu, 16 Jul 2026 06:01:10 -0400 Subject: [PATCH 02/10] feat(uns-v3): implement EffectiveNameGuard authoring-time uniqueness guard (B3-WP2) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implements IEffectiveNameGuard (the Wave-A contract): per-equipment effective-name uniqueness across UnsTagReferences (DisplayNameOverride else backing raw tag Name), VirtualTags (Name), and ScriptedAlarms (Name). Ordinal comparison, self-row exclusion by (kind, id), one pooled context per CheckAsync call. Registered Scoped in EndpointRouteBuilderExtensions so WP1's UnsTreeService consumer goes live. Verified the deploy-time DraftValidator UnsEffectiveNameCollision rule already computes reference effective names from the backing raw tag's current Name (catches rename-induced collisions), spans all three sources, compares ordinal, and names both colliding sources + the equipment — no hardening needed. DraftSnapshotFactory already loads Tags/UnsTagReferences/VirtualTags/ScriptedAlarms. Tests: 8 guard tests (in-memory EF) + 3 deploy-gate tests (rename-induced collision, override-vs-VT, ordinal case-sensitivity). All green. Claude-Session: https://claude.ai/code/session_01LVneM3eh1UtJxEisFXgmox --- .../EndpointRouteBuilderExtensions.cs | 4 + .../Uns/EffectiveNameGuard.cs | 106 +++++++++ .../DraftValidatorTests.cs | 83 +++++++ .../Uns/EffectiveNameGuardTests.cs | 203 ++++++++++++++++++ 4 files changed, 396 insertions(+) create mode 100644 src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EffectiveNameGuard.cs create mode 100644 tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/EffectiveNameGuardTests.cs diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/EndpointRouteBuilderExtensions.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/EndpointRouteBuilderExtensions.cs index 7239ee9e..72a33228 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/EndpointRouteBuilderExtensions.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/EndpointRouteBuilderExtensions.cs @@ -49,6 +49,10 @@ public static class EndpointRouteBuilderExtensions services.AddScoped(); services.AddScoped(); services.AddScoped(); + // v3 Batch 3 (WP2): authoring-time UNS effective-name uniqueness guard. Consumed by + // UnsTreeService's reference/VirtualTag/ScriptedAlarm mutations (WP1); mirrors the + // deploy-time DraftValidator UnsEffectiveNameCollision rule. + services.AddScoped(); // WP5 CSV export enumeration (read-only; does not extend the closed IRawTreeService prelude). services.AddScoped(); services.AddSingleton(); diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EffectiveNameGuard.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EffectiveNameGuard.cs new file mode 100644 index 00000000..97c8d124 --- /dev/null +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EffectiveNameGuard.cs @@ -0,0 +1,106 @@ +using Microsoft.EntityFrameworkCore; +using ZB.MOM.WW.OtOpcUa.Configuration; + +namespace ZB.MOM.WW.OtOpcUa.AdminUI.Uns; + +/// +/// Default . Loads the owning equipment's current effective-name +/// set — references (DisplayNameOverride else the backing raw tag's Name), +/// VirtualTags (Name), and ScriptedAlarms (Name) — and reports the first collision +/// with a proposed name. Comparison is to match the +/// {EquipmentId}/{EffectiveName} NodeId semantics and the deploy-time +/// DraftValidator UnsEffectiveNameCollision rule. +/// +/// +/// Each call creates and disposes its own pooled context — the same per-call pattern +/// uses — so the guard is safe to register Scoped. +/// +public sealed class EffectiveNameGuard(IDbContextFactory dbFactory) : IEffectiveNameGuard +{ + /// + public async Task CheckAsync( + string equipmentId, + string proposedEffectiveName, + EffectiveNameSourceKind kind, + string? excludeSourceId, + CancellationToken ct = default) + { + await using var db = await dbFactory.CreateDbContextAsync(ct); + + // References for this equipment. The effective name is the display-name override else the + // backing raw tag's current Name, so the two sets (references + tags) are loaded and joined + // in memory — the per-equipment set is small and this mirrors the deploy rule exactly + // (a reference whose backing tag is missing contributes no effective name, so it is skipped). + var references = await db.UnsTagReferences + .AsNoTracking() + .Where(r => r.EquipmentId == equipmentId) + .Select(r => new { r.UnsTagReferenceId, r.TagId, r.DisplayNameOverride }) + .ToListAsync(ct); + + var tagIds = references.Select(r => r.TagId).Distinct(StringComparer.Ordinal).ToList(); + var tagNameById = (await db.Tags + .AsNoTracking() + .Where(t => tagIds.Contains(t.TagId)) + .Select(t => new { t.TagId, t.Name }) + .ToListAsync(ct)) + .GroupBy(t => t.TagId, StringComparer.Ordinal) + .ToDictionary(g => g.Key, g => g.First().Name, StringComparer.Ordinal); + + foreach (var r in references) + { + if (IsSelf(EffectiveNameSourceKind.Reference, r.UnsTagReferenceId, kind, excludeSourceId)) + continue; + var effective = r.DisplayNameOverride + ?? (tagNameById.TryGetValue(r.TagId, out var n) ? n : null); + if (Collides(effective, proposedEffectiveName)) + return Message(proposedEffectiveName, "reference", r.UnsTagReferenceId, equipmentId); + } + + var virtualTags = await db.VirtualTags + .AsNoTracking() + .Where(v => v.EquipmentId == equipmentId) + .Select(v => new { v.VirtualTagId, v.Name }) + .ToListAsync(ct); + + foreach (var v in virtualTags) + { + if (IsSelf(EffectiveNameSourceKind.VirtualTag, v.VirtualTagId, kind, excludeSourceId)) + continue; + if (Collides(v.Name, proposedEffectiveName)) + return Message(proposedEffectiveName, "VirtualTag", v.VirtualTagId, equipmentId); + } + + var scriptedAlarms = await db.ScriptedAlarms + .AsNoTracking() + .Where(a => a.EquipmentId == equipmentId) + .Select(a => new { a.ScriptedAlarmId, a.Name }) + .ToListAsync(ct); + + foreach (var a in scriptedAlarms) + { + if (IsSelf(EffectiveNameSourceKind.ScriptedAlarm, a.ScriptedAlarmId, kind, excludeSourceId)) + continue; + if (Collides(a.Name, proposedEffectiveName)) + return Message(proposedEffectiveName, "ScriptedAlarm", a.ScriptedAlarmId, equipmentId); + } + + return null; + } + + /// True when a row is the self-row being edited — same kind AND same logical id — so it + /// is excluded from the collision set (a rename / override-change of a row cannot collide with itself). + private static bool IsSelf( + EffectiveNameSourceKind rowKind, + string rowId, + EffectiveNameSourceKind editedKind, + string? excludeSourceId) => + excludeSourceId is not null + && rowKind == editedKind + && string.Equals(rowId, excludeSourceId, StringComparison.Ordinal); + + private static bool Collides(string? existing, string proposed) => + existing is not null && string.Equals(existing, proposed, StringComparison.Ordinal); + + private static string Message(string name, string sourceLabel, string sourceId, string equipmentId) => + $"effective name '{name}' already used by {sourceLabel} '{sourceId}' in equipment '{equipmentId}'"; +} diff --git a/tests/Core/ZB.MOM.WW.OtOpcUa.Configuration.Tests/DraftValidatorTests.cs b/tests/Core/ZB.MOM.WW.OtOpcUa.Configuration.Tests/DraftValidatorTests.cs index adcf5dd8..6c5ca786 100644 --- a/tests/Core/ZB.MOM.WW.OtOpcUa.Configuration.Tests/DraftValidatorTests.cs +++ b/tests/Core/ZB.MOM.WW.OtOpcUa.Configuration.Tests/DraftValidatorTests.cs @@ -205,6 +205,71 @@ public sealed class DraftValidatorTests DraftValidator.Validate(draft).ShouldNotContain(e => e.Code == "UnsEffectiveNameCollision"); } + /// The rename-induced case the authoring guard never sees: an authoring-clean draft where + /// a reference (no override, effective name = backing raw tag's current Name) ends up sharing an + /// effective name with a VirtualTag after a raw-tag rename. The deploy gate is the backstop. + [Fact] + public void Reference_effective_from_raw_name_collides_with_virtualtag_after_rename() + { + var draft = new DraftSnapshot + { + GenerationId = 1, ClusterId = "c", + Tags = [BuildTag(tagId: "tag-1", name: "speed")], // raw tag renamed to "speed" + UnsTagReferences = + [ + // No override → effective name is the backing raw tag's Name ("speed"). + BuildReference(refId: "ref-1", equipmentId: "eq-1", tagId: "tag-1", overrideName: null), + ], + VirtualTags = [BuildVirtualTag(equipmentId: "eq-1", name: "speed")], + }; + + var errors = DraftValidator.Validate(draft); + errors.ShouldContain(e => e.Code == "UnsEffectiveNameCollision"); + // Names both colliding sources + the equipment. + var msg = errors.First(e => e.Code == "UnsEffectiveNameCollision").Message; + msg.ShouldContain("ref-1"); + msg.ShouldContain("vtag-eq-1-speed"); + msg.ShouldContain("eq-1"); + } + + /// A reference's DisplayNameOverride (not its backing raw name) is the effective name and + /// must be unique against a VirtualTag in the same equipment. + [Fact] + public void Reference_override_collides_with_virtualtag() + { + var draft = new DraftSnapshot + { + GenerationId = 1, ClusterId = "c", + Tags = [BuildTag(tagId: "tag-1", name: "raw-name")], // backing raw name differs + UnsTagReferences = + [ + BuildReference(refId: "ref-1", equipmentId: "eq-1", tagId: "tag-1", overrideName: "computed"), + ], + VirtualTags = [BuildVirtualTag(equipmentId: "eq-1", name: "computed")], + }; + + DraftValidator.Validate(draft).ShouldContain(e => e.Code == "UnsEffectiveNameCollision"); + } + + /// Effective-name comparison is ordinal: "Speed" (VirtualTag) and "speed" (reference's + /// backing raw name) do NOT collide — they are distinct OPC UA browse names. + [Fact] + public void Effective_name_collision_is_ordinal_case_sensitive() + { + var draft = new DraftSnapshot + { + GenerationId = 1, ClusterId = "c", + Tags = [BuildTag(tagId: "tag-1", name: "speed")], + UnsTagReferences = + [ + BuildReference(refId: "ref-1", equipmentId: "eq-1", tagId: "tag-1", overrideName: null), + ], + VirtualTags = [BuildVirtualTag(equipmentId: "eq-1", name: "Speed")], + }; + + DraftValidator.Validate(draft).ShouldNotContain(e => e.Code == "UnsEffectiveNameCollision"); + } + private static VirtualTag BuildVirtualTag(string equipmentId, string name, string suffix = "") => new() { VirtualTagId = $"vtag-{equipmentId}-{name}{suffix}", @@ -214,6 +279,24 @@ public sealed class DraftValidatorTests ScriptId = "s-1", }; + private static Tag BuildTag(string tagId, string name) => new() + { + TagId = tagId, + DeviceId = "dev-1", + Name = name, + DataType = "Float", + AccessLevel = TagAccessLevel.Read, + TagConfig = "{}", + }; + + private static UnsTagReference BuildReference(string refId, string equipmentId, string tagId, string? overrideName) => new() + { + UnsTagReferenceId = refId, + EquipmentId = equipmentId, + TagId = tagId, + DisplayNameOverride = overrideName, + }; + // ------------------------------------------------------------------------------------ // Phase 6.3 task #148 part 2 — ValidateClusterTopology (unchanged in v3) // ------------------------------------------------------------------------------------ diff --git a/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/EffectiveNameGuardTests.cs b/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/EffectiveNameGuardTests.cs new file mode 100644 index 00000000..fe1ec492 --- /dev/null +++ b/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/EffectiveNameGuardTests.cs @@ -0,0 +1,203 @@ +using Microsoft.EntityFrameworkCore; +using Shouldly; +using Xunit; +using ZB.MOM.WW.OtOpcUa.AdminUI.Uns; +using ZB.MOM.WW.OtOpcUa.Configuration; +using ZB.MOM.WW.OtOpcUa.Configuration.Entities; +using ZB.MOM.WW.OtOpcUa.Configuration.Enums; + +namespace ZB.MOM.WW.OtOpcUa.AdminUI.Tests.Uns; + +/// +/// Unit tests for — the authoring-time UNS effective-name +/// uniqueness guard. Backed by an InMemory EF database seeded with one equipment carrying a +/// reference (override + backing raw tag), a VirtualTag, and a ScriptedAlarm. +/// +public sealed class EffectiveNameGuardTests +{ + private const string EquipmentId = "EQ-000000000001"; + + // Reference REF-1 → raw tag TAG-1 (Name "speed"), NO override → effective "speed". + // Reference REF-2 → raw tag TAG-2 (Name "raw-temp"), override "temperature" → effective "temperature". + // VirtualTag VT-1 (Name "computed"). ScriptedAlarm AL-1 (Name "highpress"). + private const string RefNoOverrideId = "REF-1"; + private const string RefWithOverrideId = "REF-2"; + private const string VirtualTagId = "VT-1"; + private const string ScriptedAlarmId = "AL-1"; + + private static IDbContextFactory SeedFactory() + { + var name = $"engname-{Guid.NewGuid():N}"; + var factory = new NamedFactory(name); + using var db = factory.CreateDbContext(); + + db.Tags.Add(new Tag + { + TagId = "TAG-1", + DeviceId = "DEV-1", + Name = "speed", + DataType = "Float", + AccessLevel = TagAccessLevel.Read, + TagConfig = "{}", + }); + db.Tags.Add(new Tag + { + TagId = "TAG-2", + DeviceId = "DEV-1", + Name = "raw-temp", + DataType = "Float", + AccessLevel = TagAccessLevel.Read, + TagConfig = "{}", + }); + + db.UnsTagReferences.Add(new UnsTagReference + { + UnsTagReferenceId = RefNoOverrideId, + EquipmentId = EquipmentId, + TagId = "TAG-1", + DisplayNameOverride = null, // effective = raw tag Name "speed" + }); + db.UnsTagReferences.Add(new UnsTagReference + { + UnsTagReferenceId = RefWithOverrideId, + EquipmentId = EquipmentId, + TagId = "TAG-2", + DisplayNameOverride = "temperature", // effective = "temperature" + }); + + db.VirtualTags.Add(new VirtualTag + { + VirtualTagId = VirtualTagId, + EquipmentId = EquipmentId, + Name = "computed", + DataType = "Float", + ScriptId = "SCR-1", + }); + + db.ScriptedAlarms.Add(new ScriptedAlarm + { + ScriptedAlarmId = ScriptedAlarmId, + EquipmentId = EquipmentId, + Name = "highpress", + AlarmType = "AlarmCondition", + MessageTemplate = "{TagPath} high", + PredicateScriptId = "SCR-2", + }); + + db.SaveChanges(); + return factory; + } + + private static EffectiveNameGuard Guard(IDbContextFactory factory) => new(factory); + + [Fact] + public async Task Free_name_returns_null() + { + var guard = Guard(SeedFactory()); + + var result = await guard.CheckAsync( + EquipmentId, "brand-new-name", EffectiveNameSourceKind.VirtualTag, excludeSourceId: null); + + result.ShouldBeNull(); + } + + [Fact] + public async Task Reference_vs_new_virtualtag_clash_returns_error_naming_the_reference() + { + var guard = Guard(SeedFactory()); + + // A new VirtualTag proposing "speed" collides with reference REF-1's effective name. + var result = await guard.CheckAsync( + EquipmentId, "speed", EffectiveNameSourceKind.VirtualTag, excludeSourceId: null); + + result.ShouldNotBeNull(); + result.ShouldBe($"effective name 'speed' already used by reference '{RefNoOverrideId}' in equipment '{EquipmentId}'"); + } + + [Fact] + public async Task Override_effective_name_vs_new_reference_clash_returns_error() + { + var guard = Guard(SeedFactory()); + + // A new reference proposing "temperature" collides with REF-2's OVERRIDE effective name. + var result = await guard.CheckAsync( + EquipmentId, "temperature", EffectiveNameSourceKind.Reference, excludeSourceId: null); + + result.ShouldNotBeNull(); + result.ShouldBe($"effective name 'temperature' already used by reference '{RefWithOverrideId}' in equipment '{EquipmentId}'"); + } + + [Fact] + public async Task New_virtualtag_vs_scripted_alarm_clash_returns_error_naming_the_alarm() + { + var guard = Guard(SeedFactory()); + + var result = await guard.CheckAsync( + EquipmentId, "highpress", EffectiveNameSourceKind.VirtualTag, excludeSourceId: null); + + result.ShouldNotBeNull(); + result.ShouldBe($"effective name 'highpress' already used by ScriptedAlarm '{ScriptedAlarmId}' in equipment '{EquipmentId}'"); + } + + [Fact] + public async Task Self_exclude_on_override_change_returns_null() + { + var guard = Guard(SeedFactory()); + + // Editing REF-2 to change its override to "temperature" (its own current effective name) + // must NOT collide with itself. + var result = await guard.CheckAsync( + EquipmentId, "temperature", EffectiveNameSourceKind.Reference, excludeSourceId: RefWithOverrideId); + + result.ShouldBeNull(); + } + + [Fact] + public async Task Self_exclude_only_applies_to_same_kind() + { + var guard = Guard(SeedFactory()); + + // Excluding a VirtualTag whose id happens to equal a reference id must NOT excuse the + // reference collision — the self-row is identified by (kind, id) together. + var result = await guard.CheckAsync( + EquipmentId, "speed", EffectiveNameSourceKind.VirtualTag, excludeSourceId: RefNoOverrideId); + + result.ShouldNotBeNull(); + result.ShouldBe($"effective name 'speed' already used by reference '{RefNoOverrideId}' in equipment '{EquipmentId}'"); + } + + [Fact] + public async Task Ordinal_case_sensitivity_Speed_does_not_collide_with_speed() + { + var guard = Guard(SeedFactory()); + + // "Speed" (capital S) must NOT collide with the existing "speed" (ordinal comparison). + var result = await guard.CheckAsync( + EquipmentId, "Speed", EffectiveNameSourceKind.VirtualTag, excludeSourceId: null); + + result.ShouldBeNull(); + } + + [Fact] + public async Task Collision_is_scoped_to_the_equipment() + { + var guard = Guard(SeedFactory()); + + // Same name, different equipment → no collision (per-equipment NodeId space). + var result = await guard.CheckAsync( + "EQ-000000000002", "speed", EffectiveNameSourceKind.VirtualTag, excludeSourceId: null); + + result.ShouldBeNull(); + } + + private sealed class NamedFactory(string name) : IDbContextFactory + { + public OtOpcUaConfigDbContext CreateDbContext() => + new(new DbContextOptionsBuilder() + .UseInMemoryDatabase(name) + .Options); + + public Task CreateDbContextAsync(CancellationToken cancellationToken = default) => + Task.FromResult(CreateDbContext()); + } +} From 09ff43910c3027db0ed57160b7770a412fdf2dcc Mon Sep 17 00:00:00 2001 From: Joseph Doherty Date: Thu, 16 Jul 2026 06:04:06 -0400 Subject: [PATCH 03/10] feat(raw): B3-WP3 rename-warning script scan + historized-override refine MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Extend RawTreeService.BuildRenameWarningsAsync so a tag/ancestor rename now raises three warning kinds over the affected (prefix-scanned) tags: (a) refined — historized WITHOUT a historianTagname override (default tagname is the moving RawPath, so history forks); a pinned (override) tag no longer warns. Count/message adjusted. (b) unchanged — UNS-referenced (names the equipment). (c) NEW — substring-scan every Script body for the affected tag's OLD RawPath (ordinal, false-positives tolerated by design; no AST). OLD RawPaths are recomputed from the pre-save in-DB topology via RawPathResolver. CollectTagsBeneath* + TagsForDevices now carry (DeviceId, TagGroupId, Name) so the OLD RawPath can be rebuilt. Contained entirely within RawTreeService.cs; IRawTreeService + RawTree.razor untouched (warnings flow through the existing RawRenameResult.Warnings). Note: a direct tag rename goes through UpdateTagAsync (UnsMutationResult, no warning surface) so it is out of scope without widening the interface. Tests: new RawTreeServiceRenameWarningTests (4) — all-three, pinned-no-warn, unrelated-empty, ancestor-rename script match. AdminUI.Tests 642 green. Claude-Session: https://claude.ai/code/session_01LVneM3eh1UtJxEisFXgmox --- .../Uns/RawTreeService.cs | 153 ++++++++++-- .../Uns/RawTreeServiceRenameWarningTests.cs | 231 ++++++++++++++++++ 2 files changed, 357 insertions(+), 27 deletions(-) create mode 100644 tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/RawTreeServiceRenameWarningTests.cs diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/RawTreeService.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/RawTreeService.cs index f619c59e..1039b03c 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/RawTreeService.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/RawTreeService.cs @@ -1282,24 +1282,41 @@ public sealed class RawTreeService(IDbContextFactory dbF } /// - /// Builds the non-blocking rename warnings answerable from this batch's schema: historized tags and - /// equipment-referenced tags beneath the renamed node (whose RawPath — and thus historian tagname / - /// UNS projection path — changes with the rename). Batch 3 appends the script-substring scan here. + /// A raw tag affected by a rename, carrying the fields needed to (a) read its platform intents and + /// (b) recompute its OLD RawPath (still the in-DB state at warning time — the rename is not yet saved). + /// + private readonly record struct AffectedTag( + string TagId, string TagConfig, string DeviceId, string? TagGroupId, string Name); + + /// + /// Builds the non-blocking rename warnings answerable from this batch's schema for the tags beneath the + /// renamed node (whose RawPath — and thus historian tagname / UNS projection path / script literal — + /// changes with the rename): (a) historized tags WITHOUT a historianTagname override (their + /// history forks, since the default tagname is the moving RawPath; pinned tags are unaffected), + /// (b) equipment-referenced tags, and (c) tags whose OLD RawPath appears as a literal substring in any + /// body (tolerates false positives by design — no AST). /// private static async Task> BuildRenameWarningsAsync( - OtOpcUaConfigDbContext db, IReadOnlyList<(string TagId, string TagConfig)> tags, CancellationToken ct) + OtOpcUaConfigDbContext db, IReadOnlyList tags, CancellationToken ct) { var warnings = new List(); if (tags.Count == 0) return warnings; - var historized = tags.Count(t => TagConfigIntent.Parse(t.TagConfig).IsHistorized); - if (historized > 0) + // (a) Historized WITHOUT a historianTagname override: the default tagname is the RawPath, which is + // moving, so history forks on the next deploy. A tag WITH the override is pinned and does not warn. + var forking = tags.Count(t => { - warnings.Add(historized == 1 - ? "1 historized tag beneath this node will change its RawPath (historian tagname). Update the historian if it keys on the old path." - : $"{historized} historized tags beneath this node will change their RawPath (historian tagname). Update the historian if it keys on the old paths."); + var intent = TagConfigIntent.Parse(t.TagConfig); + return intent.IsHistorized && intent.HistorianTagname is null; + }); + if (forking > 0) + { + warnings.Add(forking == 1 + ? "1 historized tag beneath this node has no historianTagname override; its history forks to a new tagname when its RawPath changes on the next deploy. Set a historianTagname to pin it." + : $"{forking} historized tags beneath this node have no historianTagname override; their history forks to new tagnames when their RawPaths change on the next deploy. Set a historianTagname to pin them."); } + // (b) UNS-referenced: name the referencing equipment. var tagIds = tags.Select(t => t.TagId).ToList(); var referencingEquipmentIds = await db.UnsTagReferences.AsNoTracking() .Where(r => tagIds.Contains(r.TagId)) @@ -1313,12 +1330,94 @@ public sealed class RawTreeService(IDbContextFactory dbF warnings.Add($"Tags beneath this node are referenced by equipment {display}; the UNS projection path will change with the rename."); } - // Batch 3 extension point: scan scripts for substrings of the affected tags' RawPaths and append - // a "N script(s) reference tags beneath this node" warning to this same list. + // (c) Script literals: substring-scan every Script body for the affected tags' OLD RawPaths. + var scriptWarning = await BuildScriptReferenceWarningAsync(db, tags, ct); + if (scriptWarning is not null) warnings.Add(scriptWarning); return warnings; } + /// + /// Scans every body for the OLD RawPath of any affected tag as a plain ordinal + /// substring (no AST — false positives tolerated by design; {{equip}}-relative refs are NOT + /// scanned, they resolve through references and the deploy gate catches breakage). Returns a warning + /// naming the matched scripts, or when none match. + /// + private static async Task BuildScriptReferenceWarningAsync( + OtOpcUaConfigDbContext db, IReadOnlyList tags, CancellationToken ct) + { + var oldPaths = await ComputeOldRawPathsAsync(db, tags, ct); + if (oldPaths.Count == 0) return null; + + var scripts = await db.Scripts.AsNoTracking() + .Select(s => new { s.ScriptId, s.Name, s.SourceCode }) + .ToListAsync(ct); + + var matched = scripts + .Where(s => oldPaths.Any(p => s.SourceCode.Contains(p, StringComparison.Ordinal))) + .OrderBy(s => s.Name, StringComparer.Ordinal) + .Select(s => s.Name) + .ToList(); + if (matched.Count == 0) return null; + + var names = string.Join(", ", matched.Select(n => $"'{n}'")); + return matched.Count == 1 + ? $"1 script ({names}) references a tag beneath this node by its raw path; the reference will break unless the script is updated." + : $"{matched.Count} scripts ({names}) reference tags beneath this node by their raw paths; the references will break unless the scripts are updated."; + } + + /// + /// Recomputes the OLD RawPath of each affected tag from the current (pre-save) in-DB raw topology, + /// dropping any tag whose ancestry chain is broken (a null RawPath). Loads only the topology the affected + /// tags need: their devices + drivers, the drivers' clusters' folders, and the devices' tag groups. + /// + private static async Task> ComputeOldRawPathsAsync( + OtOpcUaConfigDbContext db, IReadOnlyList tags, CancellationToken ct) + { + var deviceIds = tags.Select(t => t.DeviceId).Distinct(StringComparer.Ordinal).ToList(); + + var deviceRows = await db.Devices.AsNoTracking() + .Where(d => deviceIds.Contains(d.DeviceId)) + .Select(d => new { d.DeviceId, d.DriverInstanceId, d.Name }) + .ToListAsync(ct); + + var driverIds = deviceRows.Select(d => d.DriverInstanceId).Distinct(StringComparer.Ordinal).ToList(); + var driverRows = await db.DriverInstances.AsNoTracking() + .Where(d => driverIds.Contains(d.DriverInstanceId)) + .Select(d => new { d.DriverInstanceId, d.RawFolderId, d.Name, d.ClusterId }) + .ToListAsync(ct); + + var clusterIds = driverRows.Select(d => d.ClusterId).Distinct(StringComparer.Ordinal).ToList(); + var folderRows = await db.RawFolders.AsNoTracking() + .Where(f => clusterIds.Contains(f.ClusterId)) + .Select(f => new { f.RawFolderId, f.ParentRawFolderId, f.Name }) + .ToListAsync(ct); + + var groupRows = await db.TagGroups.AsNoTracking() + .Where(g => deviceIds.Contains(g.DeviceId)) + .Select(g => new { g.TagGroupId, g.ParentTagGroupId, g.Name }) + .ToListAsync(ct); + + var folders = folderRows.ToDictionary( + f => f.RawFolderId, f => ((string?)f.ParentRawFolderId, f.Name), StringComparer.Ordinal); + var drivers = driverRows.ToDictionary( + d => d.DriverInstanceId, d => ((string?)d.RawFolderId, d.Name), StringComparer.Ordinal); + var devices = deviceRows.ToDictionary( + d => d.DeviceId, d => (d.DriverInstanceId, d.Name), StringComparer.Ordinal); + var groups = groupRows.ToDictionary( + g => g.TagGroupId, g => ((string?)g.ParentTagGroupId, g.Name), StringComparer.Ordinal); + + var resolver = new RawPathResolver(folders, drivers, devices, groups); + + var paths = new List(tags.Count); + foreach (var t in tags) + { + var path = resolver.TryBuildTagPath(t.DeviceId, t.TagGroupId, t.Name); + if (path is not null) paths.Add(path); + } + return paths; + } + /// Renders a friendly "Name (Id), …" list for the referencing equipment ids. private static async Task DescribeEquipmentAsync( OtOpcUaConfigDbContext db, IReadOnlyList equipmentIds, CancellationToken ct) @@ -1336,11 +1435,11 @@ public sealed class RawTreeService(IDbContextFactory dbF // --- Subtree tag collectors (walk the in-DB subtree for rename impact) --- - private static async Task> CollectTagsBeneathFolderAsync( + private static async Task> CollectTagsBeneathFolderAsync( OtOpcUaConfigDbContext db, string rawFolderId, CancellationToken ct) { var folder = await db.RawFolders.AsNoTracking().FirstOrDefaultAsync(f => f.RawFolderId == rawFolderId, ct); - if (folder is null) return Array.Empty<(string, string)>(); + if (folder is null) return Array.Empty(); // All folders in the cluster, walked in-memory to the descendant set (incl. self) via ParentRawFolderId. var clusterFolders = await db.RawFolders.AsNoTracking() @@ -1359,44 +1458,44 @@ public sealed class RawTreeService(IDbContextFactory dbF .Where(d => d.RawFolderId != null && folderIds.Contains(d.RawFolderId)) .Select(d => d.DriverInstanceId) .ToListAsync(ct); - if (driverIds.Count == 0) return Array.Empty<(string, string)>(); + if (driverIds.Count == 0) return Array.Empty(); var deviceIds = await db.Devices.AsNoTracking() .Where(dev => driverIds.Contains(dev.DriverInstanceId)) .Select(dev => dev.DeviceId) .ToListAsync(ct); - if (deviceIds.Count == 0) return Array.Empty<(string, string)>(); + if (deviceIds.Count == 0) return Array.Empty(); return await TagsForDevicesAsync(db, deviceIds, ct); } - private static async Task> CollectTagsBeneathDriverAsync( + private static async Task> CollectTagsBeneathDriverAsync( OtOpcUaConfigDbContext db, string driverInstanceId, CancellationToken ct) { var deviceIds = await db.Devices.AsNoTracking() .Where(dev => dev.DriverInstanceId == driverInstanceId) .Select(dev => dev.DeviceId) .ToListAsync(ct); - if (deviceIds.Count == 0) return Array.Empty<(string, string)>(); + if (deviceIds.Count == 0) return Array.Empty(); return await TagsForDevicesAsync(db, deviceIds, ct); } - private static async Task> CollectTagsBeneathDeviceAsync( + private static async Task> CollectTagsBeneathDeviceAsync( OtOpcUaConfigDbContext db, string deviceId, CancellationToken ct) { return (await db.Tags.AsNoTracking() .Where(t => t.DeviceId == deviceId) - .Select(t => new { t.TagId, t.TagConfig }) + .Select(t => new { t.TagId, t.TagConfig, t.DeviceId, t.TagGroupId, t.Name }) .ToListAsync(ct)) - .Select(t => (t.TagId, t.TagConfig)) + .Select(t => new AffectedTag(t.TagId, t.TagConfig, t.DeviceId, t.TagGroupId, t.Name)) .ToList(); } - private static async Task> CollectTagsBeneathGroupAsync( + private static async Task> CollectTagsBeneathGroupAsync( OtOpcUaConfigDbContext db, string tagGroupId, CancellationToken ct) { var group = await db.TagGroups.AsNoTracking().FirstOrDefaultAsync(g => g.TagGroupId == tagGroupId, ct); - if (group is null) return Array.Empty<(string, string)>(); + if (group is null) return Array.Empty(); var deviceGroups = await db.TagGroups.AsNoTracking() .Where(g => g.DeviceId == group.DeviceId) @@ -1412,20 +1511,20 @@ public sealed class RawTreeService(IDbContextFactory dbF return (await db.Tags.AsNoTracking() .Where(t => t.TagGroupId != null && groupIds.Contains(t.TagGroupId)) - .Select(t => new { t.TagId, t.TagConfig }) + .Select(t => new { t.TagId, t.TagConfig, t.DeviceId, t.TagGroupId, t.Name }) .ToListAsync(ct)) - .Select(t => (t.TagId, t.TagConfig)) + .Select(t => new AffectedTag(t.TagId, t.TagConfig, t.DeviceId, t.TagGroupId, t.Name)) .ToList(); } - private static async Task> TagsForDevicesAsync( + private static async Task> TagsForDevicesAsync( OtOpcUaConfigDbContext db, IReadOnlyList deviceIds, CancellationToken ct) { return (await db.Tags.AsNoTracking() .Where(t => deviceIds.Contains(t.DeviceId)) - .Select(t => new { t.TagId, t.TagConfig }) + .Select(t => new { t.TagId, t.TagConfig, t.DeviceId, t.TagGroupId, t.Name }) .ToListAsync(ct)) - .Select(t => (t.TagId, t.TagConfig)) + .Select(t => new AffectedTag(t.TagId, t.TagConfig, t.DeviceId, t.TagGroupId, t.Name)) .ToList(); } diff --git a/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/RawTreeServiceRenameWarningTests.cs b/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/RawTreeServiceRenameWarningTests.cs new file mode 100644 index 00000000..ef2a7fc3 --- /dev/null +++ b/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/RawTreeServiceRenameWarningTests.cs @@ -0,0 +1,231 @@ +using Microsoft.EntityFrameworkCore; +using Shouldly; +using Xunit; +using ZB.MOM.WW.OtOpcUa.AdminUI.Uns; +using ZB.MOM.WW.OtOpcUa.Configuration; +using ZB.MOM.WW.OtOpcUa.Configuration.Entities; +using ZB.MOM.WW.OtOpcUa.Configuration.Enums; + +namespace ZB.MOM.WW.OtOpcUa.AdminUI.Tests.Uns; + +/// +/// Covers the B3-WP3 rename-warning extension of : the three warning kinds a +/// tag/ancestor rename can raise — (a) historized WITHOUT a historianTagname override (history +/// forks), (b) UNS-referenced (names the equipment), and (c) matched by a substring scan of a +/// Script body for the affected tag's OLD RawPath. +/// +/// Seeds a bespoke InMemory slice (independent of the shared RawTreeTestDb) so each device holds +/// exactly one tag with a controlled property mix. The EF InMemory provider does not enforce +/// RowVersion tokens, so renames commit against the seeded row versions. +/// +/// +[Trait("Category", "Unit")] +public sealed class RawTreeServiceRenameWarningTests +{ + private const string ClusterId = "MAIN"; + private const string FolderId = "RF-plant"; + private const string DriverId = "DRV-modbus"; + + // Dev-all → the "everything" tag: historized (no override) + referenced + named in a script literal. + private const string DevAllId = "DEV-all"; + private const string FlowTagId = "TAG-flow"; + private const string FlowRawPath = "Plant/modbus-1/Dev-all/flow"; + + // Dev-pinned → a historized tag WITH a historianTagname override (pinned; must NOT warn). + private const string DevPinnedId = "DEV-pinned"; + private const string TempTagId = "TAG-temp"; + + // Dev-plain → a plain tag, unreferenced + absent from every script (must warn nothing). + private const string DevPlainId = "DEV-plain"; + private const string IdleTagId = "TAG-idle"; + + private const string EquipmentId = "EQ-000000000001"; + private const string EquipmentName = "packer-1"; + private const string ScriptName = "AreaCalc"; + + private static (RawTreeService Service, string DbName) Seeded() + { + var name = $"rawwarn-{Guid.NewGuid():N}"; + using var db = CreateNamed(name); + Seed(db); + return (new RawTreeService(new NamedFactory(name)), name); + } + + private static OtOpcUaConfigDbContext CreateNamed(string name) => + new(new DbContextOptionsBuilder().UseInMemoryDatabase(name).Options); + + private static byte[] DeviceRowVersion(string dbName, string deviceId) + { + using var db = CreateNamed(dbName); + return db.Devices.Single(d => d.DeviceId == deviceId).RowVersion; + } + + private static byte[] DriverRowVersion(string dbName, string driverId) + { + using var db = CreateNamed(dbName); + return db.DriverInstances.Single(d => d.DriverInstanceId == driverId).RowVersion; + } + + // ------------------------------------------------------------------------------------- Scenarios + + [Fact] + public async Task Rename_of_ancestor_of_a_historized_referenced_scripted_tag_raises_all_three_warnings() + { + var (service, dbName) = Seeded(); + var rv = DeviceRowVersion(dbName, DevAllId); + + var result = await service.RenameDeviceAsync(DevAllId, "Dev-renamed", rv); + + result.Ok.ShouldBeTrue(); + result.Warnings.ShouldContain(w => w.Contains("historian")); // (a) + result.Warnings.ShouldContain(w => w.Contains(EquipmentName)); // (b) + result.Warnings.ShouldContain(w => w.Contains("script") && w.Contains(ScriptName)); // (c) + result.Warnings.Count.ShouldBe(3); + } + + [Fact] + public async Task Rename_of_a_pinned_historized_tag_raises_no_historized_warning() + { + var (service, dbName) = Seeded(); + var rv = DeviceRowVersion(dbName, DevPinnedId); + + var result = await service.RenameDeviceAsync(DevPinnedId, "Dev-pinned2", rv); + + result.Ok.ShouldBeTrue(); + // A historianTagname override pins the tagname, so its history does NOT fork — no (a) warning; and + // the pinned tag is neither referenced nor scripted, so nothing else fires either. + result.Warnings.ShouldNotContain(w => w.Contains("historian")); + result.Warnings.ShouldBeEmpty(); + } + + [Fact] + public async Task Rename_of_an_unrelated_tags_ancestor_raises_no_warnings() + { + var (service, dbName) = Seeded(); + var rv = DeviceRowVersion(dbName, DevPlainId); + + var result = await service.RenameDeviceAsync(DevPlainId, "Dev-plain2", rv); + + result.Ok.ShouldBeTrue(); + result.Warnings.ShouldBeEmpty(); + } + + [Fact] + public async Task Script_scan_matches_when_an_ancestor_is_renamed_and_the_old_path_is_in_a_script_body() + { + var (service, dbName) = Seeded(); + var rv = DriverRowVersion(dbName, DriverId); + + // Renaming the DRIVER (an ancestor of the scripted tag) still computes the tag's unchanged OLD + // RawPath (rename not yet saved) and finds it as a substring of the script body. + var result = await service.RenameDriverAsync(DriverId, "modbus-renamed", rv); + + result.Ok.ShouldBeTrue(); + result.Warnings.ShouldContain(w => w.Contains("script") && w.Contains(ScriptName)); + } + + // ------------------------------------------------------------------------------------------ Seed + + private static void Seed(OtOpcUaConfigDbContext db) + { + db.ServerClusters.Add(new ServerCluster + { + ClusterId = ClusterId, + Name = "Main", + Enterprise = "zb", + Site = "warsaw-west", + RedundancyMode = RedundancyMode.None, + CreatedBy = "test", + }); + + db.RawFolders.Add(new RawFolder + { + RawFolderId = FolderId, + ClusterId = ClusterId, + ParentRawFolderId = null, + Name = "Plant", + }); + db.DriverInstances.Add(new DriverInstance + { + DriverInstanceId = DriverId, + ClusterId = ClusterId, + RawFolderId = FolderId, + Name = "modbus-1", + DriverType = "Modbus", + DriverConfig = "{}", + }); + + db.Devices.Add(new Device { DeviceId = DevAllId, DriverInstanceId = DriverId, Name = "Dev-all", DeviceConfig = "{}" }); + db.Devices.Add(new Device { DeviceId = DevPinnedId, DriverInstanceId = DriverId, Name = "Dev-pinned", DeviceConfig = "{}" }); + db.Devices.Add(new Device { DeviceId = DevPlainId, DriverInstanceId = DriverId, Name = "Dev-plain", DeviceConfig = "{}" }); + + // Historized, no historianTagname override → its default tagname is FlowRawPath, which moves. + db.Tags.Add(new Tag + { + TagId = FlowTagId, + DeviceId = DevAllId, + TagGroupId = null, + Name = "flow", + DataType = "Float", + AccessLevel = TagAccessLevel.Read, + TagConfig = "{\"isHistorized\":true}", + }); + // Historized WITH a historianTagname override → pinned, must not fork/warn. + db.Tags.Add(new Tag + { + TagId = TempTagId, + DeviceId = DevPinnedId, + TagGroupId = null, + Name = "temp", + DataType = "Float", + AccessLevel = TagAccessLevel.Read, + TagConfig = "{\"isHistorized\":true,\"historianTagname\":\"Plant.Pinned.Temp\"}", + }); + // Plain, unreferenced, absent from scripts. + db.Tags.Add(new Tag + { + TagId = IdleTagId, + DeviceId = DevPlainId, + TagGroupId = null, + Name = "idle", + DataType = "Boolean", + AccessLevel = TagAccessLevel.Read, + TagConfig = "{}", + }); + + db.Equipment.Add(new Equipment + { + EquipmentId = EquipmentId, + EquipmentUuid = Guid.NewGuid(), + UnsLineId = "LINE-1", + Name = EquipmentName, + MachineCode = "packer_001", + }); + db.UnsTagReferences.Add(new UnsTagReference + { + UnsTagReferenceId = "REF-flow", + EquipmentId = EquipmentId, + TagId = FlowTagId, + }); + + // A script whose body names the flow tag by its absolute RawPath literal. + db.Scripts.Add(new Script + { + ScriptId = "SC-areacalc", + Name = ScriptName, + SourceCode = $"var v = ctx.GetTag(\"{FlowRawPath}\"); return v * 2;", + SourceHash = "hash-areacalc", + }); + + db.SaveChanges(); + } + + private sealed class NamedFactory(string name) : IDbContextFactory + { + public OtOpcUaConfigDbContext CreateDbContext() => + new(new DbContextOptionsBuilder().UseInMemoryDatabase(name).Options); + + public Task CreateDbContextAsync(CancellationToken cancellationToken = default) => + Task.FromResult(CreateDbContext()); + } +} From 77bc010ba95c404aa6a3e85c0ded52536263c35d Mon Sep 17 00:00:00 2001 From: Joseph Doherty Date: Thu, 16 Jul 2026 06:15:51 -0400 Subject: [PATCH 04/10] =?UTF-8?q?v3=20Batch=203=20WP1:=20UNS=20Equipment?= =?UTF-8?q?=20Tags=20tab=20=E2=86=92=20reference=20list=20+=20raw-tag=20pi?= =?UTF-8?q?cker?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace the Batch-1-stubbed authored-tag flow with a UnsTagReference list on the equipment page's Tags tab (v3 reference-only equipment): columns are effective name, computed raw path, inherited datatype/access (read-only), display-name override (editable), and remove. The retired equipment-authored-tag editor (TagModal.razor) is deleted; the VirtualTag and ScriptedAlarm flows are untouched. - "+ Add reference" opens a new AddReferenceModal that reuses RawTree in a new opt-in PickerMode (Tag-leaf checkboxes + Device/TagGroup "select all tags below"), scoped structurally to the equipment's cluster via LoadReferencePickerRootAsync (a single cluster root — cross-cluster tags are unreachable, not merely hidden). Default /raw usage is byte-unchanged (PickerMode defaults false). - UnsTreeService (+ IUnsTreeService) gain the reference mutations: LoadReferencesForEquipmentAsync (computes each RawPath via the shared RawPathResolver), AddReferencesAsync (cluster-checked, all-or-nothing), RemoveReferenceAsync, SetReferenceOverrideAsync, plus the picker helpers LoadReferencePickerRootAsync / LoadDescendantTagIdsAsync. - Consume IEffectiveNameGuard (constructor-injected, no-op fallback when unregistered): AddReferences, SetReferenceOverride, and the VirtualTag + ScriptedAlarm create/update mutations now call CheckAsync before persisting and surface a collision as the failure. WP2 supplies the implementation + DI registration. - Drop the retired equipment↔driver binding: remove DriverInstanceId from EquipmentInput, the ImportEquipmentModal CSV column, the EquipmentPage Details driver select, and the dead decision-#122 driver-cluster guard. Tests: new UnsTreeServiceReferenceTests (add/remove/override, cross-cluster + duplicate rejection, guard-consumed rejection via a fake guard, RawPath projection, picker helpers); Equipment/Import test suites rewritten to drop the retired driver-guard cases. AdminUI suite green (639 passed, 3 skipped); full solution builds 0 errors. Claude-Session: https://claude.ai/code/session_01LVneM3eh1UtJxEisFXgmox --- .../Components/Pages/Uns/EquipmentPage.razor | 136 ++--- .../Components/Shared/Raw/RawTree.razor | 94 ++- .../Shared/Uns/AddReferenceModal.razor | 125 ++++ .../Shared/Uns/ImportEquipmentModal.razor | 24 +- .../Components/Shared/Uns/TagModal.razor | 557 ------------------ .../Uns/EquipmentChildRows.cs | 25 + .../Uns/EquipmentInput.cs | 2 - .../Uns/IUnsTreeService.cs | 102 +++- .../Uns/UnsTreeService.cs | 465 ++++++++++++--- .../Uns/UnsTreeServiceEquipmentTests.cs | 253 ++------ .../Uns/UnsTreeServiceImportTests.cs | 124 +--- .../Uns/UnsTreeServiceReferenceTests.cs | 314 ++++++++++ 12 files changed, 1161 insertions(+), 1060 deletions(-) create mode 100644 src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/AddReferenceModal.razor delete mode 100644 src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/TagModal.razor create mode 100644 tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceReferenceTests.cs diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Pages/Uns/EquipmentPage.razor b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Pages/Uns/EquipmentPage.razor index b1711eeb..34f99e9d 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Pages/Uns/EquipmentPage.razor +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Pages/Uns/EquipmentPage.razor @@ -78,17 +78,9 @@ else -
- - - - @foreach (var (id, display) in _driverOptions) - { - - } - -
+ @* v3: equipment no longer binds a driver — device I/O is authored in the /raw tree and surfaced + here by reference on the Tags tab. The old "Driver instance" select was removed. *@
@@ -138,38 +130,48 @@ else } else if (_activeTab == "tags") { + @* v3 Batch 3: equipment is reference-only — the Tags tab lists UnsTagReference rows pointing at + raw tags. Datatype/access are inherited (read-only) from the backing raw tag; the display-name + override is the only per-reference editable field. *@
- +
- @if (!string.IsNullOrWhiteSpace(_tagError)) + @if (!string.IsNullOrWhiteSpace(_refError)) { -
@_tagError
+
@_refError
} - @if (_tags is null) + @if (_refs is null) {

Loading…

} - else if (_tags.Count == 0) + else if (_refs.Count == 0) { -

No tags yet.

+

No tag references yet.

} else { - +
- + + + + - @foreach (var t in _tags) + @foreach (var r in _refs) { - - - - - - + + + + + + } @@ -177,9 +179,8 @@ else
NameDriverData typeAccessActions
Effective nameRaw pathData typeAccessDisplay-name overrideActions
@t.Name@t.DriverInstanceId@t.DataType@t.AccessLevel - - +
@r.EffectiveName@r.RawPath@r.DataType@r.AccessLevel + + + +
} - + } else if (_activeTab == "vtags") { @@ -290,15 +291,13 @@ else private EquipmentEditDto? _equipment; private FormModel _form = new(); private IReadOnlyList<(string Id, string Display)> _lineOptions = Array.Empty<(string, string)>(); - private IReadOnlyList<(string Id, string Display)> _driverOptions = Array.Empty<(string, string)>(); - // --- Tags tab state. _tags is null until the tab is first activated (drives the lazy load + spinner). --- - private IReadOnlyList? _tags; - private string? _tagError; - private bool _tagModalVisible; - private bool _tagModalIsNew; - private TagEditDto? _tagModalExisting; - private IReadOnlyList<(string Id, string Display, string DriverType, string DriverConfig)> _tagDriverOptions = Array.Empty<(string, string, string, string)>(); + // --- Tags tab state (v3 reference-only). _refs is null until the tab is first activated (lazy load + + // spinner). _overrideEdits carries the per-row editable display-name override, keyed by reference id. --- + private IReadOnlyList? _refs; + private readonly Dictionary _overrideEdits = new(StringComparer.Ordinal); + private string? _refError; + private bool _refModalVisible; // --- Virtual Tags tab state. _vtags is null until the tab is first activated. --- private IReadOnlyList? _vtags; @@ -329,54 +328,48 @@ else { _activeTab = tab; if (IsNew) { return; } - if (tab == "tags" && _tags is null) { await ReloadTagsAsync(); } + if (tab == "tags" && _refs is null) { await ReloadReferencesAsync(); } else if (tab == "vtags" && _vtags is null) { await ReloadVirtualTagsAsync(); } else if (tab == "alarms" && _alarms is null) { await ReloadAlarmsAsync(); } } - // --- Tags tab handlers (mirror GlobalUns; the owning equipment is fixed = EquipmentId) --- + // --- Tags tab handlers (v3 reference-only; the owning equipment is fixed = EquipmentId) --- - private async Task ReloadTagsAsync() + private async Task ReloadReferencesAsync() { - _tags = await Svc.LoadTagsForEquipmentAsync(EquipmentId!); + _refs = await Svc.LoadReferencesForEquipmentAsync(EquipmentId!); + // Seed the per-row override edit buffer so each row's binds to a live value. + _overrideEdits.Clear(); + foreach (var r in _refs) { _overrideEdits[r.UnsTagReferenceId] = r.DisplayNameOverride; } } - private async Task OpenAddTag() + private void OpenAddReference() { - _tagError = null; - _tagModalIsNew = true; - _tagModalExisting = null; - _tagDriverOptions = await Svc.LoadTagDriversForEquipmentAsync(EquipmentId!); - _tagModalVisible = true; + _refError = null; + _refModalVisible = true; } - private async Task OpenEditTag(string tagId) + private async Task OnReferencesCommittedAsync() { - _tagError = null; - var dto = await Svc.LoadTagAsync(tagId); - if (dto is null) { _tagError = "That tag no longer exists; the list was refreshed."; await ReloadTagsAsync(); return; } - _tagModalIsNew = false; - _tagModalExisting = dto; - _tagDriverOptions = await Svc.LoadTagDriversForEquipmentAsync(EquipmentId!); - _tagModalVisible = true; + _refModalVisible = false; + await ReloadReferencesAsync(); } - private async Task OnTagSavedAsync() + private async Task SaveOverride(EquipmentReferenceRow r) { - _tagModalVisible = false; - await ReloadTagsAsync(); + _refError = null; + var edited = _overrideEdits.GetValueOrDefault(r.UnsTagReferenceId); + var res = await Svc.SetReferenceOverrideAsync(r.UnsTagReferenceId, edited, r.RowVersion); + if (res.Ok) { await ReloadReferencesAsync(); } + else { _refError = res.Error; } } - private async Task DeleteTag(string tagId) + private async Task RemoveReference(EquipmentReferenceRow r) { - _tagModalVisible = false; - _tagError = null; - // Load the tag fresh to capture its current RowVersion for the optimistic-concurrency delete. - var dto = await Svc.LoadTagAsync(tagId); - if (dto is null) { await ReloadTagsAsync(); return; } - var r = await Svc.DeleteTagAsync(tagId, dto.RowVersion); - if (r.Ok) { await ReloadTagsAsync(); } - else { _tagError = r.Error; } + _refError = null; + var res = await Svc.RemoveReferenceAsync(r.UnsTagReferenceId, r.RowVersion); + if (res.Ok) { await ReloadReferencesAsync(); } + else { _refError = res.Error; } } // --- Virtual Tags tab handlers --- @@ -478,7 +471,7 @@ else // path lands on Details because the field initializes to "details" and a fresh page instance // starts with that initial value. The Tags/Virtual Tags lists are reset to null below so the // lazy loaders re-fetch for the (possibly different) equipment this parameter set targets. - _tags = null; + _refs = null; _vtags = null; _alarms = null; if (!IsNew) @@ -489,7 +482,6 @@ else LoadFormFrom(_equipment); var ctx = await Svc.LoadEquipmentPickContextAsync(_equipment.UnsLineId); _lineOptions = ctx.Lines; - _driverOptions = ctx.Drivers; } } else @@ -497,7 +489,6 @@ else _form = new FormModel { UnsLineId = LineId ?? "" }; var ctx = await Svc.LoadEquipmentPickContextAsync(LineId); _lineOptions = ctx.Lines; - _driverOptions = ctx.Drivers; } _loading = false; } @@ -510,7 +501,6 @@ else Name = e.Name, MachineCode = e.MachineCode, UnsLineId = e.UnsLineId, - DriverInstanceId = e.DriverInstanceId, ZTag = e.ZTag, SAPID = e.SAPID, Manufacturer = e.Manufacturer, @@ -536,7 +526,6 @@ else _form.Name, _form.MachineCode, _form.UnsLineId, - _form.DriverInstanceId, _form.ZTag, _form.SAPID, _form.Manufacturer, @@ -582,7 +571,6 @@ else public string Name { get; set; } = ""; [Required] public string MachineCode { get; set; } = ""; [Required] public string UnsLineId { get; set; } = ""; - public string? DriverInstanceId { get; set; } public string? ZTag { get; set; } public string? SAPID { get; set; } public string? Manufacturer { get; set; } diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Raw/RawTree.razor b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Raw/RawTree.razor index 6aa815f3..fef10dcd 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Raw/RawTree.razor +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Raw/RawTree.razor @@ -69,6 +69,28 @@ /// [Parameter] public EventCallback OnRootsChanged { get; set; } + // --------------------------------------------------------------------------- + // v3 Batch 3 — raw-tag PICKER mode (opt-in; default off keeps the /raw usage byte-unchanged). + // In picker mode the mutation context-menus are suppressed: Tag leaves render a multi-select + // checkbox, and Device/TagGroup containers offer a "select all tags below" menu. The equipment + // page's "+ Add reference" modal drives this against a single cluster-scoped root. + // --------------------------------------------------------------------------- + + /// When true, render the tree as a raw-tag picker (checkboxes + select-all) instead of + /// the editing tree. Default false — the /raw editing usage is unaffected. + [Parameter] public bool PickerMode { get; set; } + + /// The shared, caller-owned set of selected raw TagIds (picker mode only). The component + /// mutates it in place and raises after every change. + [Parameter] public HashSet? SelectedTagIds { get; set; } + + /// Raised after the selection set changes (picker mode) so the host can update its count / footer. + [Parameter] public EventCallback OnSelectionChanged { get; set; } + + /// Supplies the raw TagIds beneath a Device/TagGroup node for the "select all tags below" + /// affordance (picker mode). The host wires this to IUnsTreeService.LoadDescendantTagIdsAsync. + [Parameter] public Func>>? ResolveDescendantTagIds { get; set; } + // --- Configure-driver modal (edit) --- private bool _driverCfgVisible; private string? _driverCfgId; @@ -198,6 +220,12 @@ private RenderFragment RenderRowBody(RawNode node, bool muted) => __builder => { + @if (PickerMode && node.Kind == RawNodeKind.Tag) + { + + } @node.DisplayName @if (muted) @@ -270,17 +298,67 @@ // named handlers below are the seam Wave B/C replaces with the real modals. // --------------------------------------------------------------------------- - private IReadOnlyList MenuFor(RawNode node) => node.Kind switch + private IReadOnlyList MenuFor(RawNode node) { - RawNodeKind.Cluster => ClusterMenu(node), - RawNodeKind.Folder => FolderMenu(node), - RawNodeKind.Driver => DriverMenu(node), - RawNodeKind.Device => DeviceMenu(node), - RawNodeKind.TagGroup => TagGroupMenu(node), - RawNodeKind.Tag => TagMenu(node), - _ => Array.Empty(), // Enterprise: label only, no menu. + // Picker mode: no mutation menus. Device/TagGroup containers get a "select all tags below" + // affordance; every other kind (and Tag leaves, which carry the checkbox) has no menu. + if (PickerMode) + { + return node.Kind is RawNodeKind.Device or RawNodeKind.TagGroup + ? PickerContainerMenu(node) + : Array.Empty(); + } + + return node.Kind switch + { + RawNodeKind.Cluster => ClusterMenu(node), + RawNodeKind.Folder => FolderMenu(node), + RawNodeKind.Driver => DriverMenu(node), + RawNodeKind.Device => DeviceMenu(node), + RawNodeKind.TagGroup => TagGroupMenu(node), + RawNodeKind.Tag => TagMenu(node), + _ => Array.Empty(), // Enterprise: label only, no menu. + }; + } + + // --- Picker-mode menu + selection helpers --- + + private List PickerContainerMenu(RawNode node) => new() + { + new() { Label = "Select all tags below", Icon = "☑", OnClick = () => SelectAllUnderAsync(node) }, + new() { Label = "Clear all tags below", Icon = "☐", OnClick = () => ClearAllUnderAsync(node) }, }; + private bool IsTagSelected(RawNode node) => + node.EntityId is not null && SelectedTagIds is not null && SelectedTagIds.Contains(node.EntityId); + + private async Task ToggleTagSelection(RawNode node, bool selected) + { + if (SelectedTagIds is null || node.EntityId is null) { return; } + if (selected) { SelectedTagIds.Add(node.EntityId); } + else { SelectedTagIds.Remove(node.EntityId); } + await OnSelectionChanged.InvokeAsync(); + StateHasChanged(); + } + + private async Task SelectAllUnderAsync(RawNode node) + { + if (SelectedTagIds is null || ResolveDescendantTagIds is null) { return; } + var ids = await ResolveDescendantTagIds(node); + foreach (var id in ids) { SelectedTagIds.Add(id); } + await OnSelectionChanged.InvokeAsync(); + StateHasChanged(); + } + + private async Task ClearAllUnderAsync(RawNode node) + { + if (SelectedTagIds is null || ResolveDescendantTagIds is null) { return; } + var ids = await ResolveDescendantTagIds(node); + foreach (var id in ids) { SelectedTagIds.Remove(id); } + await OnSelectionChanged.InvokeAsync(); + StateHasChanged(); + } + private List ClusterMenu(RawNode node) => new() { new() { Label = "New folder", Icon = "📁", OnClick = () => OnNewFolder(node) }, diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/AddReferenceModal.razor b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/AddReferenceModal.razor new file mode 100644 index 00000000..3d05abd8 --- /dev/null +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/AddReferenceModal.razor @@ -0,0 +1,125 @@ +@* v3 Batch 3 "+ Add reference" picker: reuses the Raw project tree (RawTree) in picker mode to + multi-select raw tags, scoped to the equipment's own cluster. The cluster scope is structural — + IUnsTreeService.LoadReferencePickerRootAsync hands back a SINGLE cluster root, so raw tags of any + other cluster are simply unreachable through the tree, not merely hidden. On commit the selected + tag ids are added as UnsTagReference rows via AddReferencesAsync; the host reloads its Tags list. *@ +@using ZB.MOM.WW.OtOpcUa.AdminUI.Uns +@using ZB.MOM.WW.OtOpcUa.AdminUI.Components.Shared.Raw +@inject IUnsTreeService Svc + +@if (Visible) +{ +
+ +} + +@code { + /// Whether the modal is shown. The host owns this flag. + [Parameter] public bool Visible { get; set; } + + /// The equipment the selected raw tags are referenced under. + [Parameter] public string? EquipmentId { get; set; } + + /// Raised after references are committed so the host can reload its Tags list and close. + [Parameter] public EventCallback OnCommitted { get; set; } + + /// Raised when the user cancels so the host can close. + [Parameter] public EventCallback OnCancel { get; set; } + + private IReadOnlyList _roots = Array.Empty(); + private readonly HashSet _selected = new(StringComparer.Ordinal); + private bool _busy; + private bool _loading; + private string? _error; + private bool _wasVisible; + + protected override async Task OnParametersSetAsync() + { + // Reset + reload only on the false→true transition so re-renders while open don't wipe state. + if (Visible && !_wasVisible) + { + _selected.Clear(); + _error = null; + _roots = Array.Empty(); + _loading = true; + StateHasChanged(); + + var root = string.IsNullOrEmpty(EquipmentId) + ? null + : await Svc.LoadReferencePickerRootAsync(EquipmentId); + _roots = root is null ? Array.Empty() : new[] { root }; + _loading = false; + } + _wasVisible = Visible; + } + + private Task> ResolveDescendantsAsync(RawNode node) => + Svc.LoadDescendantTagIdsAsync(node); + + // RawTree mutates _selected in place; this just re-renders the footer count. + private void OnSelectionChanged() => StateHasChanged(); + + private async Task CommitAsync() + { + if (_selected.Count == 0) { return; } + _busy = true; + _error = null; + try + { + var res = await Svc.AddReferencesAsync(EquipmentId!, _selected.ToList()); + if (res.Ok) { await OnCommitted.InvokeAsync(); } + else { _error = res.Error; } + } + finally + { + _busy = false; + } + } + + private Task CancelAsync() => OnCancel.InvokeAsync(); +} diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/ImportEquipmentModal.razor b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/ImportEquipmentModal.razor index e6cf2cf4..759875b4 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/ImportEquipmentModal.razor +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/ImportEquipmentModal.razor @@ -2,9 +2,10 @@ the modal parses it into EquipmentInput rows and calls ImportEquipmentAsync, then shows the Inserted / Skipped / Errors summary in place. The host owns visibility; "Close" raises OnImported so the page can reload the whole tree (an import can add equipment across many lines/clusters). - Required header columns (in order): Name, MachineCode, UnsLineId, DriverInstanceId. + Required header columns (in order): Name, MachineCode, UnsLineId. Optional: ZTag, SAPID, Manufacturer, Model. Existing rows are detected by MachineCode and - skipped (additive-only — no updates), matching the retired /clusters/{id}/equipment/import page. *@ + skipped (additive-only — no updates), matching the retired /clusters/{id}/equipment/import page. + v3: equipment no longer carries a driver, so the old DriverInstanceId column is gone. *@ @using ZB.MOM.WW.OtOpcUa.AdminUI.Uns @inject IUnsTreeService Svc @@ -21,7 +22,7 @@

Paste CSV below. Required header columns (in order): - Name, MachineCode, UnsLineId, DriverInstanceId. + Name, MachineCode, UnsLineId. Optional: ZTag, SAPID, Manufacturer, Model. Each row inserts one equipment with a freshly-generated EquipmentId. Existing rows are detected by MachineCode and skipped (additive-only — no updates). @@ -29,7 +30,7 @@ + placeholder="Name,MachineCode,UnsLineId,ZTag,SAPID,Manufacturer,Model mixer-01,MX_001,LINE-1,ZT-12345,SAP-9876,Siemens,SIMATIC-1500">

Simple comma-separated values only — fields containing commas are not supported.
@if (!string.IsNullOrWhiteSpace(_parseError)) @@ -72,8 +73,8 @@ } @code { - // Required, in order; DriverInstanceId may be left blank per row (driver-less equipment). - private static readonly string[] RequiredColumns = ["Name", "MachineCode", "UnsLineId", "DriverInstanceId"]; + // Required, in order. v3: equipment no longer binds a driver, so DriverInstanceId is gone. + private static readonly string[] RequiredColumns = ["Name", "MachineCode", "UnsLineId"]; /// Whether the modal is shown. The host owns this flag. [Parameter] public bool Visible { get; set; } @@ -133,7 +134,7 @@ /// /// Parses the pasted CSV into rows. Requires a header row whose first - /// four columns are Name, MachineCode, UnsLineId, DriverInstanceId (case-insensitive); the optional + /// three columns are Name, MachineCode, UnsLineId (case-insensitive); the optional /// ZTag/SAPID/Manufacturer/Model follow. Blank optional cells parse as null. Returns /// null (and sets ) when the CSV is empty or the header is wrong. /// @@ -169,11 +170,10 @@ Name: parts[0], MachineCode: parts[1], UnsLineId: parts[2], - DriverInstanceId: NullIfEmpty(parts, 3), - ZTag: NullIfEmpty(parts, 4), - SAPID: NullIfEmpty(parts, 5), - Manufacturer: NullIfEmpty(parts, 6), - Model: NullIfEmpty(parts, 7), + ZTag: NullIfEmpty(parts, 3), + SAPID: NullIfEmpty(parts, 4), + Manufacturer: NullIfEmpty(parts, 5), + Model: NullIfEmpty(parts, 6), SerialNumber: null, HardwareRevision: null, SoftwareRevision: null, diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/TagModal.razor b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/TagModal.razor deleted file mode 100644 index a91a79be..00000000 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/TagModal.razor +++ /dev/null @@ -1,557 +0,0 @@ -@* Create/edit modal for an equipment-bound tag, wired straight into IUnsTreeService. The host page - owns visibility and supplies the owning equipment id (create) or the loaded TagEditDto (edit), plus - the equipment-scoped candidate-driver list. Tree tags are always equipment-bound (decision #110), so - the legacy SystemPlatform/FolderPath branch is dropped entirely — there is no equipment selector - either, the owning equipment is fixed. On a successful save it raises OnSaved so the host can - refresh the equipment's children in place. *@ -@using System.ComponentModel.DataAnnotations -@using System.Text.Json -@using Microsoft.AspNetCore.Components.Forms -@using ZB.MOM.WW.OtOpcUa.AdminUI.Uns -@using ZB.MOM.WW.OtOpcUa.AdminUI.Uns.TagEditors -@using ZB.MOM.WW.OtOpcUa.AdminUI.Components.Shared.Drivers -@using ZB.MOM.WW.OtOpcUa.AdminUI.Components.Shared.Drivers.Pickers -@using ZB.MOM.WW.OtOpcUa.Configuration.Enums -@inject IUnsTreeService Svc - -@if (Visible) -{ -
- -} - -@code { - private static readonly string[] DataTypes = - ["Boolean", "SByte", "Byte", "Int16", "UInt16", "Int32", "UInt32", - "Int64", "UInt64", "Float", "Double", "String", "DateTime", "Guid", "ByteString"]; - - /// Whether the modal is shown. The host owns this flag. - [Parameter] public bool Visible { get; set; } - - /// true to create a new tag; false to edit . - [Parameter] public bool IsNew { get; set; } - - /// The owning equipment id the created tag binds to (used only on create). - [Parameter] public string? EquipmentId { get; set; } - - /// The tag being edited, when is false. - [Parameter] public TagEditDto? Existing { get; set; } - - /// The candidate drivers — scoped to the equipment's cluster by the host — as - /// (Id, Display, DriverType, DriverConfig) tuples. DriverType drives typed-editor dispatch; - /// DriverConfig feeds the Galaxy live-browse picker for GalaxyMxGateway drivers. - [Parameter] public IReadOnlyList<(string Id, string Display, string DriverType, string DriverConfig)> Drivers { get; set; } = Array.Empty<(string, string, string, string)>(); - - /// Raised after a successful create/save so the host can refresh the equipment's children and close. - [Parameter] public EventCallback OnSaved { get; set; } - - /// Raised when the user cancels so the host can close. - [Parameter] public EventCallback OnCancel { get; set; } - - private FormModel _form = new(); - private bool _busy; - private string? _error; - - // Galaxy live-browse picker state. Only meaningful when the selected driver is a GalaxyMxGateway. - private bool _showGalaxyPicker; - private string _galaxyAddress = ""; - - // True when the attribute most-recently selected in the Galaxy picker is itself an alarm - // (DriverAttributeInfo.IsAlarm). On commit, this pre-fills a default native-alarm object into the - // TagConfig (when none is present) so the operator can author the alarm in one pass. - private bool _galaxyPickedIsAlarm; - - // Driver-agnostic server-side HistoryRead intent (root `isHistorized` / `historianTagname`), reflected - // for the "Historize this tag" controls. Re-read from _form.TagConfig whenever the modal (re)opens or - // the driver changes; the change handlers merge it back onto _form.TagConfig via TagHistorizeConfig. - private TagHistorizeConfig.HistorizeState _historizeState; - - // Driver-agnostic array-shape intent (root `isArray` / `arrayLength`), reflected for the array controls. - // Re-read from _form.TagConfig whenever the modal (re)opens or the driver changes; the change handlers - // merge it back onto _form.TagConfig via TagArrayConfig (same pattern as _historizeState above). - private TagArrayConfig.ArrayState _arrayState; - - // The DriverType of the currently-selected driver (drives editor dispatch). Null when no driver chosen. - private string? SelectedDriverType => - Drivers.FirstOrDefault(d => d.Id == _form.DriverInstanceId).DriverType; - - // The DriverConfig JSON of the currently-selected driver — fed to the Galaxy picker so it browses the - // right gateway. Defaults to "{}" when no driver is chosen or the config is empty. - private string SelectedDriverConfig - { - get - { - var cfg = Drivers.FirstOrDefault(d => d.Id == _form.DriverInstanceId).DriverConfig; - return string.IsNullOrEmpty(cfg) ? "{}" : cfg; - } - } - - // True when the selected driver is a GalaxyMxGateway — Galaxy points are authored as - // {"FullName":"tag_name.AttributeName"} via the live-browse picker rather than a typed editor. - private bool IsGalaxyDriver => SelectedDriverType == "GalaxyMxGateway"; - - // When the operator switches drivers, the previous driver's TagConfig schema no longer applies — - // reset it so the newly-dispatched typed editor starts clean (no stale/leaked keys from the old - // driver). Fires only on a user dropdown change (@bind-Value:after), not on the initial edit-load. - private void OnDriverChanged() - { - _form.TagConfig = "{}"; - // The Galaxy reference belongs to the previous driver; clear the picker's working address too. - _galaxyAddress = ""; - _galaxyPickedIsAlarm = false; - // The reset TagConfig carries no history intent — reflect that in the historize controls. - _historizeState = TagHistorizeConfig.Read(_form.TagConfig); - // Likewise the reset TagConfig carries no array intent. - _arrayState = TagArrayConfig.Read(_form.TagConfig); - } - - // The operator picked a Galaxy reference (tag_name.AttributeName); store it as the canonical - // {"FullName":"..."} TagConfig the Galaxy driver resolves to an MXAccess reference. Default - // (PascalCase) serialization yields the "FullName" key the driver/walker reads. - // - // When the picked attribute is itself an alarm (DriverAttributeInfo.IsAlarm), pre-seed a default - // native-alarm `alarm` object so the tag materialises as a Part 9 condition and Task 3's - // "Historize to AVEVA" toggle auto-appears — sparing the operator hand-written JSON. NativeAlarmModel - // .SeedDefaultAlarm only seeds when absent (never overwrites an authored alarm) and preserves FullName. - private void OnGalaxyAddressPicked(string address) - { - _galaxyAddress = address; - // Re-picking a Galaxy address owns ONLY the address-derived FullName key — apply it over the EXISTING - // TagConfig so every other user-edited field survives verbatim. This preserves a hand-authored `alarm` - // object (FB-4: a re-pick must never clobber edited alarm fields) as well as the root history/array - // intent and any driver/unknown keys. TagConfigJson.SetFullName uses the same preserve-unknown idiom - // as the historize/array merge seams. - var config = TagConfigJson.SetFullName(_form.TagConfig, address); - _form.TagConfig = _galaxyPickedIsAlarm - ? NativeAlarmModel.SeedDefaultAlarm(config) - : config; - _historizeState = TagHistorizeConfig.Read(_form.TagConfig); - _arrayState = TagArrayConfig.Read(_form.TagConfig); - } - - private IDictionary BuildEditorParameters() => new Dictionary - { - ["ConfigJson"] = _form.TagConfig, - ["ConfigJsonChanged"] = EventCallback.Factory.Create(this, v => _form.TagConfig = v), - ["DriverType"] = SelectedDriverType ?? "", - ["GetDriverConfigJson"] = (Func)(() => SelectedDriverConfig), - }; - - // Cache a single NativeAlarmModel parse keyed on the current TagConfig string, so the two computed - // properties below don't each re-parse the JSON on every render. Re-parsed only when TagConfig changes. - private NativeAlarmModel _nativeAlarm = NativeAlarmModel.FromJson("{}"); - private string? _nativeAlarmSource; - - private NativeAlarmModel NativeAlarm - { - get - { - if (_nativeAlarmSource != _form.TagConfig) - { - _nativeAlarmSource = _form.TagConfig; - _nativeAlarm = NativeAlarmModel.FromJson(_form.TagConfig); - } - return _nativeAlarm; - } - } - - // True when the current TagConfig carries an `alarm` object — i.e. the tag is materialised as a Part 9 - // native-alarm condition rather than a value variable. Gates the "Historize to AVEVA" toggle's visibility. - private bool HasNativeAlarm => NativeAlarm.IsAlarm; - - // The native alarm's HistorizeToAveva intent reflected for the checkbox: absent (null) ⇒ historize - // (default-on at the server gate), so the box is checked for both null and explicit true; only an - // explicit false leaves it unchecked. - private bool AlarmHistorizeToAveva => NativeAlarm.HistorizeToAveva != false; - - // Toggle the alarm.historizeToAveva opt-out in the raw TagConfig. Checked ⇒ remove the key (null ⇒ - // absent ⇒ historize default-on); unchecked ⇒ write an explicit false (suppress the durable AVEVA row). - // Unknown keys at the root + inside `alarm` are preserved across the edit (NativeAlarmModel round-trip). - private void OnAlarmHistorizeChanged(ChangeEventArgs e) - { - var model = NativeAlarmModel.FromJson(_form.TagConfig); - if (!model.IsAlarm) { return; } - model.HistorizeToAveva = e.Value is true ? null : false; - _form.TagConfig = model.ToJson(); - } - - // Toggle the root `isHistorized` tag-value history intent in the raw TagConfig, merged via the pure - // TagHistorizeConfig seam so the typed editor's driver-specific keys are preserved. Distinct from the - // native-alarm "Historize to AVEVA" opt-out above (that gates alarm-transition history, not tag values). - private void OnHistorizeChanged(ChangeEventArgs e) - { - var isHistorized = e.Value is true; - _form.TagConfig = TagHistorizeConfig.Set(_form.TagConfig, isHistorized, _historizeState.HistorianTagname); - _historizeState = TagHistorizeConfig.Read(_form.TagConfig); - } - - // Merge the optional historian-tagname override (root `historianTagname`) into the raw TagConfig. - private void OnHistorianTagnameChanged(ChangeEventArgs e) - { - var tagname = e.Value?.ToString() ?? string.Empty; - _form.TagConfig = TagHistorizeConfig.Set(_form.TagConfig, _historizeState.IsHistorized, tagname); - _historizeState = TagHistorizeConfig.Read(_form.TagConfig); - } - - // Toggle the root `isArray` array-shape intent in the raw TagConfig, merged via the pure TagArrayConfig - // seam so the typed editor's driver-specific keys are preserved. Clearing it drops `arrayLength` too - // (no orphan length), so the carried _arrayState.ArrayLength is irrelevant when unchecking. - private void OnIsArrayChanged(ChangeEventArgs e) - { - var isArray = e.Value is true; - _form.TagConfig = TagArrayConfig.Set(_form.TagConfig, isArray, _arrayState.ArrayLength); - _arrayState = TagArrayConfig.Read(_form.TagConfig); - } - - // Merge the array length (root `arrayLength`) into the raw TagConfig. A blank/zero/negative/non-numeric - // entry parses to null, so the key is dropped until a positive length is typed (and SaveAsync rejects - // an array with no positive length). - private void OnArrayLengthChanged(ChangeEventArgs e) - { - var length = ParsePositiveLength(e.Value?.ToString()); - _form.TagConfig = TagArrayConfig.Set(_form.TagConfig, _arrayState.IsArray, length); - _arrayState = TagArrayConfig.Read(_form.TagConfig); - } - - // Parse the numeric-input string to a positive uint, or null for blank/zero/negative/overflow/non-numeric. - private static uint? ParsePositiveLength(string? raw) - => uint.TryParse(raw, out var u) && u > 0 ? u : null; - - protected override void OnParametersSet() - { - // Rebuild the working form whenever the host (re)opens the modal for a fresh target. - if (IsNew) - { - _form = new FormModel(); - } - else if (Existing is not null) - { - _form = new FormModel - { - TagId = Existing.TagId, - Name = Existing.Name, - DriverInstanceId = Existing.DriverInstanceId, - DataType = Existing.DataType, - AccessLevel = Existing.AccessLevel, - WriteIdempotent = Existing.WriteIdempotent, - PollGroupId = Existing.PollGroupId, - TagConfig = Existing.TagConfig, - }; - } - _error = null; - _showGalaxyPicker = false; - _galaxyPickedIsAlarm = false; - // Seed the picker's working address from any existing {"FullName":"..."} so it opens pre-populated. - _galaxyAddress = ReadFullName(_form.TagConfig); - // Seed the historize controls from any existing root isHistorized/historianTagname keys. - _historizeState = TagHistorizeConfig.Read(_form.TagConfig); - // Seed the array controls from any existing root isArray/arrayLength keys. - _arrayState = TagArrayConfig.Read(_form.TagConfig); - } - - // Best-effort extraction of FullName from a Galaxy TagConfig; returns "" when absent or unparseable. - private static string ReadFullName(string? configJson) - { - if (string.IsNullOrWhiteSpace(configJson)) return ""; - try - { - using var doc = JsonDocument.Parse(configJson); - return doc.RootElement.ValueKind == JsonValueKind.Object - && doc.RootElement.TryGetProperty("FullName", out var fn) - && fn.ValueKind == JsonValueKind.String - ? fn.GetString() ?? "" - : ""; - } - catch (JsonException) - { - return ""; - } - } - - private async Task SaveAsync() - { - _busy = true; - _error = null; - try - { - // Client-side per-driver config validation (the typed editor's Validate()), so a blank - // required field is caught here rather than silently saving and failing at deploy/connect. - var configError = TagConfigValidator.Validate(SelectedDriverType, _form.TagConfig); - if (configError is not null) - { - _error = configError; - return; - } - - // Driver-agnostic array-shape validation: an array tag needs a positive length. Mirrors the - // per-driver config validation above so a missing length is caught here rather than at deploy. - var arrayError = TagArrayConfig.Validate(_arrayState.IsArray, _arrayState.ArrayLength); - if (arrayError is not null) - { - _error = arrayError; - return; - } - - var input = new TagInput( - _form.TagId, - _form.Name, - _form.DriverInstanceId, - _form.DataType, - _form.AccessLevel, - _form.WriteIdempotent, - _form.PollGroupId, - _form.TagConfig); - - var result = IsNew - ? await Svc.CreateTagAsync(EquipmentId!, input) - : await Svc.UpdateTagAsync(Existing!.TagId, input, Existing.RowVersion); - - if (result.Ok) - { - await OnSaved.InvokeAsync(); - } - else - { - _error = result.Error; - } - } - finally - { - _busy = false; - } - } - - private Task CancelAsync() => OnCancel.InvokeAsync(); - - private sealed class FormModel - { - [Required, RegularExpression("^[A-Za-z0-9_-]+$")] public string TagId { get; set; } = ""; - [Required] public string Name { get; set; } = ""; - [Required] public string DriverInstanceId { get; set; } = ""; - public string DataType { get; set; } = "Float"; - public TagAccessLevel AccessLevel { get; set; } = TagAccessLevel.Read; - public bool WriteIdempotent { get; set; } - public string? PollGroupId { get; set; } - [Required] public string TagConfig { get; set; } = "{}"; - } -} diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EquipmentChildRows.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EquipmentChildRows.cs index b1cee5e6..ec313790 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EquipmentChildRows.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EquipmentChildRows.cs @@ -9,3 +9,28 @@ public sealed record EquipmentTagRow( /// A virtual-tag row for the equipment page's Virtual Tags tab table. public sealed record EquipmentVirtualTagRow(string VirtualTagId, string Name, string DataType, string ScriptId, bool Enabled); + +/// +/// A UNS tag-reference row for the equipment page's Tags tab table (v3 reference-only equipment). Each +/// row projects a together with the backing raw +/// tag's inherited (read-only) datatype/access and computed RawPath. The effective name is the +/// DisplayNameOverride when set, else the backing raw tag's Name. RowVersion is the +/// reference row's concurrency token, echoed on the override-set / remove mutations. +/// +/// The reference's stable logical id (the mutation key). +/// Override else the raw tag's Name — the UNS leaf name. +/// The backing raw tag's computed RawPath (folder/driver/device/group/tag). +/// Inherited OPC UA built-in type name from the raw tag (read-only). +/// Inherited access level from the raw tag (read-only). +/// The optional display-name override; null = use the raw name. +/// Sibling display ordering within the equipment's Tags list. +/// The reference row's optimistic-concurrency token. +public sealed record EquipmentReferenceRow( + string UnsTagReferenceId, + string EffectiveName, + string RawPath, + string DataType, + TagAccessLevel AccessLevel, + string? DisplayNameOverride, + int SortOrder, + byte[] RowVersion); diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EquipmentInput.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EquipmentInput.cs index 4a39f767..dba8d117 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EquipmentInput.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/EquipmentInput.cs @@ -11,7 +11,6 @@ namespace ZB.MOM.WW.OtOpcUa.AdminUI.Uns; /// UNS level-5 segment; matches ^[a-z0-9-]{1,32}$. /// Operator colloquial id; unique fleet-wide. /// Logical FK to the owning . -/// Optional driver binding; whitespace/empty means driver-less. /// Optional ERP equipment id. /// Optional SAP PM equipment id. /// Optional OPC 40010 manufacturer name. @@ -28,7 +27,6 @@ public sealed record EquipmentInput( string Name, string MachineCode, string UnsLineId, - string? DriverInstanceId, string? ZTag, string? SAPID, string? Manufacturer, diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/IUnsTreeService.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/IUnsTreeService.cs index 1faecc18..b2dd3f01 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/IUnsTreeService.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/IUnsTreeService.cs @@ -139,6 +139,82 @@ public interface IUnsTreeService /// The equipment's virtual-tag rows ordered by Name; empty if it has none. Task> LoadVirtualTagsForEquipmentAsync(string equipmentId, CancellationToken ct = default); + // --------------------------------------------------------------------------------------------- + // v3 UNS reference-only equipment: the Tags tab lists UnsTagReference rows pointing at raw tags. + // --------------------------------------------------------------------------------------------- + + /// + /// Loads the rows for a single equipment as flat + /// projections for the equipment page's Tags tab, ordered by SortOrder then effective name. + /// Each row carries the effective name (override else the backing raw tag's Name), the backing + /// tag's computed RawPath, its inherited (read-only) datatype/access, the optional display-name + /// override, and the reference's concurrency token. Reads untracked. Returns an empty list when the + /// equipment has no references. + /// + /// The equipment whose references to load. + /// A token to cancel the load. + /// The equipment's reference rows; empty if it has none. + Task> LoadReferencesForEquipmentAsync(string equipmentId, CancellationToken ct = default); + + /// + /// Adds one per supplied raw TagId to an + /// equipment. Every backing tag MUST live in the same cluster as the equipment (cross-cluster + /// references are rejected). Each new reference's effective name (the raw tag's Name — no + /// override on add) must be unique within the equipment across references, VirtualTags, and + /// ScriptedAlarms (enforced via ), and a tag already referenced by + /// the equipment is rejected. The batch is all-or-nothing. + /// + /// The referencing equipment. + /// The raw tag ids to reference. + /// A token to cancel the operation. + /// Success, or the first guard/cluster/duplicate failure (nothing is added). + Task AddReferencesAsync(string equipmentId, IReadOnlyList tagIds, CancellationToken ct = default); + + /// + /// Removes a UNS tag reference. A missing row is treated as success (already gone). Uses last-write-wins + /// optimistic concurrency on . + /// + /// The reference to remove. + /// The concurrency token the caller last read. + /// A token to cancel the operation. + /// Success, a concurrency failure, or a delete-failed failure. + Task RemoveReferenceAsync(string unsTagReferenceId, byte[] rowVersion, CancellationToken ct = default); + + /// + /// Sets (or clears) a reference's DisplayNameOverride. A whitespace-only override collapses to + /// null (use the raw name). The resulting effective name (override else the backing raw tag's + /// Name) must be unique within the equipment across references, VirtualTags, and ScriptedAlarms + /// (enforced via , excluding this reference). Uses last-write-wins + /// optimistic concurrency. + /// + /// The reference to update. + /// The new override, or null/blank to clear it. + /// The concurrency token the caller last read. + /// A token to cancel the operation. + /// Success, a missing-row failure, a name-collision failure, or a concurrency failure. + Task SetReferenceOverrideAsync(string unsTagReferenceId, string? displayNameOverride, byte[] rowVersion, CancellationToken ct = default); + + /// + /// Builds the single cluster-rooted that seeds the "+ Add reference" raw-tag + /// picker for an equipment, structurally scoped to the equipment's own cluster (raw tags in any other + /// cluster are unreachable through this root — the scope is enforced by the query, not merely hidden). + /// The picker's RawTree lazily expands it via . + /// Returns null when the equipment cannot be resolved to a cluster. + /// + /// The equipment whose cluster scopes the picker. + /// A token to cancel the load. + /// The cluster root node, or null when the equipment/cluster can't be resolved. + Task LoadReferencePickerRootAsync(string equipmentId, CancellationToken ct = default); + + /// + /// Enumerates every raw TagId beneath a Device or TagGroup picker node (the whole subtree), for + /// the picker's "select all tags below" affordance. Returns an empty list for non-container node kinds. + /// + /// The picker node (Device or TagGroup) to enumerate tags under. + /// A token to cancel the query. + /// The tag ids in the node's subtree; empty for unsupported kinds. + Task> LoadDescendantTagIdsAsync(RawNode node, CancellationToken ct = default); + /// /// Loads a single UNS area projected for editing, or null if it no longer exists. /// Reads untracked and captures the current concurrency token for last-write-wins saves. @@ -284,24 +360,22 @@ public interface IUnsTreeService /// /// Creates a new equipment under a UNS line. The EquipmentId is system-generated /// (EQ- + the first 12 hex chars of a fresh EquipmentUuid). - /// Fails if the line is unset, if the MachineCode is already used fleet-wide, or if the - /// driver-cluster guard trips. Whitespace-only DriverInstanceId/ZTag/SAPID - /// collapse to null. + /// Fails if the line is unset or if the MachineCode is already used fleet-wide. Whitespace-only + /// ZTag/SAPID collapse to null. (v3: equipment no longer binds a driver — the reference-only + /// Tags tab points at raw tags instead — so no driver-cluster guard applies.) /// /// The operator-editable equipment fields. /// A token to cancel the operation. - /// Success, a missing-line failure, a duplicate-MachineCode failure, or a cluster-guard failure. + /// Success, a missing-line failure, or a duplicate-MachineCode failure. Task CreateEquipmentAsync(EquipmentInput input, CancellationToken ct = default); /// /// Bulk-imports equipment from a parsed set of rows in a single /// context, applying the same rules as the single-add path: a row whose UnsLineId does not - /// exist is an error; a row whose DriverInstanceId is set but does not resolve is an error; - /// a driver-bound row whose driver is in a different cluster than its line fails the cluster - /// guard; and a row whose MachineCode already exists in the DB or earlier in the - /// same batch is silently skipped (additive-only — never an update). Inserted rows get a + /// exist is an error; and a row whose MachineCode already exists in the DB or earlier + /// in the same batch is silently skipped (additive-only — never an update). Inserted rows get a /// system-generated EQ- id and a fresh EquipmentUuid. All inserts are saved once at - /// the end. + /// the end. (v3: equipment no longer binds a driver, so there is no per-row driver-cluster guard.) /// /// The parsed equipment rows to import. /// A token to cancel the operation. @@ -309,16 +383,16 @@ public interface IUnsTreeService Task ImportEquipmentAsync(IReadOnlyList rows, CancellationToken ct = default); /// - /// Updates an equipment's mutable fields (driver binding, line, name, MachineCode, external - /// ids, and the OPC 40010 identification fields). The driver-cluster guard blocks - /// binding to a driver in a different cluster than the equipment's line. Uses last-write-wins - /// optimistic concurrency on . + /// Updates an equipment's mutable fields (line, name, MachineCode, external ids, and the OPC 40010 + /// identification fields). Fails on a MachineCode already used by another row. Uses last-write-wins + /// optimistic concurrency on . (v3: equipment + /// no longer binds a driver, so there is no driver-cluster guard.) /// /// The equipment to update. /// The new operator-editable equipment fields. /// The concurrency token the caller last read. /// A token to cancel the operation. - /// Success, a missing-row failure, a cluster-guard failure, or a concurrency failure. + /// Success, a missing-row failure, a duplicate-MachineCode failure, or a concurrency failure. Task UpdateEquipmentAsync(string equipmentId, EquipmentInput input, byte[] rowVersion, CancellationToken ct = default); /// diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs index 0a12e7ce..a5837358 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs @@ -18,8 +18,17 @@ namespace ZB.MOM.WW.OtOpcUa.AdminUI.Uns; /// every AdminUI page uses — so the service is safe to register as Scoped and used per /// Blazor circuit. /// -public sealed class UnsTreeService(IDbContextFactory dbFactory) : IUnsTreeService +public sealed class UnsTreeService( + IDbContextFactory dbFactory, + IEffectiveNameGuard? guard = null) : IUnsTreeService { + // The v3 Batch-3 effective-name uniqueness guard (references / VirtualTags / ScriptedAlarms share the + // equipment's UNS NodeId space). WP2 registers the real implementation; production DI always injects it. + // A null (unregistered) guard falls back to a no-op — collisions are then caught only at the deploy + // gate — which also lets unit tests that don't exercise the guard construct the service with just a + // db factory. Tests that DO exercise the guard pass a fake. + private readonly IEffectiveNameGuard _guard = guard ?? NoOpEffectiveNameGuard.Instance; + /// public async Task> LoadStructureAsync(CancellationToken ct = default) { @@ -97,6 +106,369 @@ public sealed class UnsTreeService(IDbContextFactory dbF .ToListAsync(ct); } + // --------------------------------------------------------------------------------------------- + // v3 UNS reference-only equipment (Batch 3): the Tags tab lists UnsTagReference rows. + // --------------------------------------------------------------------------------------------- + + /// + public async Task> LoadReferencesForEquipmentAsync( + string equipmentId, CancellationToken ct = default) + { + await using var db = await dbFactory.CreateDbContextAsync(ct); + + var refs = await db.UnsTagReferences.AsNoTracking() + .Where(r => r.EquipmentId == equipmentId) + .OrderBy(r => r.SortOrder).ThenBy(r => r.UnsTagReferenceId) + .Select(r => new + { + r.UnsTagReferenceId, + r.TagId, + r.DisplayNameOverride, + r.SortOrder, + r.RowVersion, + }) + .ToListAsync(ct); + + if (refs.Count == 0) return Array.Empty(); + + // Load the backing raw tags (name + inherited datatype/access), then compute each RawPath from the + // equipment cluster's raw topology through the shared RawPathResolver (identity authority). + var tagIds = refs.Select(r => r.TagId).Distinct().ToList(); + var tags = (await db.Tags.AsNoTracking() + .Where(t => tagIds.Contains(t.TagId)) + .Select(t => new { t.TagId, t.DeviceId, t.TagGroupId, t.Name, t.DataType, t.AccessLevel }) + .ToListAsync(ct)) + .ToDictionary(t => t.TagId, StringComparer.Ordinal); + + var cluster = await ResolveEquipmentClusterAsync(db, equipmentId, ct); + var resolver = await BuildClusterRawPathResolverAsync(db, cluster, ct); + + var rows = new List(refs.Count); + foreach (var r in refs) + { + if (!tags.TryGetValue(r.TagId, out var tag)) + { + // Backing tag missing (should not happen — raw-tag delete is reference-blocked); surface a + // clearly-degraded row rather than dropping it so the operator can remove the dangling ref. + rows.Add(new EquipmentReferenceRow( + r.UnsTagReferenceId, r.DisplayNameOverride ?? "(missing tag)", "(missing tag)", + "", TagAccessLevel.Read, r.DisplayNameOverride, r.SortOrder, r.RowVersion)); + continue; + } + + var rawPath = resolver?.TryBuildTagPath(tag.DeviceId, tag.TagGroupId, tag.Name) ?? tag.Name; + var effectiveName = string.IsNullOrEmpty(r.DisplayNameOverride) ? tag.Name : r.DisplayNameOverride; + rows.Add(new EquipmentReferenceRow( + r.UnsTagReferenceId, effectiveName, rawPath, tag.DataType, tag.AccessLevel, + r.DisplayNameOverride, r.SortOrder, r.RowVersion)); + } + + return rows; + } + + /// + public async Task AddReferencesAsync( + string equipmentId, IReadOnlyList tagIds, CancellationToken ct = default) + { + ArgumentNullException.ThrowIfNull(tagIds); + var distinctTagIds = tagIds.Where(t => !string.IsNullOrEmpty(t)).Distinct(StringComparer.Ordinal).ToList(); + if (distinctTagIds.Count == 0) return new UnsMutationResult(false, "Pick at least one raw tag to reference."); + + await using var db = await dbFactory.CreateDbContextAsync(ct); + + if (!await db.Equipment.AnyAsync(e => e.EquipmentId == equipmentId, ct)) + return new UnsMutationResult(false, $"Equipment '{equipmentId}' not found."); + + var equipmentCluster = await ResolveEquipmentClusterAsync(db, equipmentId, ct); + if (equipmentCluster is null) + return new UnsMutationResult(false, $"Equipment '{equipmentId}' does not resolve to a cluster."); + + // Load the backing tags + the cluster each lives in (Tag → Device → DriverInstance.ClusterId). + var tags = await db.Tags.AsNoTracking() + .Where(t => distinctTagIds.Contains(t.TagId)) + .Join(db.Devices.AsNoTracking(), t => t.DeviceId, dev => dev.DeviceId, (t, dev) => new { t, dev.DriverInstanceId }) + .Join(db.DriverInstances.AsNoTracking(), x => x.DriverInstanceId, d => d.DriverInstanceId, + (x, d) => new { x.t.TagId, x.t.Name, DriverCluster = d.ClusterId }) + .ToListAsync(ct); + + var tagById = tags.ToDictionary(t => t.TagId, StringComparer.Ordinal); + + // Existing references on the equipment (to reject re-referencing the same tag). + var alreadyReferenced = (await db.UnsTagReferences.AsNoTracking() + .Where(r => r.EquipmentId == equipmentId) + .Select(r => r.TagId) + .ToListAsync(ct)) + .ToHashSet(StringComparer.Ordinal); + + var maxSort = await db.UnsTagReferences.AsNoTracking() + .Where(r => r.EquipmentId == equipmentId) + .Select(r => (int?)r.SortOrder) + .MaxAsync(ct) ?? -1; + + // Track effective names proposed within THIS batch so two raw tags sharing a Name are caught (the + // guard sees only persisted rows; a same-batch collision would otherwise slip through). + var batchNames = new HashSet(StringComparer.Ordinal); + var pending = new List(); + + foreach (var tagId in distinctTagIds) + { + if (!tagById.TryGetValue(tagId, out var tag)) + return new UnsMutationResult(false, $"Raw tag '{tagId}' not found."); + + if (!string.Equals(tag.DriverCluster, equipmentCluster, StringComparison.Ordinal)) + return new UnsMutationResult(false, + $"Raw tag '{tag.Name}' is in cluster '{tag.DriverCluster}' but the equipment is in cluster '{equipmentCluster}' — cross-cluster references are not allowed."); + + if (alreadyReferenced.Contains(tagId)) + return new UnsMutationResult(false, $"Raw tag '{tag.Name}' is already referenced by this equipment."); + + // Effective name at add = the raw tag's Name (no override yet). + if (!batchNames.Add(tag.Name)) + return new UnsMutationResult(false, + $"Two selected raw tags share the effective name '{tag.Name}'; set a display-name override so they stay unique within the equipment."); + + var collision = await _guard.CheckAsync(equipmentId, tag.Name, EffectiveNameSourceKind.Reference, null, ct); + if (collision is not null) return new UnsMutationResult(false, collision); + + pending.Add(new UnsTagReference + { + UnsTagReferenceId = $"UTR-{Guid.NewGuid():N}"[..16], + EquipmentId = equipmentId, + TagId = tagId, + DisplayNameOverride = null, + SortOrder = ++maxSort, + }); + } + + db.UnsTagReferences.AddRange(pending); + try + { + await db.SaveChangesAsync(ct); + return new UnsMutationResult(true, null); + } + catch (DbUpdateException) + { + // A concurrent add slipped a same-(equipment,tag) or same-name row past the pre-check. + return new UnsMutationResult(false, "Add failed — a reference at one of these tags was created concurrently. Reload and retry."); + } + } + + /// + public async Task RemoveReferenceAsync( + string unsTagReferenceId, byte[] rowVersion, CancellationToken ct = default) + { + await using var db = await dbFactory.CreateDbContextAsync(ct); + + var entity = await db.UnsTagReferences.FirstOrDefaultAsync(r => r.UnsTagReferenceId == unsTagReferenceId, ct); + if (entity is null) return new UnsMutationResult(true, null); + + db.Entry(entity).Property(e => e.RowVersion).OriginalValue = rowVersion; + db.UnsTagReferences.Remove(entity); + + try + { + await db.SaveChangesAsync(ct); + return new UnsMutationResult(true, null); + } + catch (DbUpdateConcurrencyException) + { + return new UnsMutationResult(false, "Another user changed this reference while you were viewing it."); + } + catch (Exception ex) + { + return new UnsMutationResult(false, $"Remove failed: {ex.Message}."); + } + } + + /// + public async Task SetReferenceOverrideAsync( + string unsTagReferenceId, string? displayNameOverride, byte[] rowVersion, CancellationToken ct = default) + { + var normalized = string.IsNullOrWhiteSpace(displayNameOverride) ? null : displayNameOverride.Trim(); + + await using var db = await dbFactory.CreateDbContextAsync(ct); + + var entity = await db.UnsTagReferences.FirstOrDefaultAsync(r => r.UnsTagReferenceId == unsTagReferenceId, ct); + if (entity is null) return new UnsMutationResult(false, "Row no longer exists."); + + db.Entry(entity).Property(e => e.RowVersion).OriginalValue = rowVersion; + + // Effective name = the override when set, else the backing raw tag's Name. + var rawName = await db.Tags.AsNoTracking() + .Where(t => t.TagId == entity.TagId) + .Select(t => t.Name) + .FirstOrDefaultAsync(ct); + var effectiveName = normalized ?? rawName ?? string.Empty; + + var collision = await _guard.CheckAsync( + entity.EquipmentId, effectiveName, EffectiveNameSourceKind.Reference, entity.UnsTagReferenceId, ct); + if (collision is not null) return new UnsMutationResult(false, collision); + + entity.DisplayNameOverride = normalized; + + try + { + await db.SaveChangesAsync(ct); + return new UnsMutationResult(true, null); + } + catch (DbUpdateConcurrencyException) + { + return new UnsMutationResult(false, "Another user changed this reference while you were editing."); + } + } + + /// + public async Task LoadReferencePickerRootAsync(string equipmentId, CancellationToken ct = default) + { + await using var db = await dbFactory.CreateDbContextAsync(ct); + + var clusterId = await ResolveEquipmentClusterAsync(db, equipmentId, ct); + if (clusterId is null) return null; + + var cluster = await db.ServerClusters.AsNoTracking() + .FirstOrDefaultAsync(c => c.ClusterId == clusterId, ct); + if (cluster is null) return null; + + // Root child count = cluster-root folders + cluster-root drivers (the RawTree lazily loads the rest + // via IRawTreeService.LoadChildrenAsync, keyed on this node's Cluster kind + EntityId). + var rootFolders = await db.RawFolders.AsNoTracking() + .CountAsync(f => f.ClusterId == clusterId && f.ParentRawFolderId == null, ct); + var rootDrivers = await db.DriverInstances.AsNoTracking() + .CountAsync(d => d.ClusterId == clusterId && d.RawFolderId == null, ct); + + return new RawNode + { + Kind = RawNodeKind.Cluster, + Key = $"clu:{clusterId}", + DisplayName = cluster.Name, + ClusterId = clusterId, + EntityId = clusterId, + HasLazyChildren = true, + ChildCount = rootFolders + rootDrivers, + }; + } + + /// + public async Task> LoadDescendantTagIdsAsync(RawNode node, CancellationToken ct = default) + { + ArgumentNullException.ThrowIfNull(node); + if (node.EntityId is null) return Array.Empty(); + + await using var db = await dbFactory.CreateDbContextAsync(ct); + + switch (node.Kind) + { + case RawNodeKind.Device: + // Every tag under the device (across all its tag groups). + return await db.Tags.AsNoTracking() + .Where(t => t.DeviceId == node.EntityId) + .Select(t => t.TagId) + .ToListAsync(ct); + + case RawNodeKind.TagGroup: + { + // The group + all descendant groups, then every tag in that group set. + var group = await db.TagGroups.AsNoTracking() + .FirstOrDefaultAsync(g => g.TagGroupId == node.EntityId, ct); + if (group is null) return Array.Empty(); + + var deviceGroups = await db.TagGroups.AsNoTracking() + .Where(g => g.DeviceId == group.DeviceId) + .Select(g => new { g.TagGroupId, g.ParentTagGroupId }) + .ToListAsync(ct); + + var childrenByParent = deviceGroups + .Where(g => g.ParentTagGroupId is not null) + .GroupBy(g => g.ParentTagGroupId!, StringComparer.Ordinal) + .ToDictionary(g => g.Key, g => g.Select(x => x.TagGroupId).ToList(), StringComparer.Ordinal); + + var groupIds = DescendantGroupsInclusive(node.EntityId, childrenByParent); + return await db.Tags.AsNoTracking() + .Where(t => t.TagGroupId != null && groupIds.Contains(t.TagGroupId)) + .Select(t => t.TagId) + .ToListAsync(ct); + } + + default: + // The picker only offers "select all" on Device / TagGroup containers. + return Array.Empty(); + } + } + + /// Returns plus all transitive descendant group ids (iterative walk). + private static HashSet DescendantGroupsInclusive( + string rootId, IReadOnlyDictionary> childrenByParent) + { + var result = new HashSet(StringComparer.Ordinal); + var stack = new Stack(); + stack.Push(rootId); + while (stack.Count > 0) + { + var id = stack.Pop(); + if (!result.Add(id)) continue; + if (childrenByParent.TryGetValue(id, out var kids)) + { + foreach (var kid in kids) stack.Push(kid); + } + } + return result; + } + + /// + /// Builds a over a cluster's raw topology (folders / drivers / devices / + /// tag-groups), so a referenced tag's RawPath can be computed the same way the deploy validator does. + /// Returns when the cluster is unknown/null (callers then fall back to bare name). + /// + private static async Task BuildClusterRawPathResolverAsync( + OtOpcUaConfigDbContext db, string? clusterId, CancellationToken ct) + { + if (string.IsNullOrEmpty(clusterId)) return null; + + var folders = (await db.RawFolders.AsNoTracking() + .Where(f => f.ClusterId == clusterId) + .Select(f => new { f.RawFolderId, f.ParentRawFolderId, f.Name }) + .ToListAsync(ct)) + .ToDictionary(f => f.RawFolderId, f => ((string?)f.ParentRawFolderId, f.Name), StringComparer.Ordinal); + + var drivers = (await db.DriverInstances.AsNoTracking() + .Where(d => d.ClusterId == clusterId) + .Select(d => new { d.DriverInstanceId, d.RawFolderId, d.Name }) + .ToListAsync(ct)) + .ToDictionary(d => d.DriverInstanceId, d => ((string?)d.RawFolderId, d.Name), StringComparer.Ordinal); + + var driverIds = drivers.Keys.ToList(); + + var devices = (await db.Devices.AsNoTracking() + .Where(dev => driverIds.Contains(dev.DriverInstanceId)) + .Select(dev => new { dev.DeviceId, dev.DriverInstanceId, dev.Name }) + .ToListAsync(ct)) + .ToDictionary(dev => dev.DeviceId, dev => (dev.DriverInstanceId, dev.Name), StringComparer.Ordinal); + + var deviceIds = devices.Keys.ToList(); + + var groups = (await db.TagGroups.AsNoTracking() + .Where(g => deviceIds.Contains(g.DeviceId)) + .Select(g => new { g.TagGroupId, g.ParentTagGroupId, g.Name }) + .ToListAsync(ct)) + .ToDictionary(g => g.TagGroupId, g => ((string?)g.ParentTagGroupId, g.Name), StringComparer.Ordinal); + + return new RawPathResolver(folders, drivers, devices, groups); + } + + /// + /// A no-op used only when no guard was injected (unit tests that do + /// not exercise the guard; a mis-wired DI). It always reports "free" — the deploy gate remains the + /// backstop. Production always injects the real WP2 guard. + /// + private sealed class NoOpEffectiveNameGuard : IEffectiveNameGuard + { + public static readonly NoOpEffectiveNameGuard Instance = new(); + + public Task CheckAsync( + string equipmentId, string proposedEffectiveName, EffectiveNameSourceKind kind, + string? excludeSourceId, CancellationToken ct = default) => Task.FromResult(null); + } + /// public async Task LoadAreaAsync(string unsAreaId, CancellationToken ct = default) { @@ -446,11 +818,8 @@ public sealed class UnsTreeService(IDbContextFactory dbF return new UnsMutationResult(false, $"MachineCode '{input.MachineCode}' already exists in this fleet."); } - var guard = await CheckDriverClusterGuardAsync(db, input, ct); - if (guard is not null) - { - return guard.Value; - } + // v3: equipment no longer binds a driver — the reference-only Tags tab points at raw tags — so + // the old decision-#122 driver-cluster guard is gone. var uuid = Guid.NewGuid(); var equipmentId = $"EQ-{uuid.ToString("N")[..12]}"; @@ -514,14 +883,7 @@ public sealed class UnsTreeService(IDbContextFactory dbF continue; } - // Reuse the driver/line cluster guard: it reports an unknown DriverInstanceId and a - // driver/line cluster mismatch, and is a no-op for driver-less rows. - var guard = await CheckDriverClusterGuardAsync(db, row, ct); - if (guard is not null) - { - errors.Add($"Row '{row.MachineCode}': {guard.Value.Error}"); - continue; - } + // v3: equipment no longer binds a driver, so there is no per-row driver-cluster guard. var uuid = Guid.NewGuid(); var equipmentId = $"EQ-{uuid.ToString("N")[..12]}"; @@ -578,11 +940,7 @@ public sealed class UnsTreeService(IDbContextFactory dbF return new UnsMutationResult(false, $"MachineCode '{input.MachineCode}' already exists in this fleet."); } - var guard = await CheckDriverClusterGuardAsync(db, input, ct); - if (guard is not null) - { - return guard.Value; - } + // v3: equipment no longer binds a driver — no decision-#122 driver-cluster guard. // Equipment↔driver binding retired in v3 — no DriverInstanceId column remains. entity.UnsLineId = input.UnsLineId; @@ -920,6 +1278,11 @@ public sealed class UnsTreeService(IDbContextFactory dbF return new UnsMutationResult(false, $"A virtual tag named '{input.Name}' already exists on this equipment."); } + // v3 Batch 3: the effective name must also be unique against this equipment's references + scripted + // alarms (they share the equipment's UNS NodeId space) — the authoring mirror of the deploy gate. + var nameGuard = await _guard.CheckAsync(equipmentId, input.Name, EffectiveNameSourceKind.VirtualTag, null, ct); + if (nameGuard is not null) return new UnsMutationResult(false, nameGuard); + var equipGuard = await ValidateEquipTokenAsync(db, equipmentId, input.ScriptId, ct); if (equipGuard is not null) return equipGuard.Value; @@ -969,6 +1332,10 @@ public sealed class UnsTreeService(IDbContextFactory dbF return new UnsMutationResult(false, $"A virtual tag named '{input.Name}' already exists on this equipment."); } + // v3 Batch 3: effective-name uniqueness across references + scripted alarms (excluding this VT). + var nameGuard = await _guard.CheckAsync(entity.EquipmentId, input.Name, EffectiveNameSourceKind.VirtualTag, virtualTagId, ct); + if (nameGuard is not null) return new UnsMutationResult(false, nameGuard); + var equipGuard = await ValidateEquipTokenAsync(db, entity.EquipmentId, input.ScriptId, ct); if (equipGuard is not null) return equipGuard.Value; @@ -1193,58 +1560,6 @@ public sealed class UnsTreeService(IDbContextFactory dbF return null; } - /// - /// An equipment may only bind to a driver in the same cluster as its line. - /// Policy: - /// - /// Driver-less (DriverInstanceId empty) → always allowed (returns null). - /// Driver bound but the line/area does not resolve to a cluster → rejected (unresolvable - /// line cannot guarantee cluster alignment, so the bind is unsafe). - /// Driver bound, line resolves, clusters differ → rejected. - /// Driver bound, line resolves, clusters match → allowed (returns null). - /// - /// - private static async Task CheckDriverClusterGuardAsync( - OtOpcUaConfigDbContext db, - EquipmentInput input, - CancellationToken ct) - { - if (string.IsNullOrWhiteSpace(input.DriverInstanceId)) - { - return null; - } - - var line = await db.UnsLines.FirstOrDefaultAsync(l => l.UnsLineId == input.UnsLineId, ct); - var area = line is null ? null : await db.UnsAreas.FirstOrDefaultAsync(a => a.UnsAreaId == line.UnsAreaId, ct); - var lineCluster = area?.ClusterId; - - if (lineCluster is null) - { - return new UnsMutationResult( - false, - $"Cannot bind driver '{input.DriverInstanceId}': UNS line '{input.UnsLineId}' does not resolve to a cluster (decision #122)."); - } - - var driverCluster = await db.DriverInstances - .Where(d => d.DriverInstanceId == input.DriverInstanceId) - .Select(d => d.ClusterId) - .FirstOrDefaultAsync(ct); - - if (driverCluster is null) - { - return new UnsMutationResult(false, $"Driver '{input.DriverInstanceId}' not found."); - } - - if (driverCluster != lineCluster) - { - return new UnsMutationResult( - false, - $"Driver '{input.DriverInstanceId}' is in cluster '{driverCluster}' but the line is in cluster '{lineCluster}' (decision #122)."); - } - - return null; - } - /// public async Task> LoadAlarmsForEquipmentAsync(string equipmentId, CancellationToken ct = default) { @@ -1277,6 +1592,10 @@ public sealed class UnsTreeService(IDbContextFactory dbF if (await db.ScriptedAlarms.AnyAsync(a => a.EquipmentId == equipmentId && a.Name == input.Name, ct)) return new UnsMutationResult(false, $"A scripted alarm named '{input.Name}' already exists on this equipment."); + // v3 Batch 3: effective-name uniqueness across references + VirtualTags on this equipment. + var nameGuard = await _guard.CheckAsync(equipmentId, input.Name, EffectiveNameSourceKind.ScriptedAlarm, null, ct); + if (nameGuard is not null) return new UnsMutationResult(false, nameGuard); + db.ScriptedAlarms.Add(new ScriptedAlarm { ScriptedAlarmId = input.ScriptedAlarmId, @@ -1307,6 +1626,10 @@ public sealed class UnsTreeService(IDbContextFactory dbF if (await db.ScriptedAlarms.AnyAsync(a => a.EquipmentId == entity.EquipmentId && a.Name == input.Name && a.ScriptedAlarmId != scriptedAlarmId, ct)) return new UnsMutationResult(false, $"A scripted alarm named '{input.Name}' already exists on this equipment."); + // v3 Batch 3: effective-name uniqueness across references + VirtualTags (excluding this alarm). + var nameGuard = await _guard.CheckAsync(entity.EquipmentId, input.Name, EffectiveNameSourceKind.ScriptedAlarm, scriptedAlarmId, ct); + if (nameGuard is not null) return new UnsMutationResult(false, nameGuard); + db.Entry(entity).Property(e => e.RowVersion).OriginalValue = rowVersion; entity.Name = input.Name; entity.AlarmType = input.AlarmType; diff --git a/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceEquipmentTests.cs b/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceEquipmentTests.cs index 35059ec0..f15d6bf5 100644 --- a/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceEquipmentTests.cs +++ b/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceEquipmentTests.cs @@ -1,4 +1,3 @@ -using Microsoft.EntityFrameworkCore; using Shouldly; using Xunit; using ZB.MOM.WW.OtOpcUa.AdminUI.Uns; @@ -7,10 +6,10 @@ using ZB.MOM.WW.OtOpcUa.Configuration.Entities; namespace ZB.MOM.WW.OtOpcUa.AdminUI.Tests.Uns; /// -/// Verifies the Equipment CRUD mutations on , including the -/// system-generated EQ- id, fleet-wide MachineCode uniqueness, and the decision-#122 -/// driver-cluster guard that blocks binding equipment to a driver in a different cluster than -/// the equipment's line. +/// Verifies the Equipment CRUD mutations on : the system-generated +/// EQ- id and fleet-wide MachineCode uniqueness. (v3: equipment no longer binds a driver — the +/// reference-only Tags tab points at raw tags — so the old decision-#122 driver-cluster guard is gone, +/// and its tests with it.) /// /// /// The EF InMemory provider does not enforce RowVersion concurrency, so the @@ -25,32 +24,17 @@ public sealed class UnsTreeServiceEquipmentTests return (new UnsTreeService(UnsTreeTestDb.Factory(dbName)), dbName); } - /// - /// Seeds a line under an area in , plus an optional driver in - /// . The line id is always LINE-1; the driver (when - /// requested) is always DRV-1. - /// - private static void SeedLineAndDriver(string dbName, string lineCluster, string? driverCluster) + /// Seeds an area → line (id LINE-1) under . + private static void SeedLine(string dbName, string cluster) { using var db = UnsTreeTestDb.CreateNamed(dbName); - db.UnsAreas.Add(new UnsArea { UnsAreaId = "AREA-1", ClusterId = lineCluster, Name = "a" }); + db.UnsAreas.Add(new UnsArea { UnsAreaId = "AREA-1", ClusterId = cluster, Name = "a" }); db.UnsLines.Add(new UnsLine { UnsLineId = "LINE-1", UnsAreaId = "AREA-1", Name = "l" }); - if (driverCluster is not null) - { - db.DriverInstances.Add(new DriverInstance - { - DriverInstanceId = "DRV-1", - ClusterId = driverCluster, - Name = "drv", - DriverType = "Modbus", - DriverConfig = "{}", - }); - } db.SaveChanges(); } - private static EquipmentInput Input(string name, string machineCode, string unsLineId, string? driverInstanceId) => - new(name, machineCode, unsLineId, driverInstanceId, + private static EquipmentInput Input(string name, string machineCode, string unsLineId) => + new(name, machineCode, unsLineId, ZTag: null, SAPID: null, Manufacturer: null, Model: null, SerialNumber: null, HardwareRevision: null, SoftwareRevision: null, YearOfConstruction: null, AssetLocation: null, ManufacturerUri: null, DeviceManualUri: null, Enabled: true); @@ -62,9 +46,9 @@ public sealed class UnsTreeServiceEquipmentTests public async Task CreateEquipment_generates_EQ_id_and_persists() { var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: null); + SeedLine(dbName, "MAIN"); - var result = await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "LINE-1", null)); + var result = await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "LINE-1")); result.Ok.ShouldBeTrue(); result.Error.ShouldBeNull(); @@ -83,10 +67,10 @@ public sealed class UnsTreeServiceEquipmentTests public async Task CreateEquipment_duplicate_machinecode_blocked() { var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: null); - await service.CreateEquipmentAsync(Input("machine-1", "machine_dup", "LINE-1", null)); + SeedLine(dbName, "MAIN"); + await service.CreateEquipmentAsync(Input("machine-1", "machine_dup", "LINE-1")); - var result = await service.CreateEquipmentAsync(Input("machine-2", "machine_dup", "LINE-1", null)); + var result = await service.CreateEquipmentAsync(Input("machine-2", "machine_dup", "LINE-1")); result.Ok.ShouldBeFalse(); result.Error.ShouldBe("MachineCode 'machine_dup' already exists in this fleet."); @@ -98,120 +82,28 @@ public sealed class UnsTreeServiceEquipmentTests { var (service, _) = Fresh(); - var result = await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "", null)); + var result = await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "")); result.Ok.ShouldBeFalse(); result.Error.ShouldBe("Pick a UNS line."); } - /// The #122 guard blocks binding equipment to a driver in a different cluster than the line. + /// CreateEquipmentAsync returns the generated EQ- id in CreatedId so callers can navigate to the new page. [Fact] - public async Task CreateEquipment_driver_in_other_cluster_blocked() + public async Task CreateEquipment_returns_generated_id_in_CreatedId() { - var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: "SITE-A"); + var dbName = $"uns-eq-createdid-{Guid.NewGuid():N}"; + UnsTreeTestDb.SeedNamed(dbName); + var service = new UnsTreeService(UnsTreeTestDb.Factory(dbName)); - var result = await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "LINE-1", "DRV-1")); + var input = new EquipmentInput("machine-2", "machine_002", "LINE-1", + null, null, null, null, null, null, null, null, null, null, null, true); - result.Ok.ShouldBeFalse(); - result.Error.ShouldNotBeNull(); - result.Error.ShouldContain("decision #122"); - result.Error.ShouldContain("DRV-1"); - result.Error.ShouldContain("SITE-A"); - result.Error.ShouldContain("MAIN"); - - using var db = UnsTreeTestDb.CreateNamed(dbName); - db.Equipment.Any(e => e.MachineCode == "machine_001").ShouldBeFalse(); - } - - /// - /// Passing a driver in the same cluster as the line passes the #122 guard and the equipment - /// persists. v3: the equipment↔driver binding column was retired, so the driver is validated by - /// the guard but not stored — the assertion drops to equipment existence. - /// - [Fact] - public async Task CreateEquipment_driver_in_same_cluster_allowed() - { - var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: "MAIN"); - - var result = await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "LINE-1", "DRV-1")); + var result = await service.CreateEquipmentAsync(input); result.Ok.ShouldBeTrue(); - result.Error.ShouldBeNull(); - - using var db = UnsTreeTestDb.CreateNamed(dbName); - db.Equipment.Single(e => e.MachineCode == "machine_001").UnsLineId.ShouldBe("LINE-1"); - } - - /// Driver-less equipment is allowed regardless of cluster (no #122 guard applies). - [Fact] - public async Task CreateEquipment_driverless_allowed() - { - var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: null); - - var result = await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "LINE-1", null)); - - result.Ok.ShouldBeTrue(); - result.Error.ShouldBeNull(); - - using var db = UnsTreeTestDb.CreateNamed(dbName); - db.Equipment.Single(e => e.MachineCode == "machine_001").UnsLineId.ShouldBe("LINE-1"); - } - - /// - /// The #122 guard blocks binding equipment to a driver when the UNS line does not resolve to - /// a cluster (e.g. the line does not exist in the DB). - /// - [Fact] - public async Task CreateEquipment_driver_bound_unresolvable_line_blocked() - { - var (service, dbName) = Fresh(); - // Seed a driver in MAIN cluster, but do NOT create the UnsLine that the input references. - using (var db = UnsTreeTestDb.CreateNamed(dbName)) - { - db.DriverInstances.Add(new DriverInstance - { - DriverInstanceId = "DRV-1", - ClusterId = "MAIN", - Name = "drv", - DriverType = "Modbus", - DriverConfig = "{}", - }); - db.SaveChanges(); - } - - var result = await service.CreateEquipmentAsync( - Input("machine-1", "machine_001", "LINE-BOGUS", "DRV-1")); - - result.Ok.ShouldBeFalse(); - result.Error.ShouldNotBeNull(); - result.Error.ShouldContain("decision #122"); - result.Error.ShouldContain("LINE-BOGUS"); - - using var verify = UnsTreeTestDb.CreateNamed(dbName); - verify.Equipment.Any(e => e.MachineCode == "machine_001").ShouldBeFalse(); - } - - /// Binding equipment to a DriverInstanceId that does not exist is blocked with a "not found" error. - [Fact] - public async Task CreateEquipment_driver_not_found_blocked() - { - var (service, dbName) = Fresh(); - // Seed area + line in MAIN cluster, but NO DriverInstance. - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: null); - - var result = await service.CreateEquipmentAsync( - Input("machine-1", "machine_001", "LINE-1", "DRV-GHOST")); - - result.Ok.ShouldBeFalse(); - result.Error.ShouldNotBeNull(); - result.Error.ShouldContain("not found"); - result.Error.ShouldContain("DRV-GHOST"); - - using var db = UnsTreeTestDb.CreateNamed(dbName); - db.Equipment.Any(e => e.MachineCode == "machine_001").ShouldBeFalse(); + result.CreatedId.ShouldNotBeNull(); + result.CreatedId!.ShouldStartWith("EQ-"); } // ----- UpdateEquipment ----- @@ -221,8 +113,8 @@ public sealed class UnsTreeServiceEquipmentTests public async Task UpdateEquipment_changes_fields() { var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: null); - await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "LINE-1", null)); + SeedLine(dbName, "MAIN"); + await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "LINE-1")); string equipmentId; byte[] rv; @@ -233,7 +125,7 @@ public sealed class UnsTreeServiceEquipmentTests rv = eq.RowVersion; } - var updated = new EquipmentInput("machine-renamed", "machine_renamed", "LINE-1", null, + var updated = new EquipmentInput("machine-renamed", "machine_renamed", "LINE-1", ZTag: null, SAPID: null, Manufacturer: "Acme", Model: null, SerialNumber: null, HardwareRevision: null, SoftwareRevision: null, YearOfConstruction: (short)2021, AssetLocation: null, ManufacturerUri: null, DeviceManualUri: null, Enabled: false); @@ -258,49 +150,20 @@ public sealed class UnsTreeServiceEquipmentTests { var (service, _) = Fresh(); - var result = await service.UpdateEquipmentAsync("EQ-nope", Input("n", "mc", "LINE-1", null), []); + var result = await service.UpdateEquipmentAsync("EQ-nope", Input("n", "mc", "LINE-1"), []); result.Ok.ShouldBeFalse(); result.Error.ShouldBe("Row no longer exists."); } - /// The #122 guard blocks an update that binds equipment to a driver in another cluster. - [Fact] - public async Task UpdateEquipment_driver_in_other_cluster_blocked() - { - var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: "SITE-A"); - await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "LINE-1", null)); - - string equipmentId; - byte[] rv; - using (var db = UnsTreeTestDb.CreateNamed(dbName)) - { - var eq = db.Equipment.Single(e => e.MachineCode == "machine_001"); - equipmentId = eq.EquipmentId; - rv = eq.RowVersion; - } - - var result = await service.UpdateEquipmentAsync( - equipmentId, Input("machine-1", "machine_001", "LINE-1", "DRV-1"), rv); - - result.Ok.ShouldBeFalse(); - result.Error.ShouldNotBeNull(); - result.Error.ShouldContain("decision #122"); - - // The equipment row is unchanged (v3 has no persisted driver-binding column to check). - using var verify = UnsTreeTestDb.CreateNamed(dbName); - verify.Equipment.Single(e => e.EquipmentId == equipmentId).MachineCode.ShouldBe("machine_001"); - } - /// Updating equipment with a MachineCode that already belongs to another row is blocked. [Fact] public async Task UpdateEquipment_duplicate_machinecode_blocked() { var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: null); - await service.CreateEquipmentAsync(Input("machine-a", "mc_a", "LINE-1", null)); - await service.CreateEquipmentAsync(Input("machine-b", "mc_b", "LINE-1", null)); + SeedLine(dbName, "MAIN"); + await service.CreateEquipmentAsync(Input("machine-a", "mc_a", "LINE-1")); + await service.CreateEquipmentAsync(Input("machine-b", "mc_b", "LINE-1")); string equipmentId; byte[] rv; @@ -313,7 +176,7 @@ public sealed class UnsTreeServiceEquipmentTests // Try to rename mc_a → mc_b (which already exists). var result = await service.UpdateEquipmentAsync( - equipmentId, Input("machine-a", "mc_b", "LINE-1", null), rv); + equipmentId, Input("machine-a", "mc_b", "LINE-1"), rv); result.Ok.ShouldBeFalse(); result.Error.ShouldNotBeNull(); @@ -324,52 +187,6 @@ public sealed class UnsTreeServiceEquipmentTests verify.Equipment.Single(e => e.EquipmentId == equipmentId).MachineCode.ShouldBe("mc_a"); } - /// Updating equipment to bind a driver that is in the SAME cluster as the line is allowed. - [Fact] - public async Task UpdateEquipment_driver_in_same_cluster_allowed() - { - var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: "MAIN"); - await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "LINE-1", null)); - - string equipmentId; - byte[] rv; - using (var db = UnsTreeTestDb.CreateNamed(dbName)) - { - var eq = db.Equipment.Single(e => e.MachineCode == "machine_001"); - equipmentId = eq.EquipmentId; - rv = eq.RowVersion; - } - - var result = await service.UpdateEquipmentAsync( - equipmentId, Input("machine-1", "machine_001", "LINE-1", "DRV-1"), rv); - - result.Ok.ShouldBeTrue(); - result.Error.ShouldBeNull(); - - // v3: the driver passes the #122 guard but is not persisted (binding column retired). - using var verify = UnsTreeTestDb.CreateNamed(dbName); - verify.Equipment.Single(e => e.EquipmentId == equipmentId).UnsLineId.ShouldBe("LINE-1"); - } - - /// CreateEquipmentAsync returns the generated EQ- id in CreatedId so callers can navigate to the new page. - [Fact] - public async Task CreateEquipment_returns_generated_id_in_CreatedId() - { - var dbName = $"uns-eq-createdid-{Guid.NewGuid():N}"; - UnsTreeTestDb.SeedNamed(dbName); - var service = new UnsTreeService(UnsTreeTestDb.Factory(dbName)); - - var input = new EquipmentInput("machine-2", "machine_002", "LINE-1", - null, null, null, null, null, null, null, null, null, null, null, null, true); - - var result = await service.CreateEquipmentAsync(input); - - result.Ok.ShouldBeTrue(); - result.CreatedId.ShouldNotBeNull(); - result.CreatedId!.ShouldStartWith("EQ-"); - } - // ----- DeleteEquipment ----- /// Deleting equipment removes the row. @@ -377,8 +194,8 @@ public sealed class UnsTreeServiceEquipmentTests public async Task DeleteEquipment_removes_row() { var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: null); - await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "LINE-1", null)); + SeedLine(dbName, "MAIN"); + await service.CreateEquipmentAsync(Input("machine-1", "machine_001", "LINE-1")); string equipmentId; byte[] rv; diff --git a/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceImportTests.cs b/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceImportTests.cs index 6544cbb6..ba4686fa 100644 --- a/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceImportTests.cs +++ b/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceImportTests.cs @@ -6,10 +6,10 @@ using ZB.MOM.WW.OtOpcUa.Configuration.Entities; namespace ZB.MOM.WW.OtOpcUa.AdminUI.Tests.Uns; /// -/// Verifies the bulk path: valid rows insert, -/// rows whose MachineCode already exists (in the DB or earlier in the same batch) are skipped, -/// rows referencing an unknown UNS line or unknown driver are reported as errors, and the -/// decision-#122 driver-cluster guard rejects a driver in a different cluster than the line. +/// Verifies the bulk path: valid rows insert, rows +/// whose MachineCode already exists (in the DB or earlier in the same batch) are skipped, and rows +/// referencing an unknown UNS line are reported as errors. (v3: equipment no longer binds a driver, so +/// the old DriverInstanceId column and its decision-#122 cluster guard — and their tests — are gone.) /// [Trait("Category", "Unit")] public sealed class UnsTreeServiceImportTests @@ -20,32 +20,17 @@ public sealed class UnsTreeServiceImportTests return (new UnsTreeService(UnsTreeTestDb.Factory(dbName)), dbName); } - /// - /// Seeds a line under an area in , plus an optional driver in - /// . The line id is always LINE-1; the driver (when - /// requested) is always DRV-1. - /// - private static void SeedLineAndDriver(string dbName, string lineCluster, string? driverCluster) + /// Seeds an area → line (id LINE-1) under . + private static void SeedLine(string dbName, string cluster) { using var db = UnsTreeTestDb.CreateNamed(dbName); - db.UnsAreas.Add(new UnsArea { UnsAreaId = "AREA-1", ClusterId = lineCluster, Name = "a" }); + db.UnsAreas.Add(new UnsArea { UnsAreaId = "AREA-1", ClusterId = cluster, Name = "a" }); db.UnsLines.Add(new UnsLine { UnsLineId = "LINE-1", UnsAreaId = "AREA-1", Name = "l" }); - if (driverCluster is not null) - { - db.DriverInstances.Add(new DriverInstance - { - DriverInstanceId = "DRV-1", - ClusterId = driverCluster, - Name = "drv", - DriverType = "Modbus", - DriverConfig = "{}", - }); - } db.SaveChanges(); } - private static EquipmentInput Input(string name, string machineCode, string unsLineId, string? driverInstanceId) => - new(name, machineCode, unsLineId, driverInstanceId, + private static EquipmentInput Input(string name, string machineCode, string unsLineId) => + new(name, machineCode, unsLineId, ZTag: null, SAPID: null, Manufacturer: null, Model: null, SerialNumber: null, HardwareRevision: null, SoftwareRevision: null, YearOfConstruction: null, AssetLocation: null, ManufacturerUri: null, DeviceManualUri: null, Enabled: true); @@ -55,12 +40,12 @@ public sealed class UnsTreeServiceImportTests public async Task Import_inserts_valid_rows() { var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: null); + SeedLine(dbName, "MAIN"); var result = await service.ImportEquipmentAsync( [ - Input("machine-1", "mc_1", "LINE-1", null), - Input("machine-2", "mc_2", "LINE-1", null), + Input("machine-1", "mc_1", "LINE-1"), + Input("machine-2", "mc_2", "LINE-1"), ]); result.Inserted.ShouldBe(2); @@ -85,15 +70,15 @@ public sealed class UnsTreeServiceImportTests public async Task Import_skips_duplicate_machinecode() { var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: null); + SeedLine(dbName, "MAIN"); // Pre-existing equipment with MachineCode "mc_existing". - await service.CreateEquipmentAsync(Input("machine-x", "mc_existing", "LINE-1", null)); + await service.CreateEquipmentAsync(Input("machine-x", "mc_existing", "LINE-1")); var result = await service.ImportEquipmentAsync( [ - Input("machine-1", "mc_existing", "LINE-1", null), // dup of DB row → skip - Input("machine-2", "mc_new", "LINE-1", null), // inserts - Input("machine-3", "mc_new", "LINE-1", null), // dup of in-batch row → skip + Input("machine-1", "mc_existing", "LINE-1"), // dup of DB row → skip + Input("machine-2", "mc_new", "LINE-1"), // inserts + Input("machine-3", "mc_new", "LINE-1"), // dup of in-batch row → skip ]); result.Inserted.ShouldBe(1); @@ -110,12 +95,12 @@ public sealed class UnsTreeServiceImportTests public async Task Import_reports_unknown_line() { var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: null); + SeedLine(dbName, "MAIN"); var result = await service.ImportEquipmentAsync( [ - Input("machine-1", "mc_1", "LINE-BOGUS", null), - Input("machine-2", "mc_2", "LINE-1", null), + Input("machine-1", "mc_1", "LINE-BOGUS"), + Input("machine-2", "mc_2", "LINE-1"), ]); result.Inserted.ShouldBe(1); @@ -128,73 +113,4 @@ public sealed class UnsTreeServiceImportTests db.Equipment.Any(e => e.MachineCode == "mc_1").ShouldBeFalse(); db.Equipment.Any(e => e.MachineCode == "mc_2").ShouldBeTrue(); } - - /// A driver-bound row whose DriverInstanceId does not resolve is reported as an error. - [Fact] - public async Task Import_reports_unknown_driver() - { - var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: null); // no driver seeded - - var result = await service.ImportEquipmentAsync( - [ - Input("machine-1", "mc_1", "LINE-1", "DRV-GHOST"), - ]); - - result.Inserted.ShouldBe(0); - result.Skipped.ShouldBe(0); - result.Errors.Count.ShouldBe(1); - result.Errors[0].ShouldContain("mc_1"); - result.Errors[0].ShouldContain("DRV-GHOST"); - result.Errors[0].ShouldContain("not found"); - - using var db = UnsTreeTestDb.CreateNamed(dbName); - db.Equipment.Any(e => e.MachineCode == "mc_1").ShouldBeFalse(); - } - - /// - /// The decision-#122 guard rejects a row that binds a driver living in a different cluster than - /// the row's UNS line. - /// - [Fact] - public async Task Import_enforces_122_cluster() - { - var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: "SITE-A"); - - var result = await service.ImportEquipmentAsync( - [ - Input("machine-1", "mc_1", "LINE-1", "DRV-1"), - ]); - - result.Inserted.ShouldBe(0); - result.Skipped.ShouldBe(0); - result.Errors.Count.ShouldBe(1); - result.Errors[0].ShouldContain("mc_1"); - result.Errors[0].ShouldContain("decision #122"); - - using var db = UnsTreeTestDb.CreateNamed(dbName); - db.Equipment.Any(e => e.MachineCode == "mc_1").ShouldBeFalse(); - } - - /// A driver in the same cluster as the line imports cleanly. - [Fact] - public async Task Import_allows_driver_in_same_cluster() - { - var (service, dbName) = Fresh(); - SeedLineAndDriver(dbName, lineCluster: "MAIN", driverCluster: "MAIN"); - - var result = await service.ImportEquipmentAsync( - [ - Input("machine-1", "mc_1", "LINE-1", "DRV-1"), - ]); - - result.Inserted.ShouldBe(1); - result.Skipped.ShouldBe(0); - result.Errors.ShouldBeEmpty(); - - // v3: the driver passes the #122 guard but is not persisted (binding column retired). - using var db = UnsTreeTestDb.CreateNamed(dbName); - db.Equipment.Single(e => e.MachineCode == "mc_1").UnsLineId.ShouldBe("LINE-1"); - } } diff --git a/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceReferenceTests.cs b/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceReferenceTests.cs new file mode 100644 index 00000000..8eda6188 --- /dev/null +++ b/tests/Server/ZB.MOM.WW.OtOpcUa.AdminUI.Tests/Uns/UnsTreeServiceReferenceTests.cs @@ -0,0 +1,314 @@ +using Microsoft.EntityFrameworkCore; +using Shouldly; +using Xunit; +using ZB.MOM.WW.OtOpcUa.AdminUI.Uns; +using ZB.MOM.WW.OtOpcUa.Configuration; +using ZB.MOM.WW.OtOpcUa.Configuration.Entities; +using ZB.MOM.WW.OtOpcUa.Configuration.Enums; + +namespace ZB.MOM.WW.OtOpcUa.AdminUI.Tests.Uns; + +/// +/// Verifies the v3 Batch-3 UNS reference-only equipment mutations on : +/// adding references (with computed RawPath + inherited datatype/access), removing them, setting the +/// display-name override, the cross-cluster rejection, the same-tag / same-name duplicate rejections, +/// and the -consumed collision rejection (via a configurable fake). +/// +/// +/// The EF InMemory provider enforces neither RowVersion concurrency nor the filtered-unique +/// indexes, so the service's own pre-checks are what protect the data in these tests. +/// +[Trait("Category", "Unit")] +public sealed class UnsTreeServiceReferenceTests +{ + private const string EquipmentId = "EQ-1"; + + /// A configurable : returns from every check. + private sealed class FakeGuard : IEffectiveNameGuard + { + public string? Result { get; set; } + + public string? LastProposedName { get; private set; } + + public Task CheckAsync( + string equipmentId, string proposedEffectiveName, EffectiveNameSourceKind kind, + string? excludeSourceId, CancellationToken ct = default) + { + LastProposedName = proposedEffectiveName; + return Task.FromResult(Result); + } + } + + private static OtOpcUaConfigDbContext Db(string name) => + new(new DbContextOptionsBuilder().UseInMemoryDatabase(name).Options); + + private static IDbContextFactory Factory(string name) => UnsTreeTestDb.Factory(name); + + /// + /// Seeds two clusters (MAIN, SITE-A), each with driver→device→tags, plus an equipment (EQ-1) + /// under MAIN. MAIN tags: MAIN/dev1/speed (Float, Read) and MAIN/dev1/running + /// (Boolean, ReadWrite), with speed also nested under a group grp variant. SITE-A tag: + /// OTHER/dev2/temp (for the cross-cluster rejection). + /// + private static void Seed(string name) + { + using var db = Db(name); + + db.ServerClusters.Add(new ServerCluster { ClusterId = "MAIN", Name = "Main", Enterprise = "zb", Site = "s1", RedundancyMode = RedundancyMode.None, CreatedBy = "t" }); + db.ServerClusters.Add(new ServerCluster { ClusterId = "SITE-A", Name = "Site A", Enterprise = "zb", Site = "s2", RedundancyMode = RedundancyMode.None, CreatedBy = "t" }); + + db.UnsAreas.Add(new UnsArea { UnsAreaId = "AREA-1", ClusterId = "MAIN", Name = "assembly" }); + db.UnsLines.Add(new UnsLine { UnsLineId = "LINE-1", UnsAreaId = "AREA-1", Name = "line-a" }); + db.Equipment.Add(new Equipment { EquipmentId = EquipmentId, EquipmentUuid = Guid.NewGuid(), UnsLineId = "LINE-1", Name = "machine-1", MachineCode = "mc_1" }); + + // MAIN raw topology. + db.DriverInstances.Add(new DriverInstance { DriverInstanceId = "DRV-1", ClusterId = "MAIN", Name = "MAIN", DriverType = "Modbus", DriverConfig = "{}" }); + db.Devices.Add(new Device { DeviceId = "DEV-1", DriverInstanceId = "DRV-1", Name = "dev1", DeviceConfig = "{}" }); + db.TagGroups.Add(new TagGroup { TagGroupId = "TG-1", DeviceId = "DEV-1", Name = "grp" }); + db.Tags.Add(new Tag { TagId = "TAG-speed", DeviceId = "DEV-1", Name = "speed", DataType = "Float", AccessLevel = TagAccessLevel.Read, TagConfig = "{}" }); + db.Tags.Add(new Tag { TagId = "TAG-running", DeviceId = "DEV-1", Name = "running", DataType = "Boolean", AccessLevel = TagAccessLevel.ReadWrite, TagConfig = "{}" }); + db.Tags.Add(new Tag { TagId = "TAG-grouped", DeviceId = "DEV-1", TagGroupId = "TG-1", Name = "nested", DataType = "Int32", AccessLevel = TagAccessLevel.Read, TagConfig = "{}" }); + + // SITE-A raw topology (for the cross-cluster rejection). + db.DriverInstances.Add(new DriverInstance { DriverInstanceId = "DRV-2", ClusterId = "SITE-A", Name = "OTHER", DriverType = "Modbus", DriverConfig = "{}" }); + db.Devices.Add(new Device { DeviceId = "DEV-2", DriverInstanceId = "DRV-2", Name = "dev2", DeviceConfig = "{}" }); + db.Tags.Add(new Tag { TagId = "TAG-other", DeviceId = "DEV-2", Name = "temp", DataType = "Float", AccessLevel = TagAccessLevel.Read, TagConfig = "{}" }); + + db.SaveChanges(); + } + + // ----- AddReferences ----- + + /// Adding two raw tags persists two UnsTagReference rows for the equipment. + [Fact] + public async Task AddReferences_persists_rows() + { + var name = $"ref-add-{Guid.NewGuid():N}"; + Seed(name); + var service = new UnsTreeService(Factory(name)); + + var result = await service.AddReferencesAsync(EquipmentId, ["TAG-speed", "TAG-running"]); + + result.Ok.ShouldBeTrue(); + result.Error.ShouldBeNull(); + + using var db = Db(name); + var refs = db.UnsTagReferences.Where(r => r.EquipmentId == EquipmentId).ToList(); + refs.Count.ShouldBe(2); + refs.Select(r => r.TagId).ShouldBe(new[] { "TAG-speed", "TAG-running" }, ignoreOrder: true); + refs.All(r => r.DisplayNameOverride == null).ShouldBeTrue(); + } + + /// Loaded reference rows carry the computed RawPath and inherited (raw) datatype/access. + [Fact] + public async Task LoadReferences_projects_rawpath_and_inherited_type() + { + var name = $"ref-load-{Guid.NewGuid():N}"; + Seed(name); + var service = new UnsTreeService(Factory(name)); + await service.AddReferencesAsync(EquipmentId, ["TAG-speed", "TAG-grouped"]); + + var rows = await service.LoadReferencesForEquipmentAsync(EquipmentId); + + rows.Count.ShouldBe(2); + + var speed = rows.Single(r => r.RawPath == "MAIN/dev1/speed"); + speed.EffectiveName.ShouldBe("speed"); + speed.DataType.ShouldBe("Float"); + speed.AccessLevel.ShouldBe(TagAccessLevel.Read); + + var nested = rows.Single(r => r.EffectiveName == "nested"); + nested.RawPath.ShouldBe("MAIN/dev1/grp/nested"); + nested.DataType.ShouldBe("Int32"); + } + + /// A raw tag whose cluster differs from the equipment's is rejected (cross-cluster). + [Fact] + public async Task AddReferences_cross_cluster_rejected() + { + var name = $"ref-xcluster-{Guid.NewGuid():N}"; + Seed(name); + var service = new UnsTreeService(Factory(name)); + + var result = await service.AddReferencesAsync(EquipmentId, ["TAG-other"]); + + result.Ok.ShouldBeFalse(); + result.Error.ShouldNotBeNull(); + result.Error.ShouldContain("cross-cluster"); + + using var db = Db(name); + db.UnsTagReferences.Any(r => r.EquipmentId == EquipmentId).ShouldBeFalse(); + } + + /// Re-referencing an already-referenced raw tag is rejected. + [Fact] + public async Task AddReferences_duplicate_tag_rejected() + { + var name = $"ref-dup-{Guid.NewGuid():N}"; + Seed(name); + var service = new UnsTreeService(Factory(name)); + await service.AddReferencesAsync(EquipmentId, ["TAG-speed"]); + + var result = await service.AddReferencesAsync(EquipmentId, ["TAG-speed"]); + + result.Ok.ShouldBeFalse(); + result.Error.ShouldNotBeNull(); + result.Error.ShouldContain("already referenced"); + + using var db = Db(name); + db.UnsTagReferences.Count(r => r.EquipmentId == EquipmentId).ShouldBe(1); + } + + /// A guard-reported collision (fake) becomes the mutation's readable failure; nothing is added. + [Fact] + public async Task AddReferences_guard_collision_rejected() + { + var name = $"ref-guard-{Guid.NewGuid():N}"; + Seed(name); + var guard = new FakeGuard { Result = "'speed' already exists on equipment 'machine-1'." }; + var service = new UnsTreeService(Factory(name), guard); + + var result = await service.AddReferencesAsync(EquipmentId, ["TAG-speed"]); + + result.Ok.ShouldBeFalse(); + result.Error.ShouldBe("'speed' already exists on equipment 'machine-1'."); + guard.LastProposedName.ShouldBe("speed"); + + using var db = Db(name); + db.UnsTagReferences.Any(r => r.EquipmentId == EquipmentId).ShouldBeFalse(); + } + + // ----- SetReferenceOverride ----- + + /// Setting an override changes the effective name; clearing it falls back to the raw name. + [Fact] + public async Task SetReferenceOverride_sets_and_clears() + { + var name = $"ref-override-{Guid.NewGuid():N}"; + Seed(name); + var service = new UnsTreeService(Factory(name)); + await service.AddReferencesAsync(EquipmentId, ["TAG-speed"]); + + var row = (await service.LoadReferencesForEquipmentAsync(EquipmentId)).Single(); + + var set = await service.SetReferenceOverrideAsync(row.UnsTagReferenceId, "line-speed", row.RowVersion); + set.Ok.ShouldBeTrue(); + + var afterSet = (await service.LoadReferencesForEquipmentAsync(EquipmentId)).Single(); + afterSet.EffectiveName.ShouldBe("line-speed"); + afterSet.DisplayNameOverride.ShouldBe("line-speed"); + afterSet.RawPath.ShouldBe("MAIN/dev1/speed"); // raw path is unchanged by an override + + var clear = await service.SetReferenceOverrideAsync(afterSet.UnsTagReferenceId, " ", afterSet.RowVersion); + clear.Ok.ShouldBeTrue(); + + var afterClear = (await service.LoadReferencesForEquipmentAsync(EquipmentId)).Single(); + afterClear.EffectiveName.ShouldBe("speed"); + afterClear.DisplayNameOverride.ShouldBeNull(); + } + + /// Setting an override that the guard reports as colliding is rejected. + [Fact] + public async Task SetReferenceOverride_guard_collision_rejected() + { + var name = $"ref-override-guard-{Guid.NewGuid():N}"; + Seed(name); + var guard = new FakeGuard(); + var service = new UnsTreeService(Factory(name), guard); + await service.AddReferencesAsync(EquipmentId, ["TAG-speed"]); + var row = (await service.LoadReferencesForEquipmentAsync(EquipmentId)).Single(); + + guard.Result = "collides with a virtual tag."; + var result = await service.SetReferenceOverrideAsync(row.UnsTagReferenceId, "running", row.RowVersion); + + result.Ok.ShouldBeFalse(); + result.Error.ShouldBe("collides with a virtual tag."); + guard.LastProposedName.ShouldBe("running"); + } + + // ----- RemoveReference ----- + + /// Removing a reference deletes the row; a missing row is a no-op success. + [Fact] + public async Task RemoveReference_removes_row() + { + var name = $"ref-remove-{Guid.NewGuid():N}"; + Seed(name); + var service = new UnsTreeService(Factory(name)); + await service.AddReferencesAsync(EquipmentId, ["TAG-speed"]); + var row = (await service.LoadReferencesForEquipmentAsync(EquipmentId)).Single(); + + var result = await service.RemoveReferenceAsync(row.UnsTagReferenceId, row.RowVersion); + result.Ok.ShouldBeTrue(); + + using var db = Db(name); + db.UnsTagReferences.Any(r => r.EquipmentId == EquipmentId).ShouldBeFalse(); + + // Already gone → idempotent success. + var again = await service.RemoveReferenceAsync(row.UnsTagReferenceId, row.RowVersion); + again.Ok.ShouldBeTrue(); + } + + // ----- Picker support ----- + + /// The picker root is the equipment's own cluster node (structurally cluster-scoped). + [Fact] + public async Task LoadReferencePickerRoot_returns_cluster_node() + { + var name = $"ref-picker-{Guid.NewGuid():N}"; + Seed(name); + var service = new UnsTreeService(Factory(name)); + + var root = await service.LoadReferencePickerRootAsync(EquipmentId); + + root.ShouldNotBeNull(); + root!.Kind.ShouldBe(RawNodeKind.Cluster); + root.EntityId.ShouldBe("MAIN"); + root.ClusterId.ShouldBe("MAIN"); + root.HasLazyChildren.ShouldBeTrue(); + } + + /// Select-all under a device returns every tag id in the device subtree. + [Fact] + public async Task LoadDescendantTagIds_device_returns_subtree_tags() + { + var name = $"ref-descend-{Guid.NewGuid():N}"; + Seed(name); + var service = new UnsTreeService(Factory(name)); + + var deviceNode = new RawNode + { + Kind = RawNodeKind.Device, + Key = "dev:DEV-1", + DisplayName = "dev1", + ClusterId = "MAIN", + EntityId = "DEV-1", + }; + + var ids = await service.LoadDescendantTagIdsAsync(deviceNode); + + ids.ShouldBe(new[] { "TAG-speed", "TAG-running", "TAG-grouped" }, ignoreOrder: true); + } + + /// Select-all under a tag-group returns only the tags in that group's subtree. + [Fact] + public async Task LoadDescendantTagIds_group_returns_group_tags() + { + var name = $"ref-descend-grp-{Guid.NewGuid():N}"; + Seed(name); + var service = new UnsTreeService(Factory(name)); + + var groupNode = new RawNode + { + Kind = RawNodeKind.TagGroup, + Key = "grp:TG-1", + DisplayName = "grp", + ClusterId = "MAIN", + EntityId = "TG-1", + }; + + var ids = await service.LoadDescendantTagIdsAsync(groupNode); + + ids.ShouldBe(new[] { "TAG-grouped" }); + } +} From ac12eec92473d7a98bbcc7fd2b04e084723fbaa0 Mon Sep 17 00:00:00 2001 From: Joseph Doherty Date: Thu, 16 Jul 2026 06:24:05 -0400 Subject: [PATCH 05/10] review(wave-a L1): correct concurrency-catch comment (no DB uniqueness on effective name) Claude-Session: https://claude.ai/code/session_01LVneM3eh1UtJxEisFXgmox --- src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs index a5837358..692df0ad 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs @@ -248,7 +248,9 @@ public sealed class UnsTreeService( } catch (DbUpdateException) { - // A concurrent add slipped a same-(equipment,tag) or same-name row past the pre-check. + // The UX_UnsTagReference_Equip_Tag unique index tripped: a concurrent add slipped a + // same-(equipment,tag) row past the pre-check. (Effective-name collisions have no DB + // uniqueness — those are caught by the authoring guard and the deploy gate, not here.) return new UnsMutationResult(false, "Add failed — a reference at one of these tags was created concurrently. Reload and retry."); } } From dc0d7653b94cb08e0fcdee70e966d185f4fbdb8b Mon Sep 17 00:00:00 2001 From: Joseph Doherty Date: Thu, 16 Jul 2026 06:58:17 -0400 Subject: [PATCH 06/10] =?UTF-8?q?feat(v3-batch3):=20B3-WP4=20=E2=80=94=20{?= =?UTF-8?q?{equip}}/=20reference-relative=20resolution?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace the deleted equipment-base-prefix {{equip}} mechanism (impossible now that equipment is reference-only) with per-reference resolution: {{equip}}/ resolves through the owning equipment's UnsTagReference rows (by effective name) to the backing raw tag's RawPath. Every unresolved is a clear deploy error + authoring rejection + Monaco diagnostic — preserving "editor accepts <=> publish accepts". Commons: - EquipmentScriptPaths: delete DeriveEquipmentBase; SubstituteEquipmentToken now takes the equipment's reference map (effectiveName -> RawPath) and substitutes {{equip}}/ inside path literals (unresolved left intact, never throws); add ExtractEquipReferenceNames (path-literal scoped) + ExtractEquipReferenceNamesFromText (message templates). Slash syntax replaces the v2 dot joint. - New EquipmentReferenceMap: shared, input-shape-agnostic builder (entity + JSON sides) over RawPathResolver — the single authority both compose seams + the validator use, so resolved RawPaths agree byte-for-byte. Compose seams (byte-parity kept): - AddressSpaceComposer.Compose + DeploymentArtifact.ParseComposition both build the per-equipment reference map from UnsTagReferences + Tags + raw topology and substitute VirtualTag AND ScriptedAlarm-predicate sources before dependency extraction (runtime dep refs = resolved RawPaths). Deploy gate + authoring + editor: - DraftValidator.ValidateEquipReferenceResolution: EquipReferenceUnresolved error for unresolved {{equip}}/ in VirtualTag/ScriptedAlarm scripts + alarm message-template tokens (naming script, equipment, missing ref). - UnsTreeService.ValidateEquipTokenAsync (Wave-A M1): reference-relative authoring rejection, replacing the stale DeriveEquipmentBase(empty)->reject-all logic. - ScriptAnalysisService: {{equip}}/ completion offers the equipment's reference effective names; DiagnoseAsync flags unresolved refs (OTSCRIPT_EQUIPREF) same as the deploy gate. Requests carry optional EquipmentId (threaded MonacoEditor -> monaco-init.js -> fetch bodies). IScriptTagCatalog.GetEquipmentRelativeLeavesAsync repurposed to GetEquipmentReferenceNamesAsync(equipmentId, filter). Tests: EquipmentScriptPaths substitution/extraction (slash pinned); composer<-> artifact reference-resolution byte-parity; DraftValidator unresolved-ref; ScriptAnalysis completion+diagnostic; M1 authoring gate. Build clean (0/0); all five affected suites green. Claude-Session: https://claude.ai/code/session_01LVneM3eh1UtJxEisFXgmox --- docs/ScriptEditor.md | 92 +++++---- .../Types/EquipmentReferenceMap.cs | 94 +++++++++ .../Types/EquipmentScriptPaths.cs | 150 ++++++++++----- .../Validation/DraftValidator.cs | 59 ++++++ .../Components/Shared/MonacoEditor.razor | 10 +- .../Shared/Uns/VirtualTagModal.razor | 2 +- .../ScriptAnalysis/IScriptTagCatalog.cs | 46 +++-- .../ScriptAnalysis/ScriptAnalysisContracts.cs | 10 +- .../ScriptAnalysis/ScriptAnalysisEndpoints.cs | 2 +- .../ScriptAnalysis/ScriptAnalysisService.cs | 71 ++++++- .../Uns/UnsTreeService.cs | 44 +++-- .../wwwroot/js/monaco-init.js | 14 +- .../AddressSpaceComposer.cs | 86 +++++++-- .../Drivers/DeploymentArtifact.cs | 132 ++++++++++--- .../EquipmentScriptPathsTests.cs | 179 ++++++++++-------- .../DraftValidatorTests.cs | 111 +++++++++++ .../ScriptAnalysis/CtxCompletionGuardTests.cs | 2 +- .../ScriptAnalysis/EquipTokenEditorTests.cs | 85 ++++++--- .../ScriptAnalysis/HoverSignatureTests.cs | 2 +- .../ScriptAnalysis/ScriptTagCatalogTests.cs | 124 ++++++------ .../ScriptAnalysis/TagPathCompletionTests.cs | 3 +- .../VirtualTagEquipTokenValidationTests.cs | 125 +++++------- .../DeploymentArtifactEquipRefParityTests.cs | 125 ++++++++++++ 23 files changed, 1142 insertions(+), 426 deletions(-) create mode 100644 src/Core/ZB.MOM.WW.OtOpcUa.Commons/Types/EquipmentReferenceMap.cs create mode 100644 tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Drivers/DeploymentArtifactEquipRefParityTests.cs diff --git a/docs/ScriptEditor.md b/docs/ScriptEditor.md index b445768d..c3047afc 100644 --- a/docs/ScriptEditor.md +++ b/docs/ScriptEditor.md @@ -307,76 +307,88 @@ Register the replacement in `EndpointRouteBuilderExtensions.AddAdminUI` ### Why -Today each VirtualTag bound to a script typically needs its own near-duplicate -script because tag paths are hard-coded absolutes (e.g. `TestMachine_001.Speed`). -The `{{equip}}` token breaks this coupling: point many VirtualTags' `ScriptId` at -a single template script, and each resolves the token to its own equipment's tag -base prefix at deploy time. No schema change is required — sharing a `Script` -record across VirtualTags already works; `{{equip}}` is what makes the shared -script resolve per-equipment. +Each VirtualTag bound to a script would otherwise need its own near-duplicate +script because tag paths are hard-coded absolute RawPaths (e.g. +`Cell1/Modbus/Dev1/Speed`). The `{{equip}}/` token breaks this coupling: +point many VirtualTags' `ScriptId` at a single template script, and each resolves +the token through **its own equipment's tag references** at deploy time. No schema +change is required — sharing a `Script` record across VirtualTags already works; +`{{equip}}/` is what makes the shared script resolve per-equipment. ### Before / after -**Before — one script per machine:** +**Before — one script per machine (hard-coded RawPath):** ```csharp // Script "Calc_TestMachine_001" — hard-coded, cannot reuse -return ctx.GetTag("TestMachine_001.Speed").Value; +return ctx.GetTag("Cell1/Modbus/Dev1/Speed").Value; ``` **After — one shared template:** ```csharp // Script "Calc_Speed" — works for any machine -return ctx.GetTag("{{equip}}.Speed").Value; +return ctx.GetTag("{{equip}}/Speed").Value; ``` -`TestMachine_001` and `TestMachine_002` both bind `ScriptId = "Calc_Speed"`. -At deploy, each VirtualTag receives its own expanded copy: -`TestMachine_001.Speed` and `TestMachine_002.Speed` respectively. +`TestMachine_001` and `TestMachine_002` both bind `ScriptId = "Calc_Speed"`, and +each has a **tag reference** whose effective name is `Speed`. At deploy, each +VirtualTag receives its own expanded copy — `{{equip}}/Speed` resolves to that +equipment's referenced raw tag's RawPath. -### Token rules +### Token rules (v3) -- The token is `{{equip}}` (double braces, lowercase). +- The token joint is a **slash**: `{{equip}}/` (double-brace stem, + lowercase). `` is a **reference effective name** — the reference's + `DisplayNameOverride`, else the backing raw tag's `Name`. - It is substituted **only inside `ctx.GetTag(…)` / `ctx.SetVirtualTag(…)` first-argument string literals** — comments, logger strings, and other code are untouched. -- The operator writes the separator and tail: `ctx.GetTag("{{equip}}.Speed")`, - `ctx.GetTag("{{equip}}.Sub.Field")`, etc. -- The token expands to the equipment's **tag base prefix** — the common - substring-before-the-first-dot of that equipment's configured driver-tag - `FullName` values. Example: tags `TestMachine_001.Speed` and - `TestMachine_001.Temp` → base `TestMachine_001`. +- The whole post-prefix literal content is the reference name, so effective names + with internal spaces are supported: `ctx.GetTag("{{equip}}/Motor Speed")`. +- `{{equip}}/` **resolves through the owning equipment's `UnsTagReference` + rows** (by effective name) to the backing raw tag's `RawPath`. Example: a + reference named `Speed` backing `Cell1/Modbus/Dev1/Speed` → the token expands to + `Cell1/Modbus/Dev1/Speed`. +- Scripted-alarm predicate scripts resolve `{{equip}}/` the same way; alarm + **message-template** tokens follow the same resolution rule. ### Validation requirement -Saving a VirtualTag that is bound to a `{{equip}}`-using script is rejected in -the AdminUI if the equipment does not have at least one configured driver tag, or -if its tags span multiple object prefixes (i.e. the common prefix is ambiguous or -absent). The rejection message is surfaced as a clear validation error on the save -form. This check is enforced eagerly so that an unresolved `{{equip}}` token — -which would leave a path that resolves to nothing at runtime (Bad quality) — can -never reach the deployed artifact. +Saving a VirtualTag (or ScriptedAlarm) whose script uses `{{equip}}/` is +rejected in the AdminUI when `` is not one of the owning equipment's +reference effective names. The same rule runs at the deploy gate +(`DraftValidator.ValidateEquipReferenceResolution`, error code +`EquipReferenceUnresolved`), which also catches a **rename-induced** breakage the +authoring check never saw. The rejection names the script/alarm, the equipment, and +the missing ref — so an unresolved token can never reach the deployed artifact. ### Editor support In the Monaco script editor (ScriptEdit page and the `/uns` virtual-tag modal's inline script panel): -- **Hover** — hovering a `{{equip}}` path literal shows an - *"Equipment-relative path — resolved at deploy"* note. -- **Completions** — typing `{{equip}}.` inside a `GetTag`/`SetVirtualTag` literal - offers completion of attribute leaf names (the part after the first dot of known - tag references in the catalog). +- **Hover** — hovering a `{{equip}}/` path literal shows an + *"Equipment-relative path — resolved through the equipment's tag reference at + deploy"* note. +- **Completions** — typing `{{equip}}/` inside a `GetTag`/`SetVirtualTag` literal + offers the owning equipment's **reference effective names** (needs an equipment + context; inert on the shared ScriptEdit page). +- **Diagnostics** — an unresolved `{{equip}}/` is flagged (`OTSCRIPT_EQUIPREF`) + identically to the deploy gate, preserving *editor accepts ⇔ publish accepts*. ### Maintainer note -Substitution runs at the two compose seams — -`Phase7Composer.Compose` and `DeploymentArtifact.BuildEquipmentVirtualTagPlans` -— via the shared `ZB.MOM.WW.OtOpcUa.Commons.Types.EquipmentScriptPaths` helper, -**before** dependency extraction. The runtime, the static change-trigger -dependency graph, and the literal-only path rule are therefore all unchanged: -by the time they see the script, `{{equip}}` has been replaced with a concrete -tag-base prefix and the path is a normal string literal. +Substitution runs at the two compose seams — `AddressSpaceComposer.Compose` and +`DeploymentArtifact.ParseComposition` — via the shared +`ZB.MOM.WW.OtOpcUa.Commons.Types.EquipmentScriptPaths.SubstituteEquipmentToken` +helper, fed the equipment's reference map (effective name → RawPath) built by +`EquipmentReferenceMap` over the shared `RawPathResolver`. Substitution runs +**before** dependency extraction, so the runtime, the static change-trigger +dependency graph, and the literal-only path rule are unchanged: by the time they +see the script, `{{equip}}/` has been replaced with a concrete RawPath and +the path is a normal string literal. An unresolved ref is left un-substituted (the +validator rejects it first — substitution never throws). The two seams build the +reference map identically, so their plans stay byte-parity. --- diff --git a/src/Core/ZB.MOM.WW.OtOpcUa.Commons/Types/EquipmentReferenceMap.cs b/src/Core/ZB.MOM.WW.OtOpcUa.Commons/Types/EquipmentReferenceMap.cs new file mode 100644 index 00000000..2a6eeb3d --- /dev/null +++ b/src/Core/ZB.MOM.WW.OtOpcUa.Commons/Types/EquipmentReferenceMap.cs @@ -0,0 +1,94 @@ +namespace ZB.MOM.WW.OtOpcUa.Commons.Types; + +/// +/// Builds the per-equipment reference map — equipmentId → (effectiveName → backing-tag RawPath) — +/// the single authority both compose seams (AddressSpaceComposer + DeploymentArtifact) +/// and the draft validator use to resolve {{equip}}/<RefName> script paths. A reference's +/// effective name is its DisplayNameOverride else the backing raw tag's Name; the +/// RawPath is computed through the shared (the same identity authority the +/// rest of v3 uses), so the entity side (authoring/validation) and the artifact-decode side agree +/// byte-for-byte. +/// Input-shape agnostic + pure: callers flatten their references (EF entities on one side, +/// artifact JSON on the other) into the same primitive tuple + tag lookup, so the join, the +/// effective-name rule, and the collision policy live ONLY here. References are consumed in +/// UnsTagReferenceId-ordinal order and effective-name collisions keep the FIRST — a valid draft +/// has none (the uniqueness validator rejects them), and the deterministic first-wins keeps the two +/// seams parity-stable on any input. +/// +public static class EquipmentReferenceMap +{ + /// A flattened UNS tag reference: which equipment references which raw tag under an optional override. + /// Stable logical id — the ordering key for deterministic first-wins. + /// The referencing equipment. + /// The backing raw tag. + /// Optional effective-name override; = use the raw tag's Name. + public readonly record struct ReferenceRow(string UnsTagReferenceId, string EquipmentId, string TagId, string? DisplayNameOverride); + + /// The backing raw tag's identity inputs for its RawPath + effective name. + /// The raw tag's leaf name (also the default effective name). + /// The tag's owning device id. + /// The tag's owning tag-group id, or when directly under the device. + public readonly record struct TagRow(string Name, string DeviceId, string? TagGroupId); + + /// + /// Build the reference map. For each reference (ordered by UnsTagReferenceId), resolve the + /// backing tag's RawPath via and key it under the effective name within + /// the owning equipment. References whose backing tag is unknown or whose RawPath cannot be built + /// (broken chain) are skipped. Effective-name collisions within an equipment keep the first. + /// + /// The flattened UNS tag references (any order; sorted internally). + /// Backing raw tags keyed by TagId. + /// The shared RawPath resolver over the raw topology. + /// equipmentId → (effectiveName → RawPath). Equipments with no resolvable reference are absent. + public static IReadOnlyDictionary> Build( + IEnumerable references, + IReadOnlyDictionary tagsById, + RawPathResolver resolver) + { + ArgumentNullException.ThrowIfNull(references); + ArgumentNullException.ThrowIfNull(tagsById); + ArgumentNullException.ThrowIfNull(resolver); + + var byEquip = new Dictionary>(StringComparer.Ordinal); + + foreach (var r in references.OrderBy(x => x.UnsTagReferenceId, StringComparer.Ordinal)) + { + if (string.IsNullOrEmpty(r.EquipmentId) || string.IsNullOrEmpty(r.TagId)) continue; + if (!tagsById.TryGetValue(r.TagId, out var tag)) continue; + var effectiveName = string.IsNullOrEmpty(r.DisplayNameOverride) ? tag.Name : r.DisplayNameOverride!; + if (string.IsNullOrEmpty(effectiveName)) continue; + var rawPath = resolver.TryBuildTagPath(tag.DeviceId, tag.TagGroupId, tag.Name); + if (rawPath is null) continue; // broken chain — dropped (deploy gate rejects invalid names) + + if (!byEquip.TryGetValue(r.EquipmentId, out var map)) + byEquip[r.EquipmentId] = map = new Dictionary(StringComparer.Ordinal); + map.TryAdd(effectiveName, rawPath); // first-wins on collision (validator rejects real collisions) + } + + return byEquip.ToDictionary( + kv => kv.Key, + kv => (IReadOnlyDictionary)kv.Value, + StringComparer.Ordinal); + } + + /// The set of effective names a single equipment's references contribute (for the authoring + /// gate + Monaco completion, which need only the names — not the RawPaths). + /// The flattened UNS tag references for (typically) one equipment. + /// Backing raw tag Name keyed by TagId. + /// The distinct effective names, ordinal. + public static IReadOnlySet EffectiveNames( + IEnumerable references, + IReadOnlyDictionary tagNameById) + { + ArgumentNullException.ThrowIfNull(references); + ArgumentNullException.ThrowIfNull(tagNameById); + var names = new HashSet(StringComparer.Ordinal); + foreach (var r in references) + { + var effectiveName = r.DisplayNameOverride + ?? (tagNameById.TryGetValue(r.TagId, out var n) ? n : null); + if (!string.IsNullOrEmpty(effectiveName)) names.Add(effectiveName); + } + return names; + } +} diff --git a/src/Core/ZB.MOM.WW.OtOpcUa.Commons/Types/EquipmentScriptPaths.cs b/src/Core/ZB.MOM.WW.OtOpcUa.Commons/Types/EquipmentScriptPaths.cs index d29894ca..be647250 100644 --- a/src/Core/ZB.MOM.WW.OtOpcUa.Commons/Types/EquipmentScriptPaths.cs +++ b/src/Core/ZB.MOM.WW.OtOpcUa.Commons/Types/EquipmentScriptPaths.cs @@ -3,19 +3,29 @@ using System.Text.RegularExpressions; namespace ZB.MOM.WW.OtOpcUa.Commons.Types; /// -/// Helpers for equipment-relative virtual-tag script paths. The reserved token -/// {{equip}} inside a ctx.GetTag/ctx.SetVirtualTag path literal is -/// replaced at the compose seams with the owning equipment's tag base prefix (derived -/// from its child-tag FullNames). Pure + regex-based (no Roslyn) so the OpcUaServer -/// composer and the Runtime artifact-decode path can both share it. Also the single home -/// for the ctx.GetTag("…") dependency-ref extraction those two seams used to -/// duplicate. +/// Helpers for equipment-relative virtual-tag / scripted-alarm script paths. The reserved token +/// {{equip}}/<RefName> inside a ctx.GetTag/ctx.SetVirtualTag path literal is +/// replaced at the compose seams (AddressSpaceComposer + DeploymentArtifact) with the +/// backing raw tag's RawPath, resolved through the owning equipment's +/// UnsTagReference rows by effective name (<RefName>). +/// v3 syntax: the token joint is a slash — {{equip}}/<RefName> — replacing +/// the v2 dot-prefix derivation ({{equip}}.X). <RefName> is a reference's effective name +/// (its DisplayNameOverride else the backing raw tag's Name). An unresolved +/// <RefName> is left un-substituted (substitution never throws); the deploy-time validator + +/// the authoring gate + the Monaco diagnostic reject it first, preserving the invariant +/// the editor accepts ⇔ publish accepts. +/// Pure + regex-based (no Roslyn) so the OpcUaServer composer and the Runtime artifact-decode path can +/// both share it. Also the single home for the ctx.GetTag("…") dependency-ref extraction those +/// two seams used to duplicate. /// public static class EquipmentScriptPaths { - /// The reserved equipment-base token. + /// The reserved equipment token stem. public const string EquipToken = "{{equip}}"; + /// The reserved equipment reference-relative prefix — the token stem plus the slash joint. + public const string EquipTokenPrefix = "{{equip}}/"; + // ctx.GetTag("ref") — reads only; the dependency graph subscribes to exactly these. private static readonly Regex GetTagRefRegex = new(@"ctx\s*\.\s*GetTag\s*\(\s*""([^""]+)""\s*\)", RegexOptions.Compiled); @@ -32,6 +42,14 @@ public static class EquipmentScriptPaths private static readonly Regex PathLiteralRegex = new(@"(ctx\s*\.\s*(?:GetTag|SetVirtualTag)\s*\(\s*"")([^""]*)("")", RegexOptions.Compiled); + // {{equip}}/ occurrence in FREE TEXT (message templates). runs until the next + // delimiter that cannot appear in an intra-literal RawPath segment used inline in a template — + // whitespace, quote, brace, paren, semicolon, or the '/' separator. (Reference effective names may + // contain internal spaces; that space-bearing form is unambiguous only inside a path literal, so the + // free-text scan is best-effort — see ExtractEquipReferenceNamesFromText.) + private static readonly Regex EquipRefTextRegex = + new(@"\{\{equip\}\}/([^\s""{}();/]+)", RegexOptions.Compiled); + // A pure pass-through virtual-tag body: exactly `return ctx.GetTag("").Value;` // (whitespace-insensitive). Captures for relay→alias conversion. Anything with extra // statements, arithmetic, a different member than .Value, or multiple GetTag calls is NOT a relay. @@ -46,44 +64,89 @@ public static class EquipmentScriptPaths !string.IsNullOrEmpty(source) && source.Contains(EquipToken, StringComparison.Ordinal); /// - /// Equipment tag base = the single shared substring-before-first-dot across the - /// equipment's child-tag FullNames. Returns null when there are no usable - /// FullNames or they don't agree on one prefix (equipment spanning multiple objects). + /// Replace each {{equip}}/<RefName> reference-relative path with the backing raw tag's + /// RawPath from (effective name → RawPath), inside + /// ctx.GetTag/ctx.SetVirtualTag path literals only. A path literal whose content is + /// {{equip}}/<RefName> is treated as a single reference: <RefName> is the + /// entire remainder after the prefix (so reference effective names may contain internal spaces). + /// Identity when is null/empty, is empty, + /// or the token is absent (so every existing script — none of which use the token — is byte-unchanged). + /// An <RefName> absent from the map is left un-substituted (never throws) — the validator + /// rejects it first at deploy. /// - /// The equipment's child-tag driver FullNames. - /// The shared base prefix, or null when none/ambiguous. - public static string? DeriveEquipmentBase(IEnumerable childFullNames) + /// The script source. + /// The equipment's reference map: effective name → backing-tag RawPath. + /// The source with each resolvable {{equip}}/<RefName> substituted inside path literals. + public static string SubstituteEquipmentToken(string source, IReadOnlyDictionary referenceMap) { - string? found = null; - foreach (var fn in childFullNames) - { - if (string.IsNullOrWhiteSpace(fn)) continue; - var dot = fn.IndexOf('.'); - var prefix = dot < 0 ? fn : fn.Substring(0, dot); - if (prefix.Length == 0) continue; - if (found is null) found = prefix; - else if (!string.Equals(found, prefix, StringComparison.Ordinal)) return null; - } - return found; + if (string.IsNullOrEmpty(source) || referenceMap is null || referenceMap.Count == 0) return source; + if (!source.Contains(EquipTokenPrefix, StringComparison.Ordinal)) return source; + return PathLiteralRegex.Replace(source, m => + m.Groups[1].Value + + SubstituteContent(m.Groups[2].Value, referenceMap) + + m.Groups[3].Value); + } + + // Substitute the reference-relative token inside a single path-literal's content. The content is one + // whole tag path; when it starts with the {{equip}}/ prefix the remainder is the reference name. + private static string SubstituteContent(string content, IReadOnlyDictionary referenceMap) + { + if (!content.StartsWith(EquipTokenPrefix, StringComparison.Ordinal)) return content; + var refName = content.Substring(EquipTokenPrefix.Length); + if (refName.Length == 0) return content; + return referenceMap.TryGetValue(refName, out var rawPath) ? rawPath : content; } /// - /// Replace {{equip}} with inside - /// ctx.GetTag/ctx.SetVirtualTag path literals only. Identity when - /// is null/empty or the token is absent (so every existing - /// script — none of which use the token — is byte-unchanged). + /// Distinct <RefName> values used via {{equip}}/<RefName> inside + /// ctx.GetTag/ctx.SetVirtualTag path literals, in first-seen order. Scoped to the SAME + /// path literals operates on (so a token in a comment / logger + /// string is not reported), and the entire post-prefix remainder is the reference name (matching + /// substitution) — this keeps the validator / authoring gate / Monaco diagnostic in lockstep with what + /// resolves. Feeds the deploy-gate + authoring rejection + editor completion. /// - /// The script source. - /// The equipment base prefix, or null/empty for no substitution. - /// The source with the token substituted inside path literals. - public static string SubstituteEquipmentToken(string source, string? equipBase) + /// The virtual-tag / scripted-alarm predicate script source. + /// Distinct reference names, first-seen order; empty when none / no token. + public static IReadOnlyList ExtractEquipReferenceNames(string? scriptSource) { - if (string.IsNullOrEmpty(source) || string.IsNullOrEmpty(equipBase)) return source; - if (!source.Contains(EquipToken, StringComparison.Ordinal)) return source; - return PathLiteralRegex.Replace(source, m => - m.Groups[1].Value - + m.Groups[2].Value.Replace(EquipToken, equipBase, StringComparison.Ordinal) - + m.Groups[3].Value); + if (string.IsNullOrEmpty(scriptSource) + || !scriptSource.Contains(EquipTokenPrefix, StringComparison.Ordinal)) + return Array.Empty(); + var seen = new HashSet(StringComparer.Ordinal); + var result = new List(); + foreach (Match m in PathLiteralRegex.Matches(scriptSource)) + { + var content = m.Groups[2].Value; + if (!content.StartsWith(EquipTokenPrefix, StringComparison.Ordinal)) continue; + var refName = content.Substring(EquipTokenPrefix.Length); + if (refName.Length > 0 && seen.Add(refName)) result.Add(refName); + } + return result; + } + + /// + /// Distinct <RefName> values used via {{equip}}/<RefName> in FREE TEXT — the + /// scripted-alarm MessageTemplate, which is not a path literal — in first-seen order. Best-effort: + /// a reference name is captured up to the next whitespace / quote / brace / paren / semicolon / slash, so + /// a space-bearing effective name used inline in a template resolves only up to its first space (a + /// documented, benign limitation — template rendering is dark until Batch 4). Feeds the deploy-gate rule + /// for alarm message tokens. + /// + /// The free text (e.g. a scripted-alarm message template). + /// Distinct reference names, first-seen order; empty when none / no token. + public static IReadOnlyList ExtractEquipReferenceNamesFromText(string? text) + { + if (string.IsNullOrEmpty(text) + || !text.Contains(EquipTokenPrefix, StringComparison.Ordinal)) + return Array.Empty(); + var seen = new HashSet(StringComparer.Ordinal); + var result = new List(); + foreach (Match m in EquipRefTextRegex.Matches(text)) + { + var refName = m.Groups[1].Value; + if (refName.Length > 0 && seen.Add(refName)) result.Add(refName); + } + return result; } /// @@ -115,10 +178,11 @@ public static class EquipmentScriptPaths /// {{equip}} double-brace form is excluded by the token regex. Deterministic so the live /// composer (AddressSpaceComposer) and the artifact-decode mirror (DeploymentArtifact) /// produce the exact same ordered list — the byte-parity contract EquipmentScriptedAlarmPlan - /// equality depends on. Scripted alarms do NOT use {{equip}} substitution (only virtual - /// tags do) — pass the predicate source as-is. + /// equality depends on. The predicate source passed here is the ALREADY-substituted source (the two + /// compose seams substitute {{equip}}/<RefName> before extraction, identically), so the + /// merged refs are resolved RawPaths. /// - /// The resolved predicate script source. + /// The resolved (substituted) predicate script source. /// The alarm message template carrying {TagPath} tokens. /// The merged, distinct, deterministically-ordered dependency refs. public static IReadOnlyList ExtractAlarmDependencyRefs(string? predicateSource, string? messageTemplate) @@ -154,7 +218,7 @@ public static class EquipmentScriptPaths /// The virtual-tag script source to inspect. /// /// When the method returns , the captured GetTag path literal - /// (e.g. TestMachine_020.TestChangingInt or {{equip}}.Speed); + /// (e.g. TestMachine_020.TestChangingInt or {{equip}}/Speed); /// otherwise . /// /// diff --git a/src/Core/ZB.MOM.WW.OtOpcUa.Configuration/Validation/DraftValidator.cs b/src/Core/ZB.MOM.WW.OtOpcUa.Configuration/Validation/DraftValidator.cs index 86174ef1..11d6e08c 100644 --- a/src/Core/ZB.MOM.WW.OtOpcUa.Configuration/Validation/DraftValidator.cs +++ b/src/Core/ZB.MOM.WW.OtOpcUa.Configuration/Validation/DraftValidator.cs @@ -39,6 +39,7 @@ public static class DraftValidator ValidateRawNameCharset(draft, errors); ValidateHistorizedTagnameLength(draft, errors); ValidateUnsEffectiveLeafUniqueness(draft, errors); + ValidateEquipReferenceResolution(draft, errors); ValidateCalculationTags(draft, errors); return errors; } @@ -238,6 +239,64 @@ public static class DraftValidator } } + /// v3: every {{equip}}/<RefName> used in an equipment's VirtualTag script, + /// ScriptedAlarm predicate script, or ScriptedAlarm message template must resolve to one of the owning + /// equipment's UnsTagReference effective names (DisplayNameOverride else the backing raw + /// tag's Name) — the same set the compose seams substitute against. An unresolved <RefName> + /// is a deploy error (replacing the v2 silent null-base no-substitution), naming the script/alarm, the + /// equipment, and the missing ref. This is the deploy-gate half of the invariant the Monaco diagnostic + + /// the authoring gate enforce (editor accepts ⇔ publish accepts). + private static void ValidateEquipReferenceResolution(DraftSnapshot draft, List errors) + { + var tagNameById = draft.Tags.GroupBy(t => t.TagId, StringComparer.Ordinal) + .ToDictionary(g => g.Key, g => g.First().Name, StringComparer.Ordinal); + + // equipmentId → set of reference effective names ({{equip}}/ resolves through REFERENCES + // only — VirtualTags/ScriptedAlarms are computed signals with no backing RawPath). + var refNamesByEquip = new Dictionary>(StringComparer.Ordinal); + foreach (var r in draft.UnsTagReferences) + { + var effective = r.DisplayNameOverride ?? (tagNameById.TryGetValue(r.TagId, out var n) ? n : null); + if (string.IsNullOrEmpty(effective)) continue; + if (!refNamesByEquip.TryGetValue(r.EquipmentId, out var set)) + refNamesByEquip[r.EquipmentId] = set = new HashSet(StringComparer.Ordinal); + set.Add(effective!); + } + + var scriptSourceById = draft.Scripts.GroupBy(s => s.ScriptId, StringComparer.Ordinal) + .ToDictionary(g => g.Key, g => g.First().SourceCode, StringComparer.Ordinal); + + void CheckRefs(string equipmentId, IEnumerable refNames, string source) + { + var have = refNamesByEquip.TryGetValue(equipmentId, out var set) ? set : null; + foreach (var name in refNames) + { + if (have is not null && have.Contains(name)) continue; + errors.Add(new("EquipReferenceUnresolved", + $"{source} uses '{EquipmentScriptPaths.EquipTokenPrefix}{name}' but equipment '{equipmentId}' has " + + $"no reference named '{name}'; add a reference with that effective name or correct the script.", + equipmentId)); + } + } + + foreach (var v in draft.VirtualTags) + { + var src = scriptSourceById.TryGetValue(v.ScriptId, out var s) ? s : null; + var used = EquipmentScriptPaths.ExtractEquipReferenceNames(src); + if (used.Count > 0) CheckRefs(v.EquipmentId, used, $"VirtualTag '{v.VirtualTagId}'"); + } + + foreach (var a in draft.ScriptedAlarms) + { + var src = scriptSourceById.TryGetValue(a.PredicateScriptId, out var s) ? s : null; + var used = EquipmentScriptPaths.ExtractEquipReferenceNames(src) + .Concat(EquipmentScriptPaths.ExtractEquipReferenceNamesFromText(a.MessageTemplate)) + .Distinct(StringComparer.Ordinal) + .ToList(); + if (used.Count > 0) CheckRefs(a.EquipmentId, used, $"ScriptedAlarm '{a.ScriptedAlarmId}'"); + } + } + private static bool IsValidSegment(string? s) => s is not null && (UnsSegment.IsMatch(s) || s == UnsDefaultSegment); diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/MonacoEditor.razor b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/MonacoEditor.razor index 6b4e549d..d4c73da1 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/MonacoEditor.razor +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/MonacoEditor.razor @@ -29,6 +29,13 @@ [Parameter] public bool ReadOnly { get; set; } = false; [Parameter] public bool ShowToolbar { get; set; } = true; + /// + /// Owning-equipment context for equipment-relative {{equip}}/<RefName> completion + + /// diagnostics. Set on the per-equipment VirtualTag / ScriptedAlarm modals; left null on the shared + /// ScriptEdit page (where the token cannot resolve to a single equipment). + /// + [Parameter] public string? EquipmentId { get; set; } + /// /// Fires whenever Monaco's marker set updates (after the 500 ms diagnostic /// debounce). The marker DTO is not modelled yet — typed as object[] until a @@ -61,7 +68,8 @@ { value = Value ?? "", language = Language, - readOnly = ReadOnly + readOnly = ReadOnly, + equipmentId = EquipmentId }, _dotNetRef); _initialized = true; diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/VirtualTagModal.razor b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/VirtualTagModal.razor index 3917da3c..ab7a4868 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/VirtualTagModal.razor +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/VirtualTagModal.razor @@ -99,7 +99,7 @@ Editing shared script "@_scriptName" — used by @_scriptUsageCount virtual tag(s). Changes affect all of them.
- + @if (!string.IsNullOrWhiteSpace(_scriptError)) {
@_scriptError
diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/IScriptTagCatalog.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/IScriptTagCatalog.cs index e6f03fd9..d7004c2d 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/IScriptTagCatalog.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/IScriptTagCatalog.cs @@ -23,13 +23,16 @@ public interface IScriptTagCatalog /// The resolved tag info, or when is not a known configured path. Task GetTagInfoAsync(string path, CancellationToken ct); - /// Distinct attribute leaf names — the substring after the first dot of each - /// configured tag FullName — optionally prefix-filtered. Powers {{equip}}. completion, - /// which needs the per-equipment object prefix stripped. - /// Case-insensitive StartsWith prefix over the leaf; null/empty = all (bounded). + /// v3: the owning equipment's UnsTagReference effective names (its + /// DisplayNameOverride else the backing raw tag's Name) — the resolvable set for + /// {{equip}}/<RefName> completion + diagnostics, matching what the compose seams substitute + /// and the deploy gate enforces. Optionally prefix-filtered. Empty when the equipment id is blank or has + /// no references. + /// The equipment whose references to list; blank returns empty. + /// Case-insensitive StartsWith prefix over the reference name; null/empty = all (bounded). /// Cancellation token. - /// Distinct leaf names. - Task> GetEquipmentRelativeLeavesAsync(string? filter, CancellationToken ct); + /// Distinct reference effective names. + Task> GetEquipmentReferenceNamesAsync(string equipmentId, string? filter, CancellationToken ct); } /// Resolved info for one configured tag/virtual-tag path (for hover). @@ -114,17 +117,32 @@ public sealed class ScriptTagCatalog(IDbContextFactory d } /// - public async Task> GetEquipmentRelativeLeavesAsync(string? filter, CancellationToken ct) + public async Task> GetEquipmentReferenceNamesAsync(string equipmentId, string? filter, CancellationToken ct) { - var entries = await BuildEntriesAsync(ct); - var leaves = new HashSet(StringComparer.Ordinal); - foreach (var e in entries) + if (string.IsNullOrEmpty(equipmentId)) return Array.Empty(); + await using var db = await dbFactory.CreateDbContextAsync(ct); + + var refs = await db.UnsTagReferences.AsNoTracking() + .Where(r => r.EquipmentId == equipmentId) + .Select(r => new { r.TagId, r.DisplayNameOverride }) + .ToListAsync(ct); + if (refs.Count == 0) return Array.Empty(); + + var tagIds = refs.Select(r => r.TagId).Distinct().ToList(); + var tagNameById = await db.Tags.AsNoTracking() + .Where(t => tagIds.Contains(t.TagId)) + .Select(t => new { t.TagId, t.Name }) + .ToDictionaryAsync(t => t.TagId, t => t.Name, ct); + + // Effective name = DisplayNameOverride else the backing raw tag's Name (ordinal set). + var names = new HashSet(StringComparer.Ordinal); + foreach (var r in refs) { - var dot = e.Path.IndexOf('.'); - if (dot < 0 || dot + 1 >= e.Path.Length) continue; - leaves.Add(e.Path.Substring(dot + 1)); + var eff = r.DisplayNameOverride ?? (tagNameById.TryGetValue(r.TagId, out var n) ? n : null); + if (!string.IsNullOrEmpty(eff)) names.Add(eff!); } - IEnumerable q = leaves; + + IEnumerable q = names; if (!string.IsNullOrWhiteSpace(filter)) q = q.Where(n => n.StartsWith(filter, StringComparison.OrdinalIgnoreCase)); return q.OrderBy(n => n, StringComparer.OrdinalIgnoreCase).Take(MaxResults).ToList(); diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisContracts.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisContracts.cs index 62f962a4..2c71031c 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisContracts.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisContracts.cs @@ -1,15 +1,19 @@ namespace ZB.MOM.WW.OtOpcUa.AdminUI.ScriptAnalysis; -public record DiagnoseRequest(string Code); +// EquipmentId (optional) carries the owning-equipment context the {{equip}}/ completion + +// diagnostic need to resolve reference effective names. Null on the shared ScriptEdit page (no single +// equipment) — the equip-ref features are then inert, matching the deploy gate (which only resolves per +// owning equipment). +public record DiagnoseRequest(string Code, string? EquipmentId = null); public record DiagnoseResponse(IReadOnlyList Markers); public record DiagnosticMarker(int Severity, int StartLineNumber, int StartColumn, int EndLineNumber, int EndColumn, string Message, string Code); -public record CompletionsRequest(string CodeText, int Line, int Column); +public record CompletionsRequest(string CodeText, int Line, int Column, string? EquipmentId = null); public record CompletionsResponse(IReadOnlyList Items); public record CompletionItem(string Label, string InsertText, string Detail, string Kind, int InsertTextRules = 0); -public record HoverRequest(string CodeText, int Line, int Column); +public record HoverRequest(string CodeText, int Line, int Column, string? EquipmentId = null); public record HoverResponse(string? Markdown); public record SignatureHelpRequest(string CodeText, int Line, int Column); diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisEndpoints.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisEndpoints.cs index 7fec4785..6783f56f 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisEndpoints.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisEndpoints.cs @@ -16,7 +16,7 @@ public static class ScriptAnalysisEndpoints // ConfigEditor policy (Administrator or Designer) — matches the Script page gate and the /deployments gate. var group = endpoints.MapGroup("/api/script-analysis") .RequireAuthorization(AdminUiPolicies.ConfigEditor); - group.MapPost("/diagnostics", (DiagnoseRequest r, ScriptAnalysisService s) => Results.Ok(s.Diagnose(r))); + group.MapPost("/diagnostics", async (DiagnoseRequest r, ScriptAnalysisService s) => Results.Ok(await s.DiagnoseAsync(r))); group.MapPost("/completions", async (CompletionsRequest r, ScriptAnalysisService s) => Results.Ok(await s.CompleteAsync(r))); group.MapPost("/hover", async (HoverRequest r, ScriptAnalysisService s) => Results.Ok(await s.Hover(r))); group.MapPost("/signature-help", (SignatureHelpRequest r, ScriptAnalysisService s) => Results.Ok(s.SignatureHelp(r))); diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisService.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisService.cs index 32331a0e..663ef22c 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisService.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/ScriptAnalysisService.cs @@ -130,6 +130,58 @@ public sealed class ScriptAnalysisService } } + // ctx.GetTag("…") / ctx.SetVirtualTag("…") first-arg literal — three-part capture, mirroring + // EquipmentScriptPaths.PathLiteralRegex so the editor's {{equip}}/ diagnostic is scoped to the + // SAME path literals the compose seams substitute (never a comment / logger string). + private static readonly System.Text.RegularExpressions.Regex EquipPathLiteralRegex = + new(@"(ctx\s*\.\s*(?:GetTag|SetVirtualTag)\s*\(\s*"")([^""]*)("")", + System.Text.RegularExpressions.RegexOptions.Compiled); + + /// Diagnostics plus the v3 equipment-relative {{equip}}/<RefName> resolution check. + /// Runs the synchronous Roslyn/policy then, when an equipment context + catalog + /// are present, appends a marker for each {{equip}}/<RefName> whose <RefName> is + /// not one of the equipment's reference effective names — flagging exactly what the deploy gate + /// (DraftValidator.ValidateEquipReferenceResolution) rejects, so the editor accepts ⇔ publish + /// accepts. Inert (base markers only) on the shared ScriptEdit page where EquipmentId is null. + /// The diagnose request (its EquipmentId carries the owning-equipment context). + /// The base diagnostics plus any unresolved-reference markers. + public async Task DiagnoseAsync(DiagnoseRequest req) + { + var baseResp = Diagnose(req); + if (_catalog is null || string.IsNullOrEmpty(req.EquipmentId) || string.IsNullOrEmpty(req.Code)) + return baseResp; + try + { + var code = Normalize(req.Code); + if (!code.Contains(EquipmentScriptPaths.EquipTokenPrefix, StringComparison.Ordinal)) + return baseResp; + + var names = await _catalog.GetEquipmentReferenceNamesAsync(req.EquipmentId, null, CancellationToken.None); + var resolvable = new HashSet(names, StringComparer.Ordinal); + var markers = new List(baseResp.Markers); + + foreach (System.Text.RegularExpressions.Match m in EquipPathLiteralRegex.Matches(code)) + { + var content = m.Groups[2].Value; + if (!content.StartsWith(EquipmentScriptPaths.EquipTokenPrefix, StringComparison.Ordinal)) continue; + var refName = content.Substring(EquipmentScriptPaths.EquipTokenPrefix.Length); + if (refName.Length == 0 || resolvable.Contains(refName)) continue; + // Mark the whole literal content span (the {{equip}}/ path). + var span = new Microsoft.CodeAnalysis.Text.TextSpan(m.Groups[2].Index, content.Length); + markers.Add(ToUserMarker(code, span, + $"'{EquipmentScriptPaths.EquipTokenPrefix}{refName}' does not resolve — this equipment has no " + + $"reference named '{refName}'. Add a matching reference or correct the path.", + "OTSCRIPT_EQUIPREF")); + } + return new DiagnoseResponse(markers.Distinct().ToList()); + } + catch (Exception ex) + { + _logger?.LogWarning(ex, "Script equip-ref diagnostics failed; returning base markers."); + return baseResp; + } + } + private static int Sev(DiagnosticSeverity s) => s switch { DiagnosticSeverity.Error => 8, @@ -173,13 +225,17 @@ public sealed class ScriptAnalysisService if (_catalog != null && TryGetTagPathLiteral(token, out var pathPrefix, out _)) { - const string equipDot = EquipmentScriptPaths.EquipToken + "."; // "{{equip}}." - if (pathPrefix.StartsWith(equipDot, StringComparison.Ordinal)) + // v3: {{equip}}/ completes the owning equipment's UnsTagReference effective names + // (needs the equipment context — inert on the shared ScriptEdit page where EquipmentId is null). + const string equipPrefix = EquipmentScriptPaths.EquipTokenPrefix; // "{{equip}}/" + if (pathPrefix.StartsWith(equipPrefix, StringComparison.Ordinal)) { - var leaves = await _catalog.GetEquipmentRelativeLeavesAsync( - pathPrefix.Substring(equipDot.Length), CancellationToken.None); - return new CompletionsResponse(leaves - .Select(n => new CompletionItem(equipDot + n, equipDot + n, "tag path", "Field")) + if (string.IsNullOrEmpty(req.EquipmentId)) + return new CompletionsResponse(Array.Empty()); + var names = await _catalog.GetEquipmentReferenceNamesAsync( + req.EquipmentId, pathPrefix.Substring(equipPrefix.Length), CancellationToken.None); + return new CompletionsResponse(names + .Select(n => new CompletionItem(equipPrefix + n, equipPrefix + n, "tag path", "Field")) .ToList()); } @@ -281,7 +337,8 @@ public sealed class ScriptAnalysisService { return new HoverResponse( $"**Equipment-relative path** `{Code(tagPath)}`\n\n" + - "The {{equip}} token is replaced with the owning equipment's tag base when the VirtualTag is deployed."); + "`{{equip}}/` resolves through the owning equipment's tag reference " + + "(by effective name) to the backing raw tag's path when the VirtualTag is deployed."); } var info = await _catalog.GetTagInfoAsync(tagPath, CancellationToken.None); diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs index 0a12e7ce..864c648f 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/UnsTreeService.cs @@ -866,29 +866,45 @@ public sealed class UnsTreeService(IDbContextFactory dbF } /// - /// When the bound script uses the reserved {{equip}} token, the owning equipment must have - /// a derivable tag base (≥1 driver tag, all sharing one object prefix). Returns a rejection result - /// when the token is present but no base can be derived; null otherwise (token absent, or a - /// base exists). The script source is fetched from the supplied (in-scope) context. + /// v3 (M1): when the bound script uses {{equip}}/<RefName>, every <RefName> must + /// resolve to one of the owning equipment's UnsTagReference effective names (its + /// DisplayNameOverride else the backing raw tag's Name) — the same set the compose seams + /// substitute against and the deploy gate (DraftValidator.ValidateEquipReferenceResolution) + /// enforces. Returns a readable rejection naming the missing ref(s) when any is unresolved; null + /// otherwise (no slash-token, or all resolve). Replaces the v2 DeriveEquipmentBase(empty)→null + /// check, which rejected ALL {{equip}} VirtualTags with a now-impossible "add a driver tag" message. /// private static async Task ValidateEquipTokenAsync( OtOpcUaConfigDbContext db, string equipmentId, string scriptId, CancellationToken ct) { var src = await db.Scripts.Where(s => s.ScriptId == scriptId) .Select(s => s.SourceCode).FirstOrDefaultAsync(ct); - if (!EquipmentScriptPaths.ContainsEquipToken(src)) return null; + var used = EquipmentScriptPaths.ExtractEquipReferenceNames(src); + if (used.Count == 0) return null; - // The equipment↔Tag binding was retired in v3 (Tag is Raw-only), so no equipment-bound driver - // tags exist to derive an equipment tag base from. The {{equip}} token can't be resolved here. - var fullNames = Array.Empty(); - if (EquipmentScriptPaths.DeriveEquipmentBase(fullNames) is null) + // The equipment's reference effective-name set: DisplayNameOverride else the backing raw tag's Name. + var refs = await db.UnsTagReferences.AsNoTracking() + .Where(r => r.EquipmentId == equipmentId) + .Select(r => new { r.TagId, r.DisplayNameOverride }) + .ToListAsync(ct); + var tagIds = refs.Select(r => r.TagId).ToList(); + var tagNameById = await db.Tags.AsNoTracking() + .Where(t => tagIds.Contains(t.TagId)) + .Select(t => new { t.TagId, t.Name }) + .ToDictionaryAsync(t => t.TagId, t => t.Name, ct); + var effectiveNames = new HashSet(StringComparer.Ordinal); + foreach (var r in refs) { - return new UnsMutationResult(false, - $"Equipment '{equipmentId}' has no single tag base, so the " - + $"{EquipmentScriptPaths.EquipToken} token can't be resolved. Add at least one driver tag under this " - + $"equipment (all sharing one object prefix), or remove {EquipmentScriptPaths.EquipToken} from the script."); + var eff = r.DisplayNameOverride ?? (tagNameById.TryGetValue(r.TagId, out var n) ? n : null); + if (!string.IsNullOrEmpty(eff)) effectiveNames.Add(eff!); } - return null; + + var missing = used.Where(u => !effectiveNames.Contains(u)).ToList(); + if (missing.Count == 0) return null; + return new UnsMutationResult(false, + $"Script uses {string.Join(", ", missing.Select(m => $"'{EquipmentScriptPaths.EquipTokenPrefix}{m}'"))} " + + $"but equipment '{equipmentId}' has no reference with that effective name. " + + "Add a matching reference on the Tags tab, or correct the script."); } /// diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/wwwroot/js/monaco-init.js b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/wwwroot/js/monaco-init.js index 714a7e37..e90c63bc 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/wwwroot/js/monaco-init.js +++ b/src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/wwwroot/js/monaco-init.js @@ -23,6 +23,11 @@ const KIND_MAP = { Method: 0, Field: 3, Property: 9, Event: 10, Class: 5, Module: 8, Variable: 4, Text: 18 }; + // The owning-equipment id is stamped onto each editor's model at createEditor time so the globally + // registered csharp providers (which only receive the model) can thread it into the {{equip}}/ + // completion + diagnostics. Null on the shared ScriptEdit page (equip-ref features inert there). + function equipmentIdOf(model) { return (model && model.__otEquipmentId) || null; } + function registerCSharpProviders() { monaco.languages.registerCompletionItemProvider("csharp", { triggerCharacters: [".", "(", "\""], @@ -31,7 +36,7 @@ const resp = await fetch("/api/script-analysis/completions", { method: "POST", credentials: "same-origin", headers: { "Content-Type": "application/json" }, - body: JSON.stringify({ codeText: model.getValue(), line: position.lineNumber, column: position.column }) + body: JSON.stringify({ codeText: model.getValue(), line: position.lineNumber, column: position.column, equipmentId: equipmentIdOf(model) }) }); if (!resp.ok) return { suggestions: [] }; const data = await resp.json(); @@ -72,7 +77,7 @@ const resp = await fetch("/api/script-analysis/hover", { method: "POST", credentials: "same-origin", headers: { "Content-Type": "application/json" }, - body: JSON.stringify({ codeText: model.getValue(), line: position.lineNumber, column: position.column }) + body: JSON.stringify({ codeText: model.getValue(), line: position.lineNumber, column: position.column, equipmentId: equipmentIdOf(model) }) }); if (!resp.ok) return null; const data = await resp.json(); @@ -149,7 +154,7 @@ const resp = await fetch("/api/script-analysis/diagnostics", { method: "POST", credentials: "same-origin", headers: { "Content-Type": "application/json" }, - body: JSON.stringify({ code: model.getValue() }) + body: JSON.stringify({ code: model.getValue(), equipmentId: equipmentIdOf(model) }) }); if (!resp.ok) return []; const data = await resp.json(); @@ -192,6 +197,9 @@ // inside ctx.GetTag("…") / ctx.SetVirtualTag("…") without requiring an explicit Ctrl+Space. quickSuggestions: { other: true, comments: false, strings: true } }); + // Stamp the owning-equipment id on the model so the global csharp providers can thread it into the + // {{equip}}/ completion + diagnostics (null on the shared ScriptEdit page). + try { const m0 = editor.getModel(); if (m0) m0.__otEquipmentId = options.equipmentId || null; } catch (x) {} let diagTimer = null; const scheduleDiagnostics = function () { if (diagTimer) clearTimeout(diagTimer); diff --git a/src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/AddressSpaceComposer.cs b/src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/AddressSpaceComposer.cs index 1625aec6..24d46012 100644 --- a/src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/AddressSpaceComposer.cs +++ b/src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/AddressSpaceComposer.cs @@ -315,6 +315,11 @@ public static class AddressSpaceComposer /// The scripted alarms. /// The per-equipment virtual (calculated) tags. null = none. /// The scripts joined to by ScriptId for the expression. null = none. + /// The UNS tag references (equipment → raw tag). Feed the {{equip}}/<RefName> reference map. null = none. + /// The raw tags backing (RawPath computed via the shared resolver). null = none. + /// The raw-tree folders (RawPath ancestry). null = none. + /// The raw-tree devices (RawPath ancestry). null = none. + /// The raw-tree tag-groups (RawPath ancestry). null = none. /// The composition result. public static AddressSpaceComposition Compose( IReadOnlyList unsAreas, @@ -323,7 +328,12 @@ public static class AddressSpaceComposer IReadOnlyList driverInstances, IReadOnlyList scriptedAlarms, IReadOnlyList? virtualTags = null, - IReadOnlyList