feat(uns): equipment CSV import folded into the tree toolbar

2026-06-08 13:56:01 -04:00
parent c0346f14ce
commit 7db9a24403
5 changed files with 515 additions and 1 deletions
@@ -21,7 +21,7 @@
                   @bind="_filter" @bind:event="oninput" />
            <button type="button" class="btn btn-outline-secondary btn-sm" @onclick="ExpandAll">Expand all</button>
            <button type="button" class="btn btn-outline-secondary btn-sm" @onclick="CollapseAll">Collapse all</button>
-            <button type="button" class="btn btn-outline-primary btn-sm" disabled>Import equipment CSV</button>
+            <button type="button" class="btn btn-outline-primary btn-sm" @onclick="OpenImportModal">Import equipment CSV</button>
        </div>
    </div>

@@ -89,6 +89,10 @@
                 OnSaved="OnEquipmentChildModalSavedAsync"
                 OnCancel="CloseModals" />

+<ImportEquipmentModal Visible="_importModalVisible"
+                      OnImported="OnImportedAsync"
+                      OnCancel="CloseModals" />
+
@if (_confirmNode is not null)
 {
    <div class="modal-backdrop fade show" style="display:block"></div>
@@ -158,6 +162,9 @@
    private VirtualTagEditDto? _vtagModalExisting;
    private IReadOnlyList<(string Id, string Display)> _vtagModalScriptOptions = Array.Empty<(string, string)>();

+    // --- Import-equipment-CSV modal state ---
+    private bool _importModalVisible;
+
    // --- Owning equipment to refresh in place after a tag/virtual-tag mutation ---
    private string? _childRefreshEquipmentId;

@@ -357,6 +364,24 @@
        }
    }

+    /// <summary>Opens the bulk equipment-CSV import modal.</summary>
+    private void OpenImportModal()
+    {
+        CloseModals();
+        _importModalVisible = true;
+    }
+
+    /// <summary>
+    /// Handles the import modal's close after a run. A bulk import can add equipment across many
+    /// lines and clusters, so the whole structural tree is reloaded rather than refreshed in place.
+    /// </summary>
+    private async Task OnImportedAsync()
+    {
+        _roots = await Svc.LoadStructureAsync();
+        CloseModals();
+        StateHasChanged();
+    }
+
    /// <summary>Opens the delete-confirm modal for a node, stashing it as the pending target.</summary>
    private void HandleDelete(UnsNode node)
    {
@@ -549,6 +574,7 @@
        _vtagModalExisting = null;
        _vtagModalEquipmentId = null;
        _vtagModalScriptOptions = Array.Empty<(string, string)>();
+        _importModalVisible = false;
        _childRefreshEquipmentId = null;
        _confirmNode = null;
        _confirmError = null;
@@ -0,0 +1,187 @@
+@* Bulk equipment import modal wired straight into IUnsTreeService. Paste a CSV (header + rows),
+   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.
+   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. *@
+@using ZB.MOM.WW.OtOpcUa.AdminUI.Uns
+@inject IUnsTreeService Svc
+
+@if (Visible)
+{
+    <div class="modal-backdrop fade show" style="display:block"></div>
+    <div class="modal fade show" tabindex="-1" role="dialog" style="display:block">
+        <div class="modal-dialog modal-lg" role="document">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">Import equipment CSV</h5>
+                    <button type="button" class="btn-close" aria-label="Close" @onclick="CloseAsync"></button>
+                </div>
+                <div class="modal-body">
+                    <p class="text-muted small mb-2">
+                        Paste CSV below. Required header columns (in order):
+                        <span class="mono">Name, MachineCode, UnsLineId, DriverInstanceId</span>.
+                        Optional: <span class="mono">ZTag, SAPID, Manufacturer, Model</span>.
+                        Each row inserts one equipment with a freshly-generated EquipmentId. Existing rows
+                        are detected by MachineCode and skipped (additive-only — no updates).
+                    </p>
+
+                    <textarea class="form-control form-control-sm mono" rows="12"
+                              @bind="_csv" @bind:event="oninput" disabled="@_busy"
+                              placeholder="Name,MachineCode,UnsLineId,DriverInstanceId,ZTag,SAPID,Manufacturer,Model&#10;mixer-01,MX_001,LINE-1,drv-modbus-01,ZT-12345,SAP-9876,Siemens,SIMATIC-1500"></textarea>
+
+                    @if (!string.IsNullOrWhiteSpace(_parseError))
+                    {
+                        <div class="text-danger small mt-2">@_parseError</div>
+                    }
+
+                    @if (_result is not null)
+                    {
+                        <div class="alert alert-info mt-3 mb-0" role="alert">
+                            <div>
+                                <strong>Inserted:</strong> @_result.Inserted
+                                &middot; <strong>Skipped (existing MachineCode):</strong> @_result.Skipped
+                                &middot; <strong>Errors:</strong> @_result.Errors.Count
+                            </div>
+                            @if (_result.Errors.Count > 0)
+                            {
+                                <ul class="small mb-0 mt-2">
+                                    @foreach (var err in _result.Errors)
+                                    {
+                                        <li>@err</li>
+                                    }
+                                </ul>
+                            }
+                        </div>
+                    }
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-outline-secondary" @onclick="CloseAsync" disabled="@_busy">
+                        @(_result is null ? "Cancel" : "Close")
+                    </button>
+                    <button type="button" class="btn btn-primary" @onclick="ImportAsync" disabled="@_busy">
+                        @if (_busy) { <span class="spinner-border spinner-border-sm me-1"></span> }
+                        Import
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+}
+
+@code {
+    // Required, in order; DriverInstanceId may be left blank per row (driver-less equipment).
+    private static readonly string[] RequiredColumns = ["Name", "MachineCode", "UnsLineId", "DriverInstanceId"];
+
+    /// <summary>Whether the modal is shown. The host owns this flag.</summary>
+    [Parameter] public bool Visible { get; set; }
+
+    /// <summary>
+    /// Raised when the user closes the modal after an import so the host can reload the tree and
+    /// dismiss the modal. Fired on close regardless of whether anything was inserted — closing always
+    /// returns control to the host.
+    /// </summary>
+    [Parameter] public EventCallback OnImported { get; set; }
+
+    /// <summary>Raised when the user cancels before importing so the host can close.</summary>
+    [Parameter] public EventCallback OnCancel { get; set; }
+
+    private string _csv = "";
+    private bool _busy;
+    private string? _parseError;
+    private EquipmentImportResult? _result;
+
+    protected override void OnParametersSet()
+    {
+        // Reset the working state each time the host (re)opens the modal.
+        if (!Visible)
+        {
+            _csv = "";
+            _parseError = null;
+            _result = null;
+        }
+    }
+
+    private async Task ImportAsync()
+    {
+        _busy = true;
+        _parseError = null;
+        _result = null;
+        try
+        {
+            var rows = ParseCsv(_csv);
+            if (rows is null) { return; }
+
+            _result = await Svc.ImportEquipmentAsync(rows);
+        }
+        finally
+        {
+            _busy = false;
+        }
+    }
+
+    /// <summary>
+    /// Closes the modal. Once an import has run (the user has seen the summary), closing raises
+    /// OnImported so the host reloads the tree; before any import it raises OnCancel.
+    /// </summary>
+    private Task CloseAsync() =>
+        _result is not null ? OnImported.InvokeAsync() : OnCancel.InvokeAsync();
+
+    /// <summary>
+    /// Parses the pasted CSV into <see cref="EquipmentInput"/> rows. Requires a header row whose first
+    /// four columns are Name, MachineCode, UnsLineId, DriverInstanceId (case-insensitive); the optional
+    /// ZTag/SAPID/Manufacturer/Model follow. Blank optional cells parse as <c>null</c>. Returns
+    /// <c>null</c> (and sets <see cref="_parseError"/>) when the CSV is empty or the header is wrong.
+    /// </summary>
+    private List<EquipmentInput>? ParseCsv(string csv)
+    {
+        if (string.IsNullOrWhiteSpace(csv)) { _parseError = "CSV is empty."; return null; }
+
+        var lines = csv.Replace("\r\n", "\n").Split('\n', StringSplitOptions.RemoveEmptyEntries);
+        if (lines.Length < 2) { _parseError = "Need a header row and at least one data row."; return null; }
+
+        var header = lines[0].Split(',').Select(c => c.Trim()).ToArray();
+        for (var i = 0; i < RequiredColumns.Length; i++)
+        {
+            if (i >= header.Length || !string.Equals(header[i], RequiredColumns[i], StringComparison.OrdinalIgnoreCase))
+            {
+                _parseError = $"Header column #{i + 1} must be '{RequiredColumns[i]}' (got '{(i < header.Length ? header[i] : "")}').";
+                return null;
+            }
+        }
+
+        var rows = new List<EquipmentInput>();
+        for (var lineIdx = 1; lineIdx < lines.Length; lineIdx++)
+        {
+            var parts = lines[lineIdx].Split(',').Select(c => c.Trim()).ToArray();
+            if (parts.Length < RequiredColumns.Length)
+            {
+                _parseError = $"Row {lineIdx}: too few columns (got {parts.Length}, need {RequiredColumns.Length}).";
+                return null;
+            }
+
+            rows.Add(new EquipmentInput(
+                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),
+                SerialNumber: null,
+                HardwareRevision: null,
+                SoftwareRevision: null,
+                YearOfConstruction: null,
+                AssetLocation: null,
+                ManufacturerUri: null,
+                DeviceManualUri: null,
+                Enabled: true));
+        }
+        return rows;
+    }
+
+    private static string? NullIfEmpty(string[] parts, int idx) =>
+        idx < parts.Length && !string.IsNullOrWhiteSpace(parts[idx]) ? parts[idx] : null;
+}
@@ -89,6 +89,17 @@ public sealed record TagEditDto(string TagId, string EquipmentId, string Name, s
 public sealed record VirtualTagEditDto(string VirtualTagId, string EquipmentId, string Name, string DataType, string ScriptId,
    bool ChangeTriggered, int? TimerIntervalMs, bool Historize, bool Enabled, byte[] RowVersion);

+/// <summary>
+/// The outcome of a bulk equipment CSV import: how many rows were inserted, how many were skipped
+/// (existing MachineCode — the importer is additive-only, never an update), and a per-row error list
+/// for rows that could not be inserted (unknown line, unknown driver, or a decision-#122 cluster
+/// mismatch). Skipped rows never appear in <see cref="Errors"/>.
+/// </summary>
+/// <param name="Inserted">The count of new Equipment rows added.</param>
+/// <param name="Skipped">The count of rows skipped because their MachineCode already exists.</param>
+/// <param name="Errors">The human-readable error strings for rows that failed validation.</param>
+public sealed record EquipmentImportResult(int Inserted, int Skipped, IReadOnlyList<string> Errors);
+
 /// <summary>
 /// Loads the structural portion of the unified-namespace (UNS) browse tree —
 /// Enterprise → Cluster → Area → Line → Equipment — from the config database.
@@ -258,6 +269,21 @@ public interface IUnsTreeService
    /// <returns>Success, a missing-line failure, a duplicate-MachineCode failure, or a #122 guard failure.</returns>
    Task<UnsMutationResult> CreateEquipmentAsync(EquipmentInput input, CancellationToken ct = default);

+    /// <summary>
+    /// Bulk-imports equipment from a parsed set of <see cref="EquipmentInput"/> rows in a single
+    /// context, applying the same rules as the single-add path: a row whose <c>UnsLineId</c> does not
+    /// exist is an error; a row whose <c>DriverInstanceId</c> 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 decision-#122
+    /// guard; and a row whose <c>MachineCode</c> already exists in the DB <em>or</em> earlier in the
+    /// same batch is silently skipped (additive-only — never an update). Inserted rows get a
+    /// system-generated <c>EQ-</c> id and a fresh <c>EquipmentUuid</c>. All inserts are saved once at
+    /// the end.
+    /// </summary>
+    /// <param name="rows">The parsed equipment rows to import.</param>
+    /// <param name="ct">A token to cancel the operation.</param>
+    /// <returns>The insert/skip counts and the per-row error list.</returns>
+    Task<EquipmentImportResult> ImportEquipmentAsync(IReadOnlyList<EquipmentInput> rows, CancellationToken ct = default);
+
    /// <summary>
    /// Updates an equipment's mutable fields (driver binding, line, name, MachineCode, external
    /// ids, and the OPC 40010 identification fields). The decision-#122 driver-cluster guard blocks
@@ -504,6 +504,81 @@ public sealed class UnsTreeService(IDbContextFactory<OtOpcUaConfigDbContext> dbF
        return new UnsMutationResult(true, null);
    }

+    /// <inheritdoc />
+    public async Task<EquipmentImportResult> ImportEquipmentAsync(
+        IReadOnlyList<EquipmentInput> rows,
+        CancellationToken ct = default)
+    {
+        await using var db = await dbFactory.CreateDbContextAsync(ct);
+
+        // Known lines and the MachineCodes already in the fleet, read once up front. The seen-set
+        // tracks MachineCodes inserted earlier in this same batch so two CSV rows that share a
+        // MachineCode skip the duplicate the same way the original ImportEquipment.razor did.
+        var lineSet = (await db.UnsLines.AsNoTracking().Select(l => l.UnsLineId).ToListAsync(ct))
+            .ToHashSet(StringComparer.Ordinal);
+        var existing = (await db.Equipment.AsNoTracking().Select(e => e.MachineCode).ToListAsync(ct))
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        var inserted = 0;
+        var skipped = 0;
+        var errors = new List<string>();
+
+        foreach (var row in rows)
+        {
+            // Existing MachineCode (in DB or earlier in this batch) → skip, never an error.
+            if (existing.Contains(row.MachineCode))
+            {
+                skipped++;
+                continue;
+            }
+
+            if (!lineSet.Contains(row.UnsLineId))
+            {
+                errors.Add($"Row '{row.MachineCode}': UNS line '{row.UnsLineId}' not found.");
+                continue;
+            }
+
+            // Reuse the #122 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;
+            }
+
+            var uuid = Guid.NewGuid();
+            var equipmentId = $"EQ-{uuid.ToString("N")[..12]}";
+
+            db.Equipment.Add(new Equipment
+            {
+                EquipmentId = equipmentId,
+                EquipmentUuid = uuid,
+                DriverInstanceId = string.IsNullOrWhiteSpace(row.DriverInstanceId) ? null : row.DriverInstanceId,
+                UnsLineId = row.UnsLineId,
+                Name = row.Name,
+                MachineCode = row.MachineCode,
+                ZTag = string.IsNullOrWhiteSpace(row.ZTag) ? null : row.ZTag,
+                SAPID = string.IsNullOrWhiteSpace(row.SAPID) ? null : row.SAPID,
+                Manufacturer = row.Manufacturer,
+                Model = row.Model,
+                SerialNumber = row.SerialNumber,
+                HardwareRevision = row.HardwareRevision,
+                SoftwareRevision = row.SoftwareRevision,
+                YearOfConstruction = row.YearOfConstruction,
+                AssetLocation = row.AssetLocation,
+                ManufacturerUri = row.ManufacturerUri,
+                DeviceManualUri = row.DeviceManualUri,
+                Enabled = row.Enabled,
+            });
+            existing.Add(row.MachineCode);
+            inserted++;
+        }
+
+        await db.SaveChangesAsync(ct);
+        return new EquipmentImportResult(inserted, skipped, errors);
+    }
+
    /// <inheritdoc />
    public async Task<UnsMutationResult> UpdateEquipmentAsync(
        string equipmentId,