Add cross-platform OPC UA client stack: shared library, CLI tool, and Avalonia UI

Implements Client.Shared (IOpcUaClientService with connection lifecycle, failover,
browse, read/write, subscriptions, alarms, history, redundancy), Client.CLI (8 CliFx
commands mirroring tools/opcuacli-dotnet), and Client.UI (Avalonia desktop app with
tree browser, read/write, subscriptions, alarms, and history tabs). All three target
.NET 10 and are covered by 249 unit tests.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Joseph Doherty
2026-03-30 15:49:42 -04:00
parent 50b85d41bd
commit a2883b82d9
109 changed files with 8571 additions and 0 deletions

View File

@@ -0,0 +1,38 @@
using CommunityToolkit.Mvvm.ComponentModel;
namespace ZB.MOM.WW.LmxOpcUa.Client.UI.ViewModels;
/// <summary>
/// Represents a single alarm event row.
/// </summary>
public partial class AlarmEventViewModel : ObservableObject
{
public string SourceName { get; }
public string ConditionName { get; }
public ushort Severity { get; }
public string Message { get; }
public bool Retain { get; }
public bool ActiveState { get; }
public bool AckedState { get; }
public DateTime Time { get; }
public AlarmEventViewModel(
string sourceName,
string conditionName,
ushort severity,
string message,
bool retain,
bool activeState,
bool ackedState,
DateTime time)
{
SourceName = sourceName;
ConditionName = conditionName;
Severity = severity;
Message = message;
Retain = retain;
ActiveState = activeState;
AckedState = ackedState;
Time = time;
}
}

View File

@@ -0,0 +1,128 @@
using System.Collections.ObjectModel;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Opc.Ua;
using ZB.MOM.WW.LmxOpcUa.Client.Shared;
using ZB.MOM.WW.LmxOpcUa.Client.Shared.Models;
using ZB.MOM.WW.LmxOpcUa.Client.UI.Services;
namespace ZB.MOM.WW.LmxOpcUa.Client.UI.ViewModels;
/// <summary>
/// ViewModel for the alarms panel.
/// </summary>
public partial class AlarmsViewModel : ObservableObject
{
private readonly IOpcUaClientService _service;
private readonly IUiDispatcher _dispatcher;
/// <summary>Received alarm events.</summary>
public ObservableCollection<AlarmEventViewModel> AlarmEvents { get; } = new();
[ObservableProperty]
private string? _monitoredNodeIdText;
[ObservableProperty]
private int _interval = 1000;
[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(SubscribeCommand))]
[NotifyCanExecuteChangedFor(nameof(UnsubscribeCommand))]
[NotifyCanExecuteChangedFor(nameof(RefreshCommand))]
private bool _isSubscribed;
[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(SubscribeCommand))]
[NotifyCanExecuteChangedFor(nameof(UnsubscribeCommand))]
[NotifyCanExecuteChangedFor(nameof(RefreshCommand))]
private bool _isConnected;
public AlarmsViewModel(IOpcUaClientService service, IUiDispatcher dispatcher)
{
_service = service;
_dispatcher = dispatcher;
_service.AlarmEvent += OnAlarmEvent;
}
private void OnAlarmEvent(object? sender, AlarmEventArgs e)
{
_dispatcher.Post(() =>
{
AlarmEvents.Add(new AlarmEventViewModel(
e.SourceName,
e.ConditionName,
e.Severity,
e.Message,
e.Retain,
e.ActiveState,
e.AckedState,
e.Time));
});
}
private bool CanSubscribe() => IsConnected && !IsSubscribed;
[RelayCommand(CanExecute = nameof(CanSubscribe))]
private async Task SubscribeAsync()
{
try
{
NodeId? sourceNodeId = string.IsNullOrWhiteSpace(MonitoredNodeIdText)
? null
: NodeId.Parse(MonitoredNodeIdText);
await _service.SubscribeAlarmsAsync(sourceNodeId, Interval);
IsSubscribed = true;
}
catch
{
// Subscribe failed
}
}
private bool CanUnsubscribe() => IsConnected && IsSubscribed;
[RelayCommand(CanExecute = nameof(CanUnsubscribe))]
private async Task UnsubscribeAsync()
{
try
{
await _service.UnsubscribeAlarmsAsync();
IsSubscribed = false;
}
catch
{
// Unsubscribe failed
}
}
[RelayCommand(CanExecute = nameof(CanUnsubscribe))]
private async Task RefreshAsync()
{
try
{
await _service.RequestConditionRefreshAsync();
}
catch
{
// Refresh failed
}
}
/// <summary>
/// Clears alarm events and resets state.
/// </summary>
public void Clear()
{
AlarmEvents.Clear();
IsSubscribed = false;
}
/// <summary>
/// Unhooks event handlers from the service.
/// </summary>
public void Teardown()
{
_service.AlarmEvent -= OnAlarmEvent;
}
}

View File

@@ -0,0 +1,55 @@
using System.Collections.ObjectModel;
using CommunityToolkit.Mvvm.ComponentModel;
using ZB.MOM.WW.LmxOpcUa.Client.Shared;
using ZB.MOM.WW.LmxOpcUa.Client.UI.Services;
namespace ZB.MOM.WW.LmxOpcUa.Client.UI.ViewModels;
/// <summary>
/// ViewModel for the OPC UA browse tree panel.
/// </summary>
public partial class BrowseTreeViewModel : ObservableObject
{
private readonly IOpcUaClientService _service;
private readonly IUiDispatcher _dispatcher;
/// <summary>Top-level nodes in the browse tree.</summary>
public ObservableCollection<TreeNodeViewModel> RootNodes { get; } = new();
public BrowseTreeViewModel(IOpcUaClientService service, IUiDispatcher dispatcher)
{
_service = service;
_dispatcher = dispatcher;
}
/// <summary>
/// Loads root nodes by browsing with a null parent.
/// </summary>
public async Task LoadRootsAsync()
{
var results = await _service.BrowseAsync(null);
_dispatcher.Post(() =>
{
RootNodes.Clear();
foreach (var result in results)
{
RootNodes.Add(new TreeNodeViewModel(
result.NodeId,
result.DisplayName,
result.NodeClass,
result.HasChildren,
_service,
_dispatcher));
}
});
}
/// <summary>
/// Clears all root nodes from the tree.
/// </summary>
public void Clear()
{
RootNodes.Clear();
}
}

View File

@@ -0,0 +1,22 @@
using CommunityToolkit.Mvvm.ComponentModel;
namespace ZB.MOM.WW.LmxOpcUa.Client.UI.ViewModels;
/// <summary>
/// Represents a single historical value row.
/// </summary>
public partial class HistoryValueViewModel : ObservableObject
{
public string Value { get; }
public string Status { get; }
public string SourceTimestamp { get; }
public string ServerTimestamp { get; }
public HistoryValueViewModel(string value, string status, string sourceTimestamp, string serverTimestamp)
{
Value = value;
Status = status;
SourceTimestamp = sourceTimestamp;
ServerTimestamp = serverTimestamp;
}
}

View File

@@ -0,0 +1,140 @@
using System.Collections.ObjectModel;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Opc.Ua;
using ZB.MOM.WW.LmxOpcUa.Client.Shared;
using ZB.MOM.WW.LmxOpcUa.Client.Shared.Models;
using ZB.MOM.WW.LmxOpcUa.Client.UI.Services;
namespace ZB.MOM.WW.LmxOpcUa.Client.UI.ViewModels;
/// <summary>
/// ViewModel for the history panel.
/// </summary>
public partial class HistoryViewModel : ObservableObject
{
private readonly IOpcUaClientService _service;
private readonly IUiDispatcher _dispatcher;
[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(ReadHistoryCommand))]
private string? _selectedNodeId;
[ObservableProperty]
private DateTimeOffset _startTime = DateTimeOffset.UtcNow.AddHours(-1);
[ObservableProperty]
private DateTimeOffset _endTime = DateTimeOffset.UtcNow;
[ObservableProperty]
private int _maxValues = 1000;
[ObservableProperty]
private AggregateType? _selectedAggregateType;
/// <summary>Available aggregate types (null means "Raw").</summary>
public IReadOnlyList<AggregateType?> AggregateTypes { get; } = new AggregateType?[]
{
null,
AggregateType.Average,
AggregateType.Minimum,
AggregateType.Maximum,
AggregateType.Count,
AggregateType.Start,
AggregateType.End
};
[ObservableProperty]
private double _intervalMs = 3600000;
public bool IsAggregateRead => SelectedAggregateType != null;
[ObservableProperty]
private bool _isLoading;
[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(ReadHistoryCommand))]
private bool _isConnected;
/// <summary>History read results.</summary>
public ObservableCollection<HistoryValueViewModel> Results { get; } = new();
public HistoryViewModel(IOpcUaClientService service, IUiDispatcher dispatcher)
{
_service = service;
_dispatcher = dispatcher;
}
partial void OnSelectedAggregateTypeChanged(AggregateType? value)
{
OnPropertyChanged(nameof(IsAggregateRead));
}
private bool CanReadHistory() => IsConnected && !string.IsNullOrEmpty(SelectedNodeId);
[RelayCommand(CanExecute = nameof(CanReadHistory))]
private async Task ReadHistoryAsync()
{
if (string.IsNullOrEmpty(SelectedNodeId)) return;
IsLoading = true;
_dispatcher.Post(() => Results.Clear());
try
{
var nodeId = NodeId.Parse(SelectedNodeId);
IReadOnlyList<DataValue> values;
if (SelectedAggregateType != null)
{
values = await _service.HistoryReadAggregateAsync(
nodeId,
StartTime.UtcDateTime,
EndTime.UtcDateTime,
SelectedAggregateType.Value,
IntervalMs);
}
else
{
values = await _service.HistoryReadRawAsync(
nodeId,
StartTime.UtcDateTime,
EndTime.UtcDateTime,
MaxValues);
}
_dispatcher.Post(() =>
{
foreach (var dv in values)
{
Results.Add(new HistoryValueViewModel(
dv.Value?.ToString() ?? "(null)",
dv.StatusCode.ToString(),
dv.SourceTimestamp.ToString("O"),
dv.ServerTimestamp.ToString("O")));
}
});
}
catch (Exception ex)
{
_dispatcher.Post(() =>
{
Results.Add(new HistoryValueViewModel(
$"Error: {ex.Message}", string.Empty, string.Empty, string.Empty));
});
}
finally
{
_dispatcher.Post(() => IsLoading = false);
}
}
/// <summary>
/// Clears results and resets state.
/// </summary>
public void Clear()
{
Results.Clear();
SelectedNodeId = null;
}
}

View File

@@ -0,0 +1,198 @@
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using ZB.MOM.WW.LmxOpcUa.Client.Shared;
using ZB.MOM.WW.LmxOpcUa.Client.Shared.Models;
using ZB.MOM.WW.LmxOpcUa.Client.UI.Services;
namespace ZB.MOM.WW.LmxOpcUa.Client.UI.ViewModels;
/// <summary>
/// Main window ViewModel coordinating all panels.
/// </summary>
public partial class MainWindowViewModel : ObservableObject
{
private readonly IOpcUaClientService _service;
private readonly IUiDispatcher _dispatcher;
[ObservableProperty]
private string _endpointUrl = "opc.tcp://localhost:4840";
[ObservableProperty]
private string? _username;
[ObservableProperty]
private string? _password;
[ObservableProperty]
private SecurityMode _selectedSecurityMode = SecurityMode.None;
/// <summary>All available security modes.</summary>
public IReadOnlyList<SecurityMode> SecurityModes { get; } = Enum.GetValues<SecurityMode>();
[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(ConnectCommand))]
[NotifyCanExecuteChangedFor(nameof(DisconnectCommand))]
private ConnectionState _connectionState = ConnectionState.Disconnected;
public bool IsConnected => ConnectionState == ConnectionState.Connected;
[ObservableProperty]
private TreeNodeViewModel? _selectedTreeNode;
[ObservableProperty]
private RedundancyInfo? _redundancyInfo;
[ObservableProperty]
private string _statusMessage = "Disconnected";
[ObservableProperty]
private string _sessionLabel = string.Empty;
[ObservableProperty]
private int _subscriptionCount;
public BrowseTreeViewModel BrowseTree { get; }
public ReadWriteViewModel ReadWrite { get; }
public SubscriptionsViewModel Subscriptions { get; }
public AlarmsViewModel Alarms { get; }
public HistoryViewModel History { get; }
public MainWindowViewModel(IOpcUaClientServiceFactory factory, IUiDispatcher dispatcher)
{
_service = factory.Create();
_dispatcher = dispatcher;
BrowseTree = new BrowseTreeViewModel(_service, dispatcher);
ReadWrite = new ReadWriteViewModel(_service, dispatcher);
Subscriptions = new SubscriptionsViewModel(_service, dispatcher);
Alarms = new AlarmsViewModel(_service, dispatcher);
History = new HistoryViewModel(_service, dispatcher);
_service.ConnectionStateChanged += OnConnectionStateChanged;
}
private void OnConnectionStateChanged(object? sender, ConnectionStateChangedEventArgs e)
{
_dispatcher.Post(() =>
{
ConnectionState = e.NewState;
});
}
partial void OnConnectionStateChanged(ConnectionState value)
{
OnPropertyChanged(nameof(IsConnected));
var connected = value == ConnectionState.Connected;
ReadWrite.IsConnected = connected;
Subscriptions.IsConnected = connected;
Alarms.IsConnected = connected;
History.IsConnected = connected;
switch (value)
{
case ConnectionState.Connected:
StatusMessage = $"Connected to {EndpointUrl}";
break;
case ConnectionState.Reconnecting:
StatusMessage = "Reconnecting...";
break;
case ConnectionState.Connecting:
StatusMessage = "Connecting...";
break;
case ConnectionState.Disconnected:
StatusMessage = "Disconnected";
SessionLabel = string.Empty;
RedundancyInfo = null;
BrowseTree.Clear();
ReadWrite.Clear();
Subscriptions.Clear();
Alarms.Clear();
History.Clear();
SubscriptionCount = 0;
break;
}
}
partial void OnSelectedTreeNodeChanged(TreeNodeViewModel? value)
{
ReadWrite.SelectedNodeId = value?.NodeId;
History.SelectedNodeId = value?.NodeId;
}
private bool CanConnect() => ConnectionState == ConnectionState.Disconnected;
[RelayCommand(CanExecute = nameof(CanConnect))]
private async Task ConnectAsync()
{
try
{
ConnectionState = ConnectionState.Connecting;
StatusMessage = "Connecting...";
var settings = new ConnectionSettings
{
EndpointUrl = EndpointUrl,
Username = Username,
Password = Password,
SecurityMode = SelectedSecurityMode
};
settings.Validate();
var info = await _service.ConnectAsync(settings);
_dispatcher.Post(() =>
{
ConnectionState = ConnectionState.Connected;
SessionLabel = $"{info.ServerName} | Session: {info.SessionName} ({info.SessionId})";
});
// Load redundancy info
try
{
var redundancy = await _service.GetRedundancyInfoAsync();
_dispatcher.Post(() => RedundancyInfo = redundancy);
}
catch
{
// Redundancy info not available
}
// Load root nodes
await BrowseTree.LoadRootsAsync();
}
catch (Exception ex)
{
_dispatcher.Post(() =>
{
ConnectionState = ConnectionState.Disconnected;
StatusMessage = $"Connection failed: {ex.Message}";
});
}
}
private bool CanDisconnect() => ConnectionState == ConnectionState.Connected
|| ConnectionState == ConnectionState.Reconnecting;
[RelayCommand(CanExecute = nameof(CanDisconnect))]
private async Task DisconnectAsync()
{
try
{
Subscriptions.Teardown();
Alarms.Teardown();
await _service.DisconnectAsync();
}
catch
{
// Best-effort disconnect
}
finally
{
_dispatcher.Post(() =>
{
ConnectionState = ConnectionState.Disconnected;
});
}
}
}

View File

@@ -0,0 +1,136 @@
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Opc.Ua;
using ZB.MOM.WW.LmxOpcUa.Client.Shared;
using ZB.MOM.WW.LmxOpcUa.Client.UI.Services;
namespace ZB.MOM.WW.LmxOpcUa.Client.UI.ViewModels;
/// <summary>
/// ViewModel for the read/write panel.
/// </summary>
public partial class ReadWriteViewModel : ObservableObject
{
private readonly IOpcUaClientService _service;
private readonly IUiDispatcher _dispatcher;
[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(ReadCommand))]
[NotifyCanExecuteChangedFor(nameof(WriteCommand))]
private string? _selectedNodeId;
[ObservableProperty]
private string? _currentValue;
[ObservableProperty]
private string? _currentStatus;
[ObservableProperty]
private string? _sourceTimestamp;
[ObservableProperty]
private string? _serverTimestamp;
[ObservableProperty]
private string? _writeValue;
[ObservableProperty]
private string? _writeStatus;
[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(ReadCommand))]
[NotifyCanExecuteChangedFor(nameof(WriteCommand))]
private bool _isConnected;
public bool IsNodeSelected => !string.IsNullOrEmpty(SelectedNodeId);
public ReadWriteViewModel(IOpcUaClientService service, IUiDispatcher dispatcher)
{
_service = service;
_dispatcher = dispatcher;
}
partial void OnSelectedNodeIdChanged(string? value)
{
OnPropertyChanged(nameof(IsNodeSelected));
if (!string.IsNullOrEmpty(value) && IsConnected)
{
_ = ExecuteReadAsync();
}
}
private bool CanReadOrWrite() => IsConnected && !string.IsNullOrEmpty(SelectedNodeId);
[RelayCommand(CanExecute = nameof(CanReadOrWrite))]
private async Task ReadAsync()
{
await ExecuteReadAsync();
}
private async Task ExecuteReadAsync()
{
if (string.IsNullOrEmpty(SelectedNodeId)) return;
try
{
var nodeId = NodeId.Parse(SelectedNodeId);
var dataValue = await _service.ReadValueAsync(nodeId);
_dispatcher.Post(() =>
{
CurrentValue = dataValue.Value?.ToString() ?? "(null)";
CurrentStatus = dataValue.StatusCode.ToString();
SourceTimestamp = dataValue.SourceTimestamp.ToString("O");
ServerTimestamp = dataValue.ServerTimestamp.ToString("O");
});
}
catch (Exception ex)
{
_dispatcher.Post(() =>
{
CurrentValue = null;
CurrentStatus = $"Error: {ex.Message}";
SourceTimestamp = null;
ServerTimestamp = null;
});
}
}
[RelayCommand(CanExecute = nameof(CanReadOrWrite))]
private async Task WriteAsync()
{
if (string.IsNullOrEmpty(SelectedNodeId) || WriteValue == null) return;
try
{
var nodeId = NodeId.Parse(SelectedNodeId);
var statusCode = await _service.WriteValueAsync(nodeId, WriteValue);
_dispatcher.Post(() =>
{
WriteStatus = statusCode.ToString();
});
}
catch (Exception ex)
{
_dispatcher.Post(() =>
{
WriteStatus = $"Error: {ex.Message}";
});
}
}
/// <summary>
/// Clears all displayed values.
/// </summary>
public void Clear()
{
SelectedNodeId = null;
CurrentValue = null;
CurrentStatus = null;
SourceTimestamp = null;
ServerTimestamp = null;
WriteValue = null;
WriteStatus = null;
}
}

View File

@@ -0,0 +1,30 @@
using CommunityToolkit.Mvvm.ComponentModel;
namespace ZB.MOM.WW.LmxOpcUa.Client.UI.ViewModels;
/// <summary>
/// Represents a single active subscription row.
/// </summary>
public partial class SubscriptionItemViewModel : ObservableObject
{
/// <summary>The monitored NodeId.</summary>
public string NodeId { get; }
/// <summary>The subscription interval in milliseconds.</summary>
public int IntervalMs { get; }
[ObservableProperty]
private string? _value;
[ObservableProperty]
private string? _status;
[ObservableProperty]
private string? _timestamp;
public SubscriptionItemViewModel(string nodeId, int intervalMs)
{
NodeId = nodeId;
IntervalMs = intervalMs;
}
}

View File

@@ -0,0 +1,133 @@
using System.Collections.ObjectModel;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Opc.Ua;
using ZB.MOM.WW.LmxOpcUa.Client.Shared;
using ZB.MOM.WW.LmxOpcUa.Client.Shared.Models;
using ZB.MOM.WW.LmxOpcUa.Client.UI.Services;
namespace ZB.MOM.WW.LmxOpcUa.Client.UI.ViewModels;
/// <summary>
/// ViewModel for the subscriptions panel.
/// </summary>
public partial class SubscriptionsViewModel : ObservableObject
{
private readonly IOpcUaClientService _service;
private readonly IUiDispatcher _dispatcher;
/// <summary>Currently active subscriptions.</summary>
public ObservableCollection<SubscriptionItemViewModel> ActiveSubscriptions { get; } = new();
[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(AddSubscriptionCommand))]
private string? _newNodeIdText;
[ObservableProperty]
private int _newInterval = 1000;
[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(AddSubscriptionCommand))]
[NotifyCanExecuteChangedFor(nameof(RemoveSubscriptionCommand))]
private bool _isConnected;
[ObservableProperty]
private int _subscriptionCount;
[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(RemoveSubscriptionCommand))]
private SubscriptionItemViewModel? _selectedSubscription;
public SubscriptionsViewModel(IOpcUaClientService service, IUiDispatcher dispatcher)
{
_service = service;
_dispatcher = dispatcher;
_service.DataChanged += OnDataChanged;
}
private void OnDataChanged(object? sender, DataChangedEventArgs e)
{
_dispatcher.Post(() =>
{
foreach (var item in ActiveSubscriptions)
{
if (item.NodeId == e.NodeId)
{
item.Value = e.Value.Value?.ToString() ?? "(null)";
item.Status = e.Value.StatusCode.ToString();
item.Timestamp = e.Value.SourceTimestamp.ToString("O");
}
}
});
}
private bool CanAddSubscription() => IsConnected && !string.IsNullOrWhiteSpace(NewNodeIdText);
[RelayCommand(CanExecute = nameof(CanAddSubscription))]
private async Task AddSubscriptionAsync()
{
if (string.IsNullOrWhiteSpace(NewNodeIdText)) return;
var nodeIdStr = NewNodeIdText;
var interval = NewInterval;
try
{
var nodeId = NodeId.Parse(nodeIdStr);
await _service.SubscribeAsync(nodeId, interval);
_dispatcher.Post(() =>
{
ActiveSubscriptions.Add(new SubscriptionItemViewModel(nodeIdStr, interval));
SubscriptionCount = ActiveSubscriptions.Count;
});
}
catch
{
// Subscription failed; no item added
}
}
private bool CanRemoveSubscription() => IsConnected && SelectedSubscription != null;
[RelayCommand(CanExecute = nameof(CanRemoveSubscription))]
private async Task RemoveSubscriptionAsync()
{
if (SelectedSubscription == null) return;
var item = SelectedSubscription;
try
{
var nodeId = NodeId.Parse(item.NodeId);
await _service.UnsubscribeAsync(nodeId);
_dispatcher.Post(() =>
{
ActiveSubscriptions.Remove(item);
SubscriptionCount = ActiveSubscriptions.Count;
});
}
catch
{
// Unsubscribe failed
}
}
/// <summary>
/// Clears all subscriptions and resets state.
/// </summary>
public void Clear()
{
ActiveSubscriptions.Clear();
SubscriptionCount = 0;
}
/// <summary>
/// Unhooks event handlers from the service.
/// </summary>
public void Teardown()
{
_service.DataChanged -= OnDataChanged;
}
}

View File

@@ -0,0 +1,122 @@
using System.Collections.ObjectModel;
using CommunityToolkit.Mvvm.ComponentModel;
using Opc.Ua;
using ZB.MOM.WW.LmxOpcUa.Client.Shared;
using ZB.MOM.WW.LmxOpcUa.Client.UI.Services;
namespace ZB.MOM.WW.LmxOpcUa.Client.UI.ViewModels;
/// <summary>
/// Represents a single node in the OPC UA browse tree with lazy-load support.
/// </summary>
public partial class TreeNodeViewModel : ObservableObject
{
private static readonly TreeNodeViewModel PlaceholderSentinel = new();
private readonly IOpcUaClientService? _service;
private readonly IUiDispatcher? _dispatcher;
private bool _hasLoadedChildren;
/// <summary>The string NodeId of this node.</summary>
public string NodeId { get; }
/// <summary>The display name shown in the tree.</summary>
public string DisplayName { get; }
/// <summary>The OPC UA node class (Object, Variable, etc.).</summary>
public string NodeClass { get; }
/// <summary>Whether this node has child references.</summary>
public bool HasChildren { get; }
/// <summary>Child nodes (may contain a placeholder sentinel before first expand).</summary>
public ObservableCollection<TreeNodeViewModel> Children { get; } = new();
[ObservableProperty]
private bool _isExpanded;
[ObservableProperty]
private bool _isLoading;
/// <summary>
/// Private constructor for the placeholder sentinel only.
/// </summary>
private TreeNodeViewModel()
{
NodeId = string.Empty;
DisplayName = "Loading...";
NodeClass = string.Empty;
HasChildren = false;
}
public TreeNodeViewModel(
string nodeId,
string displayName,
string nodeClass,
bool hasChildren,
IOpcUaClientService service,
IUiDispatcher dispatcher)
{
NodeId = nodeId;
DisplayName = displayName;
NodeClass = nodeClass;
HasChildren = hasChildren;
_service = service;
_dispatcher = dispatcher;
if (hasChildren)
{
Children.Add(PlaceholderSentinel);
}
}
partial void OnIsExpandedChanged(bool value)
{
if (value && !_hasLoadedChildren && HasChildren)
{
_ = LoadChildrenAsync();
}
}
private async Task LoadChildrenAsync()
{
if (_service == null || _dispatcher == null) return;
_hasLoadedChildren = true;
IsLoading = true;
try
{
var nodeId = Opc.Ua.NodeId.Parse(NodeId);
var results = await _service.BrowseAsync(nodeId);
_dispatcher.Post(() =>
{
Children.Clear();
foreach (var result in results)
{
Children.Add(new TreeNodeViewModel(
result.NodeId,
result.DisplayName,
result.NodeClass,
result.HasChildren,
_service,
_dispatcher));
}
});
}
catch
{
_dispatcher.Post(() => Children.Clear());
}
finally
{
_dispatcher.Post(() => IsLoading = false);
}
}
/// <summary>
/// Returns whether this node instance is the placeholder sentinel.
/// </summary>
internal bool IsPlaceholder => ReferenceEquals(this, PlaceholderSentinel);
}