WCS/Plugins/Wcs/Plugin.Cowain.Wcs/ViewModels/FlowManagementViewModel.cs

using Avalonia.Controls.Notifications;
using Avalonia.Platform.Storage;
using Avalonia.Threading;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Cowain.Base.Helpers;
using Cowain.Base.ViewModels;
using Ke.Bee.Localization.Localizer.Abstractions;
using Newtonsoft.Json;
using Plugin.Cowain.Wcs.IServices;
using Plugin.Cowain.Wcs.Models.Enum;
using System.Collections.ObjectModel;
using Ursa.Controls;


namespace Plugin.Cowain.Wcs.ViewModels;

public partial class FlowManagementViewModel : PageViewModelBase
{
    [ObservableProperty]
    private ObservableCollection<ProcessFlowViewModel>? _flowList;
    [ObservableProperty]
    private ObservableCollection<StationViewModel>? _stations;
    [ObservableProperty]
    private ObservableCollection<ProcessViewModel>? _process;
    [ObservableProperty]
    private int _totals;
    [ObservableProperty]
    private int _pageSize;
    [ObservableProperty]
    private int _pageIndex;

    [ObservableProperty]
    private ProcessViewModel? _selectedProcess;

    private readonly ILocalizer _l;
    private IProcessFlowService _flowService;
    private IStationService _stationService;
    private IProcessService _processService;
    private List<string> actions = new List<string>() { RgvCommandEnum.MoveFrom.ToString(), RgvCommandEnum.Pick.ToString(), RgvCommandEnum.MoveTo.ToString(), RgvCommandEnum.Place.ToString() };
    public FlowManagementViewModel(ILocalizer localizer, IProcessService processService, IProcessFlowService processFlowService, IStationService stationService)
    {
        PageSize = 20;
        _flowService = processFlowService;
        _processService = processService;
        _stationService = stationService;
        _l = localizer;
        FlowList = new ObservableCollection<ProcessFlowViewModel>();
        // 异步调用刷新
        RefreshCommand.ExecuteAsync(1);
    }
    public static List<string> StationStateList =>
                        Enum.GetNames(typeof(StationStateEnum)).ToList(); // 直接获取枚举名称字符串列表



    [RelayCommand]
    private async Task RefreshAsync(int pageIndex)
    {
        if (Stations == null)
        {
            var stationList = await _stationService.GetAllAsync();
            Stations = new ObservableCollection<StationViewModel>(stationList);
            StationViewModel nullStation = new StationViewModel { Id = 0, StationName = "Null", StationCode = "Null" };
            Stations.Insert(0, nullStation);
        }
        if (Process == null)
        {
            var processList = await _processService.GetAllAsync();
            Process = new ObservableCollection<ProcessViewModel>(processList);
        }
        var (data, count) = await _flowService.GetAllAsync(pageIndex, PageSize, SelectedProcess?.Id);
        Totals = count;
        if (count > 0)
        {
            FlowList?.Clear();
            foreach (var item in data)
            {
                FlowList?.Add(item);
            }
        }
    }

    [RelayCommand]
    private void Add()
    {
        if (SelectedProcess == null || SelectedProcess.Id == 0)
        {
            NotificationHelper.ShowNormal(NotificationType.Error, _l["FlowManagement.Edit.SelectedProcessIsNull"]);
            return;
        }
        FlowList?.Add(new ProcessFlowViewModel
        {
            ProcessId = SelectedProcess.Id,
            FromStatus1 = StationStateEnum.UnKnown.ToString(),
            ToStatus1 = StationStateEnum.UnKnown.ToString(),
            FromStatus2 = StationStateEnum.UnKnown.ToString(),
            ToStatus2 = StationStateEnum.UnKnown.ToString(),
            Action = JsonConvert.SerializeObject(actions)
        });

    }

    [RelayCommand]
    private async Task DeleteAsync(ProcessFlowViewModel? flow)
    {
        if (flow == null)
        {
            return;
        }
        var result = await MessageBox.ShowOverlayAsync(_l["DeleteDialog"], _l["Message.Info.Title"], button: MessageBoxButton.YesNo);
        if (result != MessageBoxResult.Yes)
        {
            return;
        }
        var deleteDevice = await _flowService.DeleteAsync(flow.Id);
        if (deleteDevice.IsSuccess)
        {
            NotificationHelper.ShowNormal(NotificationType.Success, _l["FlowManagement.Delete.Success"]);
            FlowList?.Remove(flow);
        }
        else
        {
            NotificationHelper.ShowNormal(NotificationType.Error, _l["FlowManagement.Delete.Error"] + ":" + deleteDevice.ErrorMessage);
        }
    }

    [RelayCommand]
    private async Task SaveAsync(ProcessFlowViewModel? flow)
    {
        if (flow == null)
        {
            return;

        }
        if (SelectedProcess == null || SelectedProcess.Id == 0)
        {
            NotificationHelper.ShowNormal(NotificationType.Error, _l["FlowManagement.Edit.SelectedProcessIsNull"]);
            return;
        }
        var result = await MessageBox.ShowOverlayAsync(_l["SaveDialog"], _l["Message.Info.Title"], button: MessageBoxButton.YesNo);
        if (result != MessageBoxResult.Yes)
        {
            return;
        }
        if (flow.Id == 0)
        {
            var add = await _flowService.AddAsync(SelectedProcess.Id, new List<ProcessFlowViewModel> { flow });
            await RefreshAsync(1);
            if (add.IsSuccess)
            {
                NotificationHelper.ShowNormal(NotificationType.Success, _l["FlowManagement.Add.Success"]);
            }
            else
            {
                NotificationHelper.ShowNormal(NotificationType.Error, _l["FlowManagement.Add.Error"]);
            }
        }
        else
        {
            var update = await _flowService.UpdateAsync(SelectedProcess.Id, new List<ProcessFlowViewModel> { flow });
            await RefreshAsync(1);
            if (update.IsSuccess)
            {
                NotificationHelper.ShowNormal(NotificationType.Success, _l["FlowManagement.Update.Success"]);
            }
            else
            {
                NotificationHelper.ShowNormal(NotificationType.Error, _l["FlowManagement.Update.Error"] + ":" + update.ErrorMessage);
            }
        }
    }

    [RelayCommand]
    private async Task ExportAsync()
    {

        var saveDialog = await FileDialogHelper.SaveFileDialogAsync(GetFileTypes());

        if (!saveDialog.IsSuccess)
        {
            return;
        }
        var flows = await _flowService.GetAllAsync();
        if (flows == null)
        {
            return;
        }
        var result = await ExcelHelper<ProcessFlowViewModel>.ExportExcelAsync(flows.ToList(), saveDialog.Data!.Path.LocalPath);
        if (result.IsSuccess)
        {
            NotificationHelper.ShowNormal(NotificationType.Success, _l["FlowManagement.Export.Success"]);
        }
        else
        {
            NotificationHelper.ShowNormal(NotificationType.Error, _l["FlowManagement.Export.Error"] + ":" + result.ErrorMessage);
        }

    }

    [RelayCommand]
    private async Task ImportAsync()
    {
        var openDialog = await FileDialogHelper.OpenFileDialogAsync(GetFileTypes());
        if (!openDialog.IsSuccess) return;
        var result = ExcelHelper<ProcessFlowViewModel>.ImportExcel(openDialog.Data!.Path.LocalPath);
        if (!result.IsSuccess)
        {
            NotificationHelper.ShowNormal(NotificationType.Error, _l["TagManagement.Import.Error"] + ":" + result.ErrorMessage);
            return;
        }
        // 使用Dispatcher确保UI线程更新
        Dispatcher.UIThread.Post(() =>
        {
            FlowList = new ObservableCollection<ProcessFlowViewModel>(result.Data!);
            OnPropertyChanged(nameof(FlowList));

        });
        NotificationHelper.ShowNormal(NotificationType.Success, _l["FlowManagement.Import.Success"]);
    }

    [RelayCommand]
    private async Task SaveAllAsync()
    {
        if (FlowList == null)
        {
            return;
        }
        if (SelectedProcess == null || SelectedProcess.Id == 0)
        {
            NotificationHelper.ShowNormal(NotificationType.Error, _l["FlowManagement.Edit.SelectedProcessIsNull"]);
            return;
        }
        var result = await MessageBox.ShowOverlayAsync(_l["SaveDialog"], _l["Message.Info.Title"], button: MessageBoxButton.YesNo);
        if (result != MessageBoxResult.Yes)
        {
            return;
        }
        var update = await _flowService.UpdateAsync(SelectedProcess.Id, FlowList.ToList());
        await RefreshAsync(1);
        if (update.IsSuccess)
        {
            NotificationHelper.ShowNormal(NotificationType.Success, _l["FlowManagement.Update.Success"]);
        }
        else
        {
            NotificationHelper.ShowNormal(NotificationType.Error, _l["FlowManagement.Update.Error"] + ":" + update.ErrorMessage);
        }
    }


    List<FilePickerFileType>? GetFileTypes()
    {
        return
        [
           new FilePickerFileType("Excel"){ Patterns=["*.xlsx"]}
        ];
    }


}