ShakerControl/ShakerManger/ViewModel/ShakerControlViewModel.cs

using HandyControl.Interactivity;
using HandyControl.Interactivity.Commands;
using OxyPlot;
using Shaker.Model;
using Shaker.ViewModel;
using ShakerManger.Data;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Security.AccessControl;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Media.Media3D;
using System.Windows.Threading;
using XamlAnimatedGif;

namespace ShakerManger.ViewModel
{
    internal class ShakerControlViewModel:Shaker.ViewModel.DisplayViewModel<Shaker.Model.ShakerControlModel>
    {
        private object locker = new object();
        public string ClientID { get => Model.ClientID; set => UpdateProperty(ref Model.ClientID, value); }
        public int MaxItemCount => 1000;
        private ObservableCollection<DataMangerItemViewModel> Items { get; } = new ObservableCollection<DataMangerItemViewModel>();

        private List<OxyPlot.Series.LineSeries> _LineSeries = new List<OxyPlot.Series.LineSeries>();

        public string[] PropertiyNames { get; }= new string[]
        {
            nameof(DataMangerItemViewModel.OperatingStatus),
            nameof(DataMangerItemViewModel.OutputCurrent),
            nameof(DataMangerItemViewModel.OutputVoltage),
            nameof(DataMangerItemViewModel.ExcitationCurrent),
            nameof(DataMangerItemViewModel.ExcitationVoltage),
            nameof(DataMangerItemViewModel.ThreePhaseVoltage),
            nameof(DataMangerItemViewModel.AbutmentTemperature0),
            nameof(DataMangerItemViewModel.AbutmentTemperature1),
            nameof(DataMangerItemViewModel.DCVoltage1),
            nameof(DataMangerItemViewModel.DCVoltage2),
            nameof(DataMangerItemViewModel.DCVoltage3),
            nameof(DataMangerItemViewModel.DCVoltage4),
            nameof(DataMangerItemViewModel.ExternalCirculatoryPressure),
            nameof(DataMangerItemViewModel.MovingCoilPressure),
            nameof(DataMangerItemViewModel.ExcitationPressure),
            nameof(DataMangerItemViewModel.OilPumpPressure),
            nameof(DataMangerItemViewModel.DynamicFlow),
            nameof(DataMangerItemViewModel.ExcitationFlow),
            nameof(DataMangerItemViewModel.MovingCoilWaterTemperature),
            nameof(DataMangerItemViewModel.ExcitationWaterTemperature),
            nameof(DataMangerItemViewModel.OilPumpTemperature),
            nameof(DataMangerItemViewModel.CoolingWaterStatus),
            nameof(DataMangerItemViewModel.Gain),
        };

        public bool ModelVisibily { get => modelVisibily; set =>UpdateProperty(ref modelVisibily,value); }
        public ICommand MenuShowCommand => new DelegateCommand<ExCommandParameter>(MenuShow);
        private void MenuShow(ExCommandParameter parameter)
        {
            if(parameter.EventArgs is MouseButtonEventArgs args)
            {
                if (args.ChangedButton == MouseButton.Right && (args.OriginalSource == null ? true :!(args.OriginalSource.GetType().FullName.Contains("Helix"))))
                {
                    MenuIsOpen = true;
                }
            }
        }
        public ICommand DisConnectCommand=> new DelegateCommand(DisConnect);
        private void DisConnect()
        {
            PromptViewModel.Default.Init();
            PromptViewModel.Default.IconType = IconType.Ask;
            PromptViewModel.Default.Message = "是否断开功放连接?";
            PromptViewModel.Default.YesAction = async ()=>
            {
                var result = await BusManger.Defaut.Bus.RPC.RequestAsync<Shaker.Model.SysControl, Shaker.Model.Result>(new SysControl()
                {
                    Cmd = SysCmd.DisConnect,
                }, Properties);
                if (result == null ||!result.Success)
                {
                    PromptViewModel.Default.Init();
                    PromptViewModel.Default.IconType = IconType.Error;
                    PromptViewModel.Default.Message = result == null? "通信超时" : result.Message;
                    PromptViewModel.Default.NoVisibility = Visibility.Collapsed;
                    PromptViewModel.Default.IsOpen = true;
                }
            };
            PromptViewModel.Default.IsOpen = true;
        }
        public ICommand ConnectCommand => new DelegateCommand(Connect);
        private async void Connect()
        {
            var result = await BusManger.Defaut.Bus.RPC.RequestAsync<Shaker.Model.SysControl, Shaker.Model.Result>(new SysControl()
            {
                Cmd = SysCmd.Connect,
            },Properties);
            if(result == null || !result.Success)
            {
                PromptViewModel.Default.Init();
                PromptViewModel.Default.IconType = IconType.Error;
                PromptViewModel.Default.Message = result == null?"通信超时": result.Message;
                PromptViewModel.Default.NoVisibility = Visibility.Collapsed;
                PromptViewModel.Default.IsOpen= true;
            }
        }
        public bool IsOnline { get => isOnline; set =>UpdateProperty(ref isOnline, value); }
        public DataMangerItemViewModel CurrentData { get => currentData; set =>UpdateProperty(ref currentData, value); }
        public Boolean SetPlotConfigIsOpen 
        {
            get => setPlotConfigIsOpen;
            set
            {
                UpdateProperty(ref setPlotConfigIsOpen, value);
                if(value)
                {
                    foreach(var item in PlotConfig)
                    {
                        item.Init();
                    }
                }
            }
        }
        public string ActiveMQClintID 
        {
            get => activeMQClintID;
            set
            {
                if (activeMQClintID == value) return;
                if(string.IsNullOrEmpty(value) || string.IsNullOrEmpty(activeMQClintID))
                {
                    activeMQClintID = value;
                }
            }
        }

        public bool MenuIsOpen { get => menuIsOpen; set =>UpdateProperty(ref menuIsOpen , value); }
        private Data.ShakerViewType lastviewType = ShakerViewType.ShakerControl;
        public Data.ShakerViewType ShakerView 
        { 
            get => shakerView;
            set
            {
                if (shakerView == value) return;
                MenuIsOpen = false;
                UpdateProperty(ref shakerView, value);
            }
        }
        public bool IsDeviceControl { get => isDeviceControl; set =>UpdateProperty(ref isDeviceControl , value); }
        public bool IsConnected 
        {
            get => isConnected;
            set
            {
                if (isConnected == value) return;
                UpdateProperty(ref isConnected, value);
                if (value)
                {
                    ShakerView = lastviewType;
                }
                else
                {
                    lastviewType = ShakerView;
                    ShakerView = ShakerViewType.None;
                }
            }
        }
        public bool StartupCompleted
        {
            get => startupCompleted;
            set
            {
                if (startupCompleted == value) return;
                UpdateProperty(ref startupCompleted, value);
                OnPropertyChanged(nameof(GainSwitchEnabled));
                if (value)
                {
                    animator?.Play();
                }
                else
                {
                    animator.Pause();
                }
            }
        }
        public bool CacheFramesInMemory { get => cacheFramesInMemory; set => UpdateProperty(ref cacheFramesInMemory, value); }
        public bool AutoStart { get => autoStart; set => UpdateProperty(ref autoStart, value); }
        [AllowNull]
        private Animator animator;

        [AllowNull]
        private Image image;


        public Image Image
        {
            get => image;
            set
            {
                image = value;
                if (animator == null && value != null) animator = AnimationBehavior.GetAnimator(value);
            }
        }
        public RepeatBehavior RepeatBehavior { get => repeatBehavior; set =>UpdateProperty(ref repeatBehavior, value); }
        public string GifPath { get => gifPath; set => UpdateProperty(ref gifPath, value); }
        private bool isVisible = false;
        private static string ModelDirectory=System.AppDomain.CurrentDomain.BaseDirectory + $"Model\\";
        public bool IsVisible { get => isVisible; set => UpdateProperty(ref isVisible, value); }
        public string[] AnalogNames { get; } = new string[Shaker.Model.DataMangerItemModel.ANALOG_DATA_LENGTH];
        public string[] Units { get; } = new string[Shaker.Model.DataMangerItemModel.ANALOG_DATA_LENGTH];
        private Dictionary<string, string> Properties { get; init; } = new Dictionary<string, string>();

        public ObservableCollection<PlotConfigViewModel> PlotConfig { get; } = new ObservableCollection<PlotConfigViewModel>();
        public int Index { get; }

        public ShakerControlViewModel(Shaker.Model.ShakerControlModel model,int index)
        {
            Index = index;
            Model = model;
            GifPath = System.AppDomain.CurrentDomain.BaseDirectory + $"\\GIF\\Shaker{index}.gif";
            ModelVisibily = File.Exists(GifPath);

            Values.Add(new PLCAnlogViewModel(model.ExcitationVoltage));
            Values.Add(new PLCAnlogViewModel(model.ExcitationCurrent)
            {
                IsVisily = false,
            });
            Values.Add(new PLCAnlogViewModel(model.ThreePhaseVoltage)
            {
                IsVisily = false,
            });
            Values.Add(new PLCAnlogViewModel(model.AbutmentTemperature0));
            Values.Add(new PLCAnlogViewModel(model.AbutmentTemperature1));
            Values.Add(new PLCAnlogViewModel(model.DCVoltage1));
            Values.Add(new PLCAnlogViewModel(model.DCVoltage2));
            Values.Add(new PLCAnlogViewModel(model.DCVoltage3));
            Values.Add(new PLCAnlogViewModel(model.DCVoltage4));

            CoolingWaterValues.Add(new PLCAnlogViewModel(model.ExternalCirculatoryPressure));
            CoolingWaterValues.Add(new PLCAnlogViewModel(model.MovingCoilPressure));
            CoolingWaterValues.Add(new PLCAnlogViewModel(model.ExcitationPressure));

            CoolingWaterValues.Add(new PLCAnlogViewModel(model.OilPumpPressure));
            CoolingWaterValues.Add(new PLCAnlogViewModel(model.DynamicFlow));
            CoolingWaterValues.Add(new PLCAnlogViewModel(model.ExcitationFlow));

            CoolingWaterValues.Add(new PLCAnlogViewModel(model.MovingCoilWaterTemperature));
            CoolingWaterValues.Add(new PLCAnlogViewModel(model.ExcitationWaterTemperature));
            CoolingWaterValues.Add(new PLCAnlogViewModel(model.OilPumpTemperature));
            CurrentData = new DataMangerItemViewModel(new DataMangerItemModel());
            CurrentData.PropertyChanged += (sender, args) =>
            {
                if(args.PropertyName == nameof(DataMangerItemViewModel.OperatingStatus))
                {
                    OnPropertyChanged(nameof(GainEnabled));
                    OnPropertyChanged(nameof(GainSwitchEnabled));
                    OnPropertyChanged(nameof(StartEnabled));
                    OnPropertyChanged(nameof(StopEnabled));
                    OnPropertyChanged(nameof(ResetEnabled));
                }
            };
            Properties[Shaker.Model.GlobalVariable.ShakerIDKey] = model.Id;
            AnalogNames[0] = Model.OperatingStatus.Name;
            AnalogNames[1] = Model.OutputCurrent.Name;
            AnalogNames[2] = Model.OutputVoltage.Name;
            AnalogNames[3] = Model.ExcitationCurrent.Name;
            AnalogNames[4] = Model.ExcitationVoltage.Name;
            AnalogNames[5] = Model.ThreePhaseVoltage.Name;

            Units[0] = Model.OperatingStatus.Unit;
            Units[1] = Model.OutputCurrent.Unit;
            Units[2] = Model.OutputVoltage.Unit;
            Units[3] = Model.ExcitationCurrent.Unit;
            Units[4] = Model.ExcitationVoltage.Unit;
            Units[5] = Model.ThreePhaseVoltage.Unit;
            if (!string.IsNullOrEmpty(model.AbutmentTemperature0.Name))
            {
                AnalogNames[6] = Model.AbutmentTemperature0.Name;
                Units[6] = Model.AbutmentTemperature0.Unit;
            }
            if (!string.IsNullOrEmpty(model.AbutmentTemperature1.Name))
            {
                AnalogNames[7] = Model.AbutmentTemperature1.Name;
                Units[7] = Model.AbutmentTemperature1.Unit;
            }
            if (!string.IsNullOrEmpty(model.DCVoltage1.Name))
            {
                AnalogNames[8] = Model.DCVoltage1.Name;
                Units[8] = Model.DCVoltage1.Unit;
            }
            if (!string.IsNullOrEmpty(model.DCVoltage2.Name))
            {
                AnalogNames[9] = Model.DCVoltage2.Name;
                Units[9] = Model.DCVoltage2.Unit;
            }
            if (!string.IsNullOrEmpty(model.DCVoltage3.Name))
            {
                AnalogNames[10] = Model.DCVoltage3.Name;
                Units[10] = Model.DCVoltage3.Unit;
            }
            if (!string.IsNullOrEmpty(model.DCVoltage4.Name))
            {
                AnalogNames[11] = Model.DCVoltage4.Name;
                Units[11] = Model.DCVoltage4.Unit;
            }

            AnalogNames[12] = Model.ExternalCirculatoryPressure.Name;
            Units[12] = Model.ExternalCirculatoryPressure.Unit;

            AnalogNames[13] = Model.MovingCoilPressure.Name;
            Units[13] = Model.MovingCoilPressure.Unit;

            AnalogNames[14] = Model.ExcitationPressure.Name;
            Units[14] = Model.ExcitationPressure.Unit;

            AnalogNames[15] = Model.OilPumpPressure.Name;
            Units[15] = Model.OilPumpPressure.Unit;

            AnalogNames[16] = Model.DynamicFlow.Name;
            Units[16] = Model.DynamicFlow.Unit;

            AnalogNames[17] = Model.ExcitationFlow.Name;
            Units[17] = Model.ExcitationFlow.Unit;

            AnalogNames[18] = Model.MovingCoilWaterTemperature.Name;
            Units[18] = Model.MovingCoilWaterTemperature.Unit;

            AnalogNames[19] = Model.ExcitationWaterTemperature.Name;
            Units[19] = Model.ExcitationWaterTemperature.Unit;

            AnalogNames[20] = Model.OilPumpTemperature.Name;
            Units[20] = Model.OilPumpTemperature.Unit;

            AnalogNames[21] = Model.CoolingWaterOperatingStatus.Name;
            Units[21] = Model.CoolingWaterOperatingStatus.Unit;
            var maincolor = Tools.ColorHelper.ColorToOxyColor(Tools.ColorHelper.MainColor);
            var lablecolor = Tools.ColorHelper.ColorToOxyColor(Tools.ColorHelper.LableColor);
            var auxiliarycolor = Tools.ColorHelper.ColorToOxyColor(Tools.ColorHelper.AuxiliaryColor);
            PlotModel.TextColor = lablecolor;
            PlotModel.TitleColor = lablecolor;
            PlotModel.PlotAreaBorderColor = lablecolor;
            PlotModel.Axes.Add(new OxyPlot.Axes.DateTimeAxis()
            {
                Title = "时间",
                Position = OxyPlot.Axes.AxisPosition.Bottom,
                Key = "X",
                MaximumPadding = 0,
                MajorGridlineColor = auxiliarycolor,
                MajorGridlineStyle = LineStyle.Dot,
                MajorGridlineThickness = 1,
                MinimumPadding = 0,
                ExtraGridlineColor = lablecolor,
                TextColor = lablecolor,
                TitleColor = lablecolor,
                AxislineColor = lablecolor,

                TicklineColor = lablecolor,               
            });
            PlotModel.Axes.Add(new OxyPlot.Axes.LinearAxis()
            {
                Title = "值",
                Position = OxyPlot.Axes.AxisPosition.Left,
                Key = "Y",
                MajorGridlineStyle = LineStyle.Dot,
                MajorGridlineColor = auxiliarycolor,
                MajorGridlineThickness = 1,
                ExtraGridlineColor = lablecolor,
                TextColor = lablecolor,
                TitleColor =lablecolor,
                AxislineColor =lablecolor,
                TicklineColor = lablecolor,
            });
            for (int i = 0; i < AnalogNames.Length-1; i++)
            {
                if (string.IsNullOrEmpty(AnalogNames[i]) || i == 0 || i==21) continue;
                OxyPlot.Series.LineSeries lineSeries = new OxyPlot.Series.LineSeries();
                lineSeries.Title = AnalogNames[i];
                lineSeries.StrokeThickness = 1;
                lineSeries.XAxisKey = "X";
                lineSeries.YAxisKey = "Y";
                lineSeries.TrackerFormatString = "{1}:{2}\n{0}:{4}" + Units[i];
                lineSeries.CanTrackerInterpolatePoints = false;
                lineSeries.DataFieldX = nameof(DataMangerItemModel.Time);
                lineSeries.DataFieldY = PropertiyNames[i];
                lineSeries.IsVisible = PropertiyNames[i] == nameof(DataMangerItemModel.OutputCurrent) || PropertiyNames[i] == nameof(DataMangerItemModel.OutputVoltage);
                _LineSeries.Add(lineSeries);
                PlotModel.Series.Add(lineSeries);
                PlotConfig.Add(new PlotConfigViewModel(lineSeries));
                PlotConfig[^1].PropertyChanged += (_, _) =>
                {
                    PlotModel.InvalidatePlot(false);
                    PlotModel.InvalidatePlot(true);
                };
            }
            {
                OxyPlot.Series.LineSeries lineSeries = new OxyPlot.Series.LineSeries();
                lineSeries.Title = "增益";
                lineSeries.XAxisKey = "X";
                lineSeries.YAxisKey = "Y";
                lineSeries.IsVisible = false;
                lineSeries.StrokeThickness = 1;
                lineSeries.TrackerFormatString = "{1}:{2}\n{0}:{4}%";
                lineSeries.CanTrackerInterpolatePoints = false;
                lineSeries.DataFieldX = nameof(DataMangerItemModel.Time);
                lineSeries.DataFieldY = PropertiyNames[^1];
                _LineSeries.Add(lineSeries);
                PlotModel.Series.Add(lineSeries);
                PlotConfig.Add(new PlotConfigViewModel(lineSeries)); 
                PlotConfig[^1].PropertyChanged += (_, _) =>
                {
                    PlotModel.InvalidatePlot(false);
                    PlotModel.InvalidatePlot(true);
                };
            }
            PlotModel.Legends.Add(new OxyPlot.Legends.Legend()
            {

                IsLegendVisible = true,
                ShowInvisibleSeries = false,
            });
            
            BusManger.Defaut.Bus.PubSub.Subscribe<Shaker.Model.ShakerConnectState>((data,property) =>
            {
                Tools.DispatherInovke.Inovke(() =>
                {
                    IsConnected = data.IsConnected;
                });
            }, $"{Shaker.Model.GlobalVariable.ShakerIDKey}='{Model.Id}'");
            BusManger.Defaut.Bus.PubSub.Subscribe<Shaker.Model.ShakerStatusModel>((data, _) =>
            {
                Tools.DispatherInovke.Inovke(() =>
                {
                    GainSwitch = data.GainSwich;
                    StartupCompleted = data.StartupCompleted;

                });
            }, $"{Shaker.Model.GlobalVariable.ShakerIDKey}='{Model.Id}'");
            BusManger.Defaut.Bus.PubSub.Subscribe<Shaker.Model.ClientExitModel>((data, pro) =>
            {
                Tools.DispatherInovke.Inovke(() =>
                {
                    IsOnline = data.Online;
                    if (!IsOnline) ActiveMQClintID = string.Empty;
                });
            }, $"{Shaker.Model.GlobalVariable.ShakerIDKey}='{Model.Id}'");
            BusManger.Defaut.Bus.PubSub.Subscribe<DataMangerItemModel>((model, property) =>
            {
                if(MainWindowViewModel.Default.IsSaveData) Sql.Default.Insert(model, Model.Id);
                Tools.DispatherInovke.Inovke(() =>
                {
                    if (CurrentData == null)
                    {
                        CurrentData = new DataMangerItemViewModel(model);
                    }
                    else
                    {
                        CurrentData.UpDateModel(model);
                    }
                    lock (locker)
                    {
                        gain = model.Gain;
                        OnPropertyChanged(nameof(Gain));
                    }
                    Items.Add(new DataMangerItemViewModel(model));
                    if (Items.Count > MaxItemCount) Items.RemoveAt(0);
                    PlotModel.InvalidatePlot(false);
                    _LineSeries.ForEach(x => x.ItemsSource = Items);
                    PlotModel.InvalidatePlot(true);
                });
            }, $"{Shaker.Model.GlobalVariable.ShakerIDKey}='{Model.Id}'");
            BusManger.Defaut.Bus.PubSub.Subscribe<Shaker.Model.AllowRemoteControl>((model, property) =>
            {
                Tools.DispatherInovke.Inovke(() =>
                {
                    IsRemoteControl = model == AllowRemoteControl.Remote;
                });
            }, $"{Shaker.Model.GlobalVariable.ShakerIDKey}='{Model.Id}'");


            PlotController.BindMouseDown(OxyMouseButton.Right, new DelegatePlotCommand<OxyMouseDownEventArgs>((v, c, h) =>
            {
                h.Handled = true;
                MenuIsOpen = true;
            })); 
        }

        public OxyPlot.IPlotController PlotController { get; } = new OxyPlot.PlotController();
        public View.ShakerView Content { get; } = new View.ShakerView();
        public bool GainSwitch 
        { 
            get => gainSwitch;
            set
            {
                if (value == gainSwitch) return;
                UpdateProperty(ref gainSwitch, value);
                OnPropertyChanged(nameof(GainEnabled));
            }
        }
        public bool AllowCoolingWater => Model.AllowCoolingWater;
        public ObservableCollection<PLCAnlogViewModel> CoolingWaterValues { get; } = new ObservableCollection<PLCAnlogViewModel>();
        public ObservableCollection<PLCAnlogViewModel> Values { get; } = new ObservableCollection<PLCAnlogViewModel>();
        public override Type View { get; } = typeof(View.ShakerView);
        public ICommand OpenCommand => new DelegateCommand(Open);
        public ICommand CloseCommand => new DelegateCommand(Close);
        public ICommand StartCommand => new DelegateCommand(Start);
        public ICommand StopCommand => new DelegateCommand(Stop);
        public ICommand ResetCommand => new DelegateCommand(Reset);

        public Task  StartNoResult(bool skipPermissions = false)
        {
            return  BusManger.Defaut.Bus.PubSub.PublishAsync<SysControl>(new SysControl()
            {
                Cmd = SysCmd.Start,
                SkipPermissions = skipPermissions,
            }, Properties);
        }
        public async void StopNoResult(bool skipPermissions = false)
        {
            await BusManger.Defaut.Bus.PubSub.PublishAsync<SysControl>(new SysControl()
            {
                Cmd = SysCmd.Stop,
                SkipPermissions = skipPermissions,
            }, Properties);
        }
        public async void ResetNoResult(bool skipPermissions = false)
        {
            await BusManger.Defaut.Bus.PubSub.PublishAsync<SysControl>(new SysControl()
            {
                Cmd = SysCmd.Reset,
                SkipPermissions = skipPermissions,
            }, Properties);
        }
        public async void GainSwitchControlNoResult(bool switchon,bool skipPermissions = false)
        {
            await BusManger.Defaut.Bus.PubSub.PublishAsync<Shaker.Model.SysControl>(new Shaker.Model.SysControl()
            {
                Cmd = switchon ? SysCmd.OpenGain : Shaker.Model.SysCmd.CloseGain,
                SkipPermissions = skipPermissions,
            }, Properties);
        }
        private bool isOpen = false;

        public OxyPlot.PlotModel PlotModel { get; } = new OxyPlot.PlotModel();
        public bool IsOpen { get => isOpen; set => UpdateProperty(ref isOpen, value); }

        private async void Close()
        {
            GetEvent<Shaker.Model.LogModel>().Publish(this, new Shaker.Model.LogModel($"振动台{Name}关闭功放"));
            var result = await BusManger.Defaut.Bus.RPC.RequestAsync<Shaker.Model.SysControl,Shaker.Model.Result>(new Shaker.Model.SysControl()
            {
                Cmd = Shaker.Model.SysCmd.CloseGain,
            }, Properties);
            if(result == null || !result.Success)
            {
                PromptViewModel.Default.Init();
                PromptViewModel.Default.IconType = IconType.Error;
                PromptViewModel.Default.Message = result == null ? "通信超时" : result.Message;
                PromptViewModel.Default.NoVisibility = Visibility.Collapsed;
                PromptViewModel.Default.IsOpen = true;
            }
        }
        public void SetGainNoResult(short gain,bool skipPermissions = false)
        {
            lock (locker)
            {
                BusManger.Defaut.Bus.PubSub.PublishAsync(new SetGain()
                {
                    Gain = gain,
                    SkipPermissions = skipPermissions,
                }, Properties).Wait();
                this.gain = gain;
                OnPropertyChanged(nameof(Gain));
            }
        }
        public ICommand GainSwitchCommand => new DelegateCommand<ExCommandParameter>(GainSwitchControl);
        public void GainSwitchControl(ExCommandParameter parameter)
        {
            if (parameter.Parameter is bool switchon)
            {
                if (switchon) Open();
                else Close();
                return;
            }
            if(parameter.Parameter is string val && bool.TryParse(val,out var result))
            {
                if (result) Open();
                else Close();
                return;
            }
        }
        private void SetGain(short gain)
        {
            GetEvent<Shaker.Model.LogModel>().Publish(this, new Shaker.Model.LogModel($"振动台{Name}设置功放增益为{Gain}%"));
            var result = BusManger.Defaut.Bus.RPC.RequestAsync<Shaker.Model.SetGain, Shaker.Model.Result>(new Shaker.Model.SetGain()
            {
                Gain = gain,
            }, Properties).Result;
            if (result == null || !result.Success)
            {
                PromptViewModel.Default.Init();
                PromptViewModel.Default.IconType = IconType.Error;
                PromptViewModel.Default.Message = result == null ? "通信超时" : result.Message;
                PromptViewModel.Default.NoVisibility = Visibility.Collapsed;
                PromptViewModel.Default.IsOpen = true;
            }
        } public bool GainSwitchEnabled => CurrentData?.OperatingStatus == OperatingStatus.Run && StartupCompleted;
        public bool GainEnabled => CurrentData != null && (CurrentData.OperatingStatus == OperatingStatus.Run && GainSwitch);
        public bool StartEnabled => CurrentData?.OperatingStatus == OperatingStatus.Wait;
        public bool StopEnabled => CurrentData?.OperatingStatus == OperatingStatus.Run;
        public bool ResetEnabled => CurrentData?.OperatingStatus != OperatingStatus.Run;


        private async void Start()
        {
            GetEvent<Shaker.Model.LogModel>().Publish(this, new Shaker.Model.LogModel($"振动台{Name}功放开始"));
            var result = await BusManger.Defaut.Bus.RPC.RequestAsync<Shaker.Model.SysControl,Shaker.Model.Result>(new Shaker.Model.SysControl()
            {
                Cmd = Shaker.Model.SysCmd.Start,
            }, Properties);
            if (result == null || !result.Success)
            {
                PromptViewModel.Default.Init();
                PromptViewModel.Default.IconType = IconType.Error;
                PromptViewModel.Default.Message = result == null ? "通信超时" : result.Message;
                PromptViewModel.Default.NoVisibility = Visibility.Collapsed;
                PromptViewModel.Default.IsOpen = true;
            }
        }
        private async void Stop()
        {
            GetEvent<Shaker.Model.LogModel>().Publish(this, new Shaker.Model.LogModel($"振动台{Name}停止功放"));
            var result = await BusManger.Defaut.Bus.RPC.RequestAsync<Shaker.Model.SysControl,Shaker.Model.Result>(new Shaker.Model.SysControl()
            {
                Cmd = Shaker.Model.SysCmd.Stop,
            }, Properties);
        }
        private async void Reset()
        {
            GetEvent<Shaker.Model.LogModel>().Publish(this, new Shaker.Model.LogModel($"振动台{Name}功放复位"));
            var result= await BusManger.Defaut.Bus.RPC.RequestAsync<Shaker.Model.SysControl,Shaker.Model.Result>(new Shaker.Model.SysControl()
            {
                Cmd = Shaker.Model.SysCmd.Reset,
            }, Properties);
            if (result == null || !result.Success)
            {
                PromptViewModel.Default.Init();
                PromptViewModel.Default.IconType = IconType.Error;
                PromptViewModel.Default.Message = result == null ? "通信超时" : result.Message;
                PromptViewModel.Default.NoVisibility = Visibility.Collapsed;
                PromptViewModel.Default.IsOpen = true;
            }
        }

        private async void Open()
        {
            GetEvent<Shaker.Model.LogModel>().Publish(this, new Shaker.Model.LogModel($"振动台{Name}打开功放"));
            var result = await BusManger.Defaut.Bus.RPC.RequestAsync<Shaker.Model.SysControl,Shaker.Model.Result>(new Shaker.Model.SysControl()
            {
                Cmd = Shaker.Model.SysCmd.OpenGain,
            }, Properties);
            if (result == null || !result.Success)
            {
                PromptViewModel.Default.Init();
                PromptViewModel.Default.IconType = IconType.Error;
                PromptViewModel.Default.Message = result == null ? "通信超时" : result.Message;
                PromptViewModel.Default.NoVisibility = Visibility.Collapsed;
                PromptViewModel.Default.IsOpen = true;
            }
        }
        private short gain;
        private bool setPlotConfigIsOpen = false;
        [AllowNull]
        private DataMangerItemViewModel currentData;
        private bool isConnected = false;
        private bool isRemoteControl = false;
        private bool isOnline = false;
        private bool gainSwitch = false;
        private bool isDeviceControl = false;
        private ShakerViewType shakerView = Data.ShakerViewType.None;
        private bool menuIsOpen = false;
        private bool startupCompleted = false;
        private string activeMQClintID = string.Empty;
        private string gifPath = string.Empty;
        private RepeatBehavior repeatBehavior = RepeatBehavior.Forever;
        private bool autoStart = true;
        private bool cacheFramesInMemory = true;

        public string Title => string.IsNullOrEmpty(Description) ? Name : Description;

        private bool modelVisibily = false;

        public string Name
        {
            get => Model.Name;
            set
            {
                UpdateProperty(ref Model.Name, value);
                OnPropertyChanged(nameof(Title));
            }
        }

        public string Description
        {
            get => Model.Description;
            set
            {
                if (value == Model.Description) return;
                GetEvent<Shaker.Model.LogModel>().Publish(this, new Shaker.Model.LogModel($"振动台{Name}别名修改为{value}"));
                UpdateProperty(ref Model.Description, value);
                Sql.Default.UpDate<Shaker.Model.ShakerControlModel, string, string>(p => p.Id, Model.Id, p => p.Description, Model.Description);
                OnPropertyChanged(nameof(Title));
            }
        }
        public byte SlaveID { get=>Model.SlaveID; set=>UpdateProperty(ref Model.SlaveID, value); }
        public string IPAddress
        {
            get => Model.IPAddress;
            set
            {
                if (Model.Id == value) return;
                GetEvent<Shaker.Model.LogModel>().Publish(this, new Shaker.Model.LogModel($"振动台{Name}功放IP地址修改为{value}"));
                UpdateProperty(ref Model.IPAddress, value);
                Sql.Default.UpDate<Shaker.Model.ShakerControlModel, string, string>(p => p.Id, Model.Id, p => p.IPAddress, Model.IPAddress);
            }
        }
        public int Port
        {
            get => Model.Port;
            set
            {
                if (value != Model.Port)
                {
                    GetEvent<Shaker.Model.LogModel>().Publish(this, new Shaker.Model.LogModel($"振动台{Name}功放端口号修改为{value}"));
                    UpdateProperty(ref Model.Port, value);
                    Sql.Default.UpDate<Shaker.Model.ShakerControlModel, string, int>(p => p.Id, Model.Id, p => p.Port, Model.Port);
                }
            }
        }
        public ICommand RequestPermissionsCommand => new DelegateCommand(RequestPermissions);
        private async void RequestPermissions()
        {
            if (IsRemoteControl) return;
            GetEvent<Shaker.Model.LogModel>().Publish(this, new Shaker.Model.LogModel($"申请振动台{Name}功放控制权限"));
            var result = await BusManger.Defaut.Bus.RPC.RequestAsync<Shaker.Model.SysControl, Shaker.Model.Result>(new Shaker.Model.SysControl()
            {
                Cmd = Shaker.Model.SysCmd.ApplicationControl,
            }, Properties,CancellationToken.None,MainWindowViewModel.Default.SystemConfig.SystemPage.RequestPermissionsTimeout);
            if (result == null || !result.Success)
            {
                PromptViewModel.Default.Init();
                PromptViewModel.Default.IconType = IconType.Error;
                PromptViewModel.Default.Message = result == null ? "通信超时" : result.Message;
                PromptViewModel.Default.NoVisibility = Visibility.Collapsed;
                PromptViewModel.Default.IsOpen = true;
            }
        }
        public short Gain 
        { 
            get => gain;
            set
            {
                if (gain == value) return;
                lock (locker)
                {
                    UpdateProperty(ref gain, value);
                }
                SetGain(value);
            }
        }
        public bool IsRemoteControl { get => isRemoteControl; set =>UpdateProperty(ref isRemoteControl, value); }
        public ICommand SaveCommand => new DelegateCommand(() => Save());
        public ICommand CancelCommand => new DelegateCommand(() => Cancel());

        private void Save()
        {
            GetEvent<Shaker.Model.LogModel>().Publish(this, new Shaker.Model.LogModel($"修改了振动台{Name}配置参数"));
            Sql.Default.Replace(p => p.Id, Model.Id, Model);

        }
        private void Cancel()
        {
            Model = Sql.Default.FindFirst<Shaker.Model.ShakerControlModel>(p => p.Id == Model.Id)!;
            RefreshUI();
        }
        public bool IsMax { get; set; }
        public bool IsSelected { get; set; }
    }
}