CommunicationMonitorViewModel.cs

이 파일의 문서화 페이지로 가기

using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Text;
using System.Windows.Input;
using Dreamine.Communication.Abstractions.Enums;
using Dreamine.Communication.Abstractions.Models;
using Dreamine.Communication.Wpf.Commands;
using Dreamine.Communication.Wpf.Models;
 
namespace Dreamine.Communication.Wpf.ViewModels;

public sealed class CommunicationMonitorViewModel : INotifyPropertyChanged
{
    private CommunicationChannelViewItem? _selectedChannel;

    public CommunicationMonitorViewModel()
    {
        ClearLogsCommand = new DelegateCommand(_ => ClearLogs());
    }

    public event PropertyChangedEventHandler? PropertyChanged;

    public ObservableCollection<CommunicationChannelViewItem> Channels { get; } = new();

    public ObservableCollection<CommunicationMessageLogItem> Logs { get; } = new();

    public CommunicationChannelViewItem? SelectedChannel
    {
        get => _selectedChannel;
        set => SetProperty(ref _selectedChannel, value);
    }

    public ICommand ClearLogsCommand { get; }

    public void AddChannel(string name, TransportKind kind, string description = "")
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(name);
 
        if (Channels.Any(x => x.Name == name))
        {
            return;
        }
 
        Channels.Add(new CommunicationChannelViewItem
        {
            Name = name,
            Kind = kind,
            State = ConnectionState.Disconnected,
            Description = description
        });
    }

    public void UpdateChannelState(string name, ConnectionState state)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(name);
 
        var channel = Channels.FirstOrDefault(x => x.Name == name);
 
        if (channel is null)
        {
            return;
        }
 
        channel.State = state;
    }

    public void UpdateChannelDescription(string name, string description)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(name);
 
        var channel = Channels.FirstOrDefault(x => x.Name == name);
 
        if (channel is null)
        {
            return;
        }
 
        channel.Description = description ?? string.Empty;
    }

    public void AddSendLog(string channelName, TransportKind kind, MessageEnvelope message)
    {
        AddMessageLog(channelName, kind, "SEND", message);
    }

    public void AddReceiveLog(string channelName, TransportKind kind, MessageEnvelope message)
    {
        AddMessageLog(channelName, kind, "RECV", message);
    }

    public void ClearLogs()
    {
        Logs.Clear();
    }

    private void AddMessageLog(
        string channelName,
        TransportKind kind,
        string direction,
        MessageEnvelope message)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(channelName);
        ArgumentNullException.ThrowIfNull(message);
 
        Logs.Insert(0, new CommunicationMessageLogItem
        {
            ChannelName = channelName,
            Kind = kind,
            Direction = direction,
            MessageName = message.Name,
            Route = message.Route,
            PayloadLength = message.Payload.Length,
            PayloadPreview = CreatePayloadPreview(message.Payload)
        });
    }

    private static string CreatePayloadPreview(byte[] payload)
    {
        if (payload.Length == 0)
        {
            return string.Empty;
        }
 
        var text = Encoding.UTF8.GetString(payload);
 
        if (text.Length <= 120)
        {
            return text;
        }
 
        return text[..120] + "...";
    }

    private void SetProperty<T>(
        ref T storage,
        T value,
        [CallerMemberName] string? propertyName = null)
    {
        if (EqualityComparer<T>.Default.Equals(storage, value))
        {
            return;
        }
 
        storage = value;
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}