ShakerControl/ShakerControl/ViewModel/ShakerControlViewModel.cs

using HandyControl.Interactivity;
using HandyControl.Interactivity.Commands;
using PLCControl;
using Shaker.Model;
using Shaker.ViewModel;
using ShakerControl.ViewModel.DataManger;
using ShakerControl.ViewModel.Warn;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Windows.Input;

namespace ShakerControl.ViewModel
{
    internal class ShakerControlViewModel : ViewModelBase<ShakerControlModel>
    {
        private AllowRemoteControl allowRemote = AllowRemoteControl.Local;

        private EventBus.Properties Properties { get; init; } = new EventBus.Properties();
        private EventBus.IEventData<LogModel> EventHandle { get; init; }
        public void Close()
        {
            PLCControl?.Disconnect();
        }
        public void PublishLog(string message,Shaker.Model.LogType logType = LogType.Message)
        {
            EventHandle?.Publish(this, new LogModel()
            {
                ClientID = MainWindowViewModel.Default.ClientID,
                DateTime = DateTime.Now,
                Message = message,
                LogType = logType,
                ShakerID = Model.Id,
                UserID = MainWindowViewModel.Default.User.Model.Id,
            }, Properties);
        }

        public AllowRemoteControl AllowRemote 
        { 
            get => allowRemote;
            set
            {
                if (allowRemote != value)
                {
                    UpdateProperty(ref allowRemote, value);
                    if (!MainWindowViewModel.Default.MangerIsOnLine) return;
                    MainWindowViewModel.Default.Bus.PubSub.PublishAsync(value, new Dictionary<string, string>()
                    {
                        {Shaker.Model.GlobalVariable.ShakerIDKey,Model.Id }
                    });
                }
            }
        }


        public IO.IOPageViewModel IO { get; } = new IO.IOPageViewModel();
        public DataMangerViewModel DataManger { get; init; } 
        public WarningViewModel Warning { get; init; }
        public Log.LogViewModel Log { get; init; }

        public ShakerControlViewModel(ShakerControlModel model)
        {
            for(int i=0;i<DataMangerItemModel.ANALOG_DATA_LENGTH;i++)
            {
                AnalogNames.Add("");
                Units.Add("");
            }
            EventHandle = GetEvent<LogModel>();
            Properties[Shaker.Model.GlobalVariable.ShakerIDKey] = model.Id;
            PLCControl = new PLCControl.ModBus.Control();
            PLCControl.IPAddress =model.IPAddress;
            PLCControl.Port = model.Port;
            PLCControl.SlaveID = model.SlaveID;
            PLCControl.ConnectionChanged = (sender) =>
            {
                OnPropertyChanged(nameof(IsConnected));
                if (MainWindowViewModel.Default.MangerIsOnLine)
                {
                    MainWindowViewModel.Default.Bus.PubSub.PublishAsync<Shaker.Model.ShakerConnectState>(new ShakerConnectState()
                    {
                        IsConnected = sender,
                    }, new Dictionary<string, string>()
                    {
                        {Shaker.Model.GlobalVariable.ShakerIDKey,model.Id }
                    });
                }
                if(sender)
                {
                    PublishLog("功放连接成功", LogType.Message);
                }
                else
                {
                    PublishLog("功放连接已断开", LogType.Error);
                }
            };
            if(!MainWindowViewModel.Default.IsOffine) MainWindowViewModel.Default.Bus.PubSub.PublishAsync(AllowRemote, new Dictionary<string, string>()
            {
                {Shaker.Model.GlobalVariable.ShakerIDKey,model.Id }
            });
            PLCControl.Connect();
            if (!MainWindowViewModel.Default.IsOffine)
            {
                MainWindowViewModel.Default.Bus.RPC.Respond<Shaker.Model.SetGain, Shaker.Model.Result>((gain, properties) =>
                {
                    if (properties.Contains(Shaker.Model.GlobalVariable.ShakerIDKey))
                    {
                        string shakerid = properties.GetString(GlobalVariable.ShakerIDKey);
                        if (string.IsNullOrEmpty(shakerid))
                        {
                            SystemLog.Default.WriteLog("远程控制功放时需必须指定振动台", LogType.Warn);
                            return (new Result()
                            {
                                Message = "必须指定振动台",
                                Success = false,
                            });
                        }
                        else
                        {
                            if (AllowRemote == AllowRemoteControl.Local)
                            {
                                SystemLog.Default.WriteLog("当前振动台为本地控制", LogType.Message);
                                return (new Result()
                                {
                                    Message = "当前振动台为本地控制",
                                    Success = false,
                                });
                            }
                            else
                            {
                                if (PowerAmplifier == null)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持增益控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持增益控制",
                                        Success = false,
                                    });
                                }
                                if (!GainEnabled)
                                {
                                    SystemLog.Default.WriteLog("增益开关未打开", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "增益开关未打开",
                                        Success = false,
                                    });
                                }
                                if (gain.Gain > PowerAmplifier.MaxGain || gain.Gain < PowerAmplifier.MinGain)
                                {
                                    SystemLog.Default.WriteLog($"超过设定范围，当前设定值为{gain.Gain}，允许值范围为{PowerAmplifier.MinGain}~{PowerAmplifier.MaxGain}", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = $"超过设定范围，当前设定值为{gain.Gain}，允许值范围为{PowerAmplifier.MinGain}~{PowerAmplifier.MaxGain}",
                                        Success = false,
                                    });
                                }
                                PowerAmplifier?.SetGain(gain.Gain);
                                return (new Result()
                                {
                                    Success = true,
                                });
                            }
                        }
                    }
                    else
                    {
                        SystemLog.Default.WriteLog("远程控制功放时需必须指定振动台", LogType.Warn);
                        return (new Result()
                        {
                            Message = "必须指定振动台",
                            Success = false,
                        });
                    }
                }, $"{Shaker.Model.GlobalVariable.ShakerIDKey} = '{model.Id}'");
                MainWindowViewModel.Default.Bus.PubSub.Subscribe<Shaker.Model.ShakerControlModel>((model, _) =>
                {
                    PublishLog($"振动台{Description}的参数已修改");
                    Tools.DispatherInovke.Inovke(() =>
                    {
                        PromptViewModel.Default.Init();
                        PromptViewModel.Default.NoTextFunc = (index) => $"否({10 - index})";
                        PromptViewModel.Default.Message = $"振动台{Description}的参数已修改，是否重启程序?";
                        PromptViewModel.Default.YesAction = () =>
                        {
                            (App.Current as App)?.Restart();
                        };
                        PromptViewModel.Default.SetTimeout(10);
                        PromptViewModel.Default.IsOpen = true;
                    });
                   
                }, $"{Shaker.Model.GlobalVariable.ShakerIDKey} = '{model.Id}'");

                MainWindowViewModel.Default.Bus.RPC.Respond<Shaker.Model.SysControl, Shaker.Model.Result>(SystemControl, $"{Shaker.Model.GlobalVariable.ShakerIDKey} = '{model.Id}'");

                MainWindowViewModel.Default.Bus.PubSub.Subscribe<SysControl>((control, properties) =>
                {
                    if (control == null) return;
                    switch(control.Cmd)
                    {
                        case SysCmd.Start:
                            if (!StartEnabled) return;
                            PowerAmplifier?.StartCommand?.Execute(null);
                            break;
                        case SysCmd.Stop:
                            if (!StopEnabled) return;
                            PowerAmplifier?.StopCommand?.Execute(null);
                            break;
                        case SysCmd.Reset:
                            if (!ResetEnabled) return;
                            PowerAmplifier?.ResetCommand?.Execute(null);
                            break;
                        case SysCmd.CloseGain:
                            if (!GainSwitchEnabled || PowerAmplifier ==null) return;
                            PowerAmplifier.GainSwitchControl(false);
                            break;
                        case SysCmd.OpenGain:
                            if (!GainSwitchEnabled || PowerAmplifier ==null) return;
                            PowerAmplifier.GainSwitchControl(true);
                            break;
                        case SysCmd.CoolingWaterReset:
                            if (!CoolingWaterResetEnabled || !AllowCoolingWater) return;
                            CoolingWater?.ResetCommand?.Execute(null);
                            break;
                        case SysCmd.CoolingWaterStart:
                            if (!CoolingWaterStartEnabled || !AllowCoolingWater) return;
                            CoolingWater?.StartCommand?.Execute(null);
                            break;
                        case SysCmd.CoolingWaterStop:
                            if (!CoolingWaterStopEnabled || !AllowCoolingWater) return;
                            CoolingWater?.StopCommand?.Execute(null);
                            break;
                    }
                }, $"{Shaker.Model.GlobalVariable.ShakerIDKey} = '{model.Id}'");
                MainWindowViewModel.Default.Bus.PubSub.Subscribe<SetGain>((control, _) =>
                {
                    if (control == null || PowerAmplifier ==null || GainEnabled) return;
                    PowerAmplifier.SetGain(control.Gain);
                }, $"{Shaker.Model.GlobalVariable.ShakerIDKey} = '{model.Id}'");
            }
            Warning = new WarningViewModel(this);
            GetEvent(MainWindowViewModel.GET_DATA_EVENT).Subscrip((_, _) =>
            {
                if (!IsConnected) return;
                ReadPlcValue();
                DataManger?.AddData(new short[Shaker.Model.DataMangerItemModel.ANALOG_DATA_LENGTH]
                {
                    Model.OperatingStatus.Value,
                    Model.OutputCurrent.Value,
                    Model.OutputVoltage.Value,
                    Model.ExcitationCurrent.Value,
                    Model.ExcitationVoltage.Value,
                    Model.ThreePhaseVoltage.Value,
                    Model.AbutmentTemperature0.Value,
                    Model.AbutmentTemperature1.Value,
                    Model.DCVoltage1.Value,
                    Model.DCVoltage2.Value,
                    Model.DCVoltage3.Value,
                    Model.DCVoltage4.Value,
                    Model.ExternalCirculatingWaterPressure.Value,
                    Model.ExcitationWaterSupplyFlow.Value,
                    Model.ExcitationWaterSupplyTemperature.Value,
                    Model.MovingCoilWaterSupplyPressure.Value,
                    Model.MovingCoilWaterSupplyFlow.Value,
                    Model.MovingCoilWaterSupplyTemperature.Value,
                    Model.ExcitationWaterSupplyPressure.Value,
                    Model.ExcitationWaterSupplyFlow.Value,
                    Model.ExcitationWaterSupplyTemperature.Value,
                    Model.CoolingWaterOperatingStatus.Value,
                }, PowerAmplifier?.Gain ?? 0);
                if (MainWindowViewModel.Default.IsOffine) return;
                if(MainWindowViewModel.Default.MangerIsOnLine)
                {
                    MainWindowViewModel.Default.Bus.PubSub.PublishAsync<Shaker.Model.ShakerStatusModel>(new ShakerStatusModel()
                    {
                        GainSwich = PowerAmplifier?.GainSwitch ??false,
                        Values = ShakerDigitalGroup?.Model?.Values ?? new byte[4],
                        Values1 = ShakerDigitalGroup1?.Model?.Values ?? new byte[4],
                    },new Dictionary<string, string>()
                    { {Shaker.Model.GlobalVariable.ShakerIDKey,model.Id } });
                }
            });
            ShakerAnlogs.Add(new ShakerAnlogViewModel(this, model.OutputCurrent));
            ShakerAnlogs.Add(new ShakerAnlogViewModel(this, model.OutputVoltage));
            ShakerAnlogs.Add(new ShakerAnlogViewModel(this, model.ExcitationCurrent));
            ShakerAnlogs.Add(new ShakerAnlogViewModel(this, model.ExcitationVoltage));
            ShakerAnlogs.Add(new ShakerAnlogViewModel(this, model.ThreePhaseVoltage));
            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;
                ShakerAnlogs.Add(new ShakerAnlogViewModel(this, model.AbutmentTemperature0));
            }
            if (!string.IsNullOrEmpty(model.AbutmentTemperature1.Name))
            {
                AnalogNames[7] = Model.AbutmentTemperature1.Name;
                Units[7] = Model.AbutmentTemperature1.Unit;
                ShakerAnlogs.Add(new ShakerAnlogViewModel(this, model.AbutmentTemperature1));
            }
            if (!string.IsNullOrEmpty(model.DCVoltage1.Name))
            {
                AnalogNames[8] = Model.DCVoltage1.Name;
                Units[8] = Model.DCVoltage1.Unit;
                ShakerAnlogs.Add(new ShakerAnlogViewModel(this, model.DCVoltage1));
            }
            if (!string.IsNullOrEmpty(model.DCVoltage2.Name))
            {
                AnalogNames[9] = Model.DCVoltage2.Name;
                Units[9] = Model.DCVoltage2.Unit;
                ShakerAnlogs.Add(new ShakerAnlogViewModel(this, model.DCVoltage2));
            }
            if (!string.IsNullOrEmpty(model.DCVoltage3.Name))
            {
                AnalogNames[10] = Model.DCVoltage3.Name;
                Units[10] = Model.DCVoltage3.Unit;
                ShakerAnlogs.Add(new ShakerAnlogViewModel(this, model.DCVoltage3));
            }
            if (!string.IsNullOrEmpty(model.DCVoltage4.Name))
            {
                AnalogNames[11] = Model.DCVoltage4.Name;
                Units[11] = Model.DCVoltage4.Unit;
                ShakerAnlogs.Add(new ShakerAnlogViewModel(this, model.DCVoltage4));
            }

            AnalogNames[12] = Model.ExternalCirculatingWaterPressure.Name;
            Units[12] = Model.ExternalCirculatingWaterPressure.Unit;
            CoolingWaters.Add(new ShakerAnlogViewModel(this, model.ExternalCirculatingWaterPressure));

            AnalogNames[13] = Model.ExternalCirculatingWaterFlow.Name;
            Units[13] = Model.ExternalCirculatingWaterFlow.Unit;
            CoolingWaters.Add(new ShakerAnlogViewModel(this, model.ExternalCirculatingWaterFlow));

            AnalogNames[14] = Model.ExternalCirculatingWaterTemperature.Name;
            Units[14] = Model.ExternalCirculatingWaterTemperature.Unit;
            CoolingWaters.Add(new ShakerAnlogViewModel(this, model.ExternalCirculatingWaterTemperature));

            AnalogNames[15] = Model.MovingCoilWaterSupplyPressure.Name;
            Units[15] = Model.MovingCoilWaterSupplyPressure.Unit;
            CoolingWaters.Add(new ShakerAnlogViewModel(this, model.MovingCoilWaterSupplyPressure));

            AnalogNames[16] = Model.MovingCoilWaterSupplyFlow.Name;
            Units[16] = Model.MovingCoilWaterSupplyFlow.Unit;
            CoolingWaters.Add(new ShakerAnlogViewModel(this, model.MovingCoilWaterSupplyFlow));

            AnalogNames[17] = Model.MovingCoilWaterSupplyTemperature.Name;
            Units[17] = Model.MovingCoilWaterSupplyTemperature.Unit;
            CoolingWaters.Add(new ShakerAnlogViewModel(this, model.MovingCoilWaterSupplyTemperature));

            AnalogNames[18] = Model.ExcitationWaterSupplyPressure.Name;
            Units[18] = Model.ExcitationWaterSupplyPressure.Unit;
            CoolingWaters.Add(new ShakerAnlogViewModel(this, model.ExcitationWaterSupplyPressure));

            AnalogNames[19] = Model.ExcitationWaterSupplyFlow.Name;
            Units[19] = Model.ExcitationWaterSupplyFlow.Unit;
            CoolingWaters.Add(new ShakerAnlogViewModel(this, model.ExcitationWaterSupplyFlow));

            AnalogNames[20] = Model.ExcitationWaterSupplyTemperature.Name;
            Units[20] = Model.ExcitationWaterSupplyTemperature.Unit;
            CoolingWaters.Add(new ShakerAnlogViewModel(this, model.ExcitationWaterSupplyTemperature));

            AnalogNames[21] = Model.CoolingWaterOperatingStatus.Name;
            Units[21] = Model.CoolingWaterOperatingStatus.Unit;

            ShakerDigitalGroup = new ShakerDigitalGroupViewModel(this);
            ShakerDigitalGroup.UpDateModel(model.DigitalGroup);
            CoolingWater = new CoolingWaterViewModel(this);
            PowerAmplifier = new PowerAmplifierViewModel(this);
            PowerAmplifier.PropertyChanged += (sender, args) =>
            {
                if (args.PropertyName == nameof(PowerAmplifierViewModel.GainSwitch))
                {
                    OnPropertyChanged(nameof(GainEnabled));
                }
            };
            ShakerDigitalGroup1 = new ShakerDigitalGroupViewModel(this);
            ShakerDigitalGroup1.UpDateModel(model.DigitalGroup1);
            CoolingWaterGroup = new ShakerDigitalGroupViewModel(this);
            CoolingWaterGroup.UpDateModel(model.CoolingWaterDigitalGroup);
            DataManger = new DataMangerViewModel(AnalogNames.ToArray(),Units.ToArray());
            DataManger.ShakerID = model.Id;
            Log = new Log.LogViewModel(model.Id);
            
            UpDateModel(model);
            if (!MainWindowViewModel.Default.IsOffine)
            {
                MainWindowViewModel.Default.Bus.PubSub.PublishAsync<Shaker.Model.ClientExitModel>(new ClientExitModel()
                {
                    Online = true,
                }, new Dictionary<string, string>()
            {
                {Shaker.Model.GlobalVariable.ShakerIDKey,model.Id }
            });
            }
        }
        public bool AllowCoolingWater => Model.AllowCoolingWater;
        private Result SystemControl(Shaker.Model.SysControl gain, Apache.NMS.IPrimitiveMap properties)
        {
            if (properties.Contains(Shaker.Model.GlobalVariable.ShakerIDKey))
            {
                string shakerid = properties.GetString(GlobalVariable.ShakerIDKey);
                if (string.IsNullOrEmpty(shakerid))
                {
                    SystemLog.Default.WriteLog("远程控制功放时需必须指定振动台", LogType.Warn);
                    return (new Result()
                    {
                        Message = "必须指定振动台",
                        Success = false,
                    });
                }
                else
                {
                    if (AllowRemote == AllowRemoteControl.Local && gain.Cmd != SysCmd.ApplicationControl)
                    {
                        SystemLog.Default.WriteLog("当前振动台为本地控制", LogType.Message);
                        return (new Result()
                        {
                            Message = "当前振动台为本地控制",
                            Success = false,
                        });
                    }
                    else
                    {
                        switch (gain.Cmd)
                        {
                            case SysCmd.Start:
                                if (PowerAmplifier == null)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持功放控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持功放控制",
                                        Success = false,
                                    });
                                }
                                if (StartEnabled)
                                {
                                    PowerAmplifier.StartCommand?.Execute(null);
                                }
                                else
                                {
                                    SystemLog.Default.WriteLog("当前状态无法启动功放", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前状态无法启动功放",
                                        Success = false,
                                    });
                                }
                                break;
                            case SysCmd.Stop:
                                if (PowerAmplifier == null)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持功放控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持功放控制",
                                        Success = false,
                                    });
                                }
                                if (StopEnabled)
                                {
                                    PowerAmplifier.StopCommand?.Execute(null);
                                }
                                else
                                {
                                    SystemLog.Default.WriteLog("当前状态无法停止功放", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前状态无法停止功放",
                                        Success = false,
                                    });
                                }
                                break;
                            case SysCmd.Reset:
                                if (PowerAmplifier == null)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持功放控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持功放控制",
                                        Success = false,
                                    });
                                }
                                if (ResetEnabled)
                                {
                                    PowerAmplifier.ResetCommand?.Execute(null);
                                }
                                else
                                {
                                    SystemLog.Default.WriteLog("当前状态无法复位功放", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前状态无法复位功放",
                                        Success = false,
                                    });
                                }
                                break;
                            case SysCmd.CoolingWaterReset:
                                if(!AllowCoolingWater)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持冷却水控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持冷却水控制",
                                        Success = false,
                                    });
                                }
                                if (CoolingWater == null)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持冷却水控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持冷却水控制",
                                        Success = false,
                                    });
                                }
                                if (CoolingWaterResetEnabled)
                                {
                                    CoolingWater.ResetCommand?.Execute(null);
                                }
                                else
                                {
                                    SystemLog.Default.WriteLog("当前状态无法复位冷却水", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前状态无法复位冷却水",
                                        Success = false,
                                    });
                                }
                                break;
                            case SysCmd.CoolingWaterStart:
                                if (!AllowCoolingWater)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持冷却水控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持冷却水控制",
                                        Success = false,
                                    });
                                }
                                if (CoolingWater == null)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持冷却水控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持冷却水控制",
                                        Success = false,
                                    });
                                }
                                if (CoolingWaterStartEnabled)
                                {
                                    CoolingWater.StartCommand?.Execute(null);
                                }
                                else
                                {
                                    SystemLog.Default.WriteLog("当前状态无法启动冷却水", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前状态无法启动冷却水",
                                        Success = false,
                                    });
                                }
                                break;
                            case SysCmd.CoolingWaterStop:
                                if (!AllowCoolingWater)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持冷却水控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持冷却水控制",
                                        Success = false,
                                    });
                                }
                                if (CoolingWater == null)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持冷却水控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持冷却水控制",
                                        Success = false,
                                    });
                                }
                                if (CoolingWaterStopEnabled)
                                {
                                    CoolingWater.StopCommand?.Execute(null);
                                }
                                else
                                {
                                    SystemLog.Default.WriteLog("当前状态无法停止冷却水", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前状态无法停止冷却水",
                                        Success = false,
                                    });
                                }
                                break;
                            case SysCmd.CloseGain:
                                if (PowerAmplifier == null)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持功放控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持功放控制",
                                        Success = false,
                                    });
                                }
                                if (GainSwitchEnabled)
                                {
                                    PowerAmplifier?.GainSwitchControl(false);
                                }
                                else
                                {
                                    SystemLog.Default.WriteLog("当前状态无法关闭增益输出", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前状态无法关闭增益输出",
                                        Success = false,
                                    });
                                }
                                break;
                            case SysCmd.OpenGain:
                                if (PowerAmplifier == null)
                                {
                                    SystemLog.Default.WriteLog("当前振动台不支持功放控制", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前振动台不支持功放控制",
                                        Success = false,
                                    });
                                }
                                if (GainSwitchEnabled)
                                {
                                    PowerAmplifier?.GainSwitchControl(true);
                                }
                                else
                                {
                                    SystemLog.Default.WriteLog("当前状态无法打开增益输出", LogType.Message);
                                    return (new Result()
                                    {
                                        Message = "当前状态无法打开增益输出",
                                        Success = false,
                                    });
                                }
                                break;
                            case SysCmd.ApplicationControl:
                                {
                                    if(!MainWindowViewModel.Default.IsLoggedIn)
                                    {
                                        return new Result()
                                        {
                                            Success = false,
                                            Message = "用户未登录",
                                        };
                                    }
                                    if (AllowRemote == AllowRemoteControl.Remote) return new Result()
                                    {
                                        Success = true,
                                    };
                                    Tools.DispatherInovke.Inovke(() =>
                                    {
                                        PromptViewModel.Default.Init();
                                        PromptViewModel.Default.Message = $"申请{Model.Description}的控制权限,是否同意?";
                                        PromptViewModel.Default.YesAction = () =>
                                        {
                                            AllowRemote = AllowRemoteControl.Remote;
                                        };
                                        uint count = MainWindowViewModel.Default.SystemConfig.RequestPermissionsTimeout / 1000;
                                        PromptViewModel.Default.NoTextFunc = (index) => $"否({count - index})";
                                        PromptViewModel.Default.SetTimeout(count);
                                        PromptViewModel.Default.IsOpen = true;
                                    });
                                   
                                    return new Result()
                                    {
                                        Success = true,
                                    };
                                }
                            case SysCmd.Connect:
                                if (PLCControl.IsConnected)
                                {
                                    return new Result()
                                    {
                                        Success = false,
                                        Message = "当前已连接",
                                    };
                                }
                                else
                                {
                                    try
                                    {
                                        var result = PLCControl.Connect();
                                        if (result)
                                        {
                                            return new Result()
                                            {
                                                Success = true,
                                            };
                                        }
                                        else
                                        {
                                            return new Result()
                                            {
                                                Success = false,
                                                Message = "连接失败",
                                            };
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        return new Result()
                                        {
                                            Success = false,
                                            Message = "连接失败," + ex.Message,
                                        };
                                    }
                                }
                            case SysCmd.DisConnect:
                                if (PLCControl.IsConnected)
                                {
                                    PLCControl.Disconnect();
                                    return new Result()
                                    {
                                        Success = true,
                                    };
                                }
                                else
                                {
                                    return new Result()
                                    {
                                        Success = false,
                                        Message = "当前没有连接",
                                    };
                                }
                            default:
                                {
                                    SystemLog.Default.WriteLog("不支持的指令", LogType.Message);
                                    return (new Result()
                                    {
                                        Success = false,
                                        Message = "不支持的指令",
                                    });
                                }
                        }
                        return (new Result()
                        {
                            Success = true,
                        });
                    }
                }
            }
            else
            {
                SystemLog.Default.WriteLog("远程控制功放时需必须指定振动台", LogType.Warn);
                return (new Result()
                {
                    Message = "必须指定振动台",
                    Success = false,
                });
            }
        }

        public bool ResetEnabled => OperatingStatus != OperatingStatus.Run;
        public bool StartEnabled => OperatingStatus == OperatingStatus.Wait;
        public bool StopEnabled => OperatingStatus == OperatingStatus.Run;
        public bool GainSwitchEnabled => OperatingStatus == OperatingStatus.Run;
        public bool GainEnabled => (PowerAmplifier?.GainSwitch ?? false)&& OperatingStatus == OperatingStatus.Run;
        public ObservableCollection<string> AnalogNames { get; } = new ObservableCollection<string>(); 
        public ObservableCollection<string> Units { get; } = new ObservableCollection<string>();

        public CoolingWaterOperatingStatus CoolingWaterOperatingStatus
        {
            get => (CoolingWaterOperatingStatus)Model.CoolingWaterOperatingStatus.Value;
            set
            {
                var temp = Model.CoolingWaterOperatingStatus.Value;
                if(temp!=(short)value)
                {
                    UpdateProperty(ref Model.CoolingWaterOperatingStatus.Value, (short)value);
                    OnPropertyChanged(nameof(CoolingWaterResetEnabled));
                    OnPropertyChanged(nameof(CoolingWaterStartEnabled));
                    OnPropertyChanged(nameof(CoolingWaterStopEnabled));
                }
            }
        }
        public OperatingStatus OperatingStatus
        {
            get => (OperatingStatus)Model.OperatingStatus.Value;
            private set
            {
                var temp = Model.OperatingStatus.Value;
                if (temp != (short)value)
                {
                    UpdateProperty(ref Model.OperatingStatus.Value, (short)value);
                    OnPropertyChanged(nameof(ResetEnabled));
                    OnPropertyChanged(nameof(StartEnabled));
                    OnPropertyChanged(nameof(StopEnabled));
                    OnPropertyChanged(nameof(GainSwitchEnabled));
                    OnPropertyChanged(nameof(GainEnabled));
                }
            }
        }

        public bool CoolingWaterResetEnabled => CoolingWaterOperatingStatus != CoolingWaterOperatingStatus.Run;
        public bool CoolingWaterStartEnabled => CoolingWaterOperatingStatus == CoolingWaterOperatingStatus.Wait;
        public bool CoolingWaterStopEnabled => CoolingWaterOperatingStatus == CoolingWaterOperatingStatus.Run;
        public void Exit()
        {
            if (!MainWindowViewModel.Default.MangerIsOnLine) return;
            MainWindowViewModel.Default.Bus.PubSub.PublishAsync<Shaker.Model.ClientExitModel>(new ClientExitModel()
            {
                Online = false,
            }, new Dictionary<string, string>()
            {
                {Shaker.Model.GlobalVariable.ShakerIDKey,Model.Id }
            });
            Disconnect();
        }
        public void Connect() => PLCControl.Connect();
        public void Disconnect() => PLCControl.Disconnect();
        public string ClientID => Model.ClientID;
        public string ShakerName => Model.Name;
        [AllowNull]
        internal IPLCControl PLCControl { get; private set; }
        public string Description { get => Model.Description; set => UpdateProperty(ref Model.Description, value); }
        public string IPAddress { get => Model.IPAddress; }
        public int Port { get => Model.Port; }
        public byte SlaveID => Model.SlaveID;
        public bool IsConnected => PLCControl != null && PLCControl.IsConnected;
        public ObservableCollection<ShakerAnlogViewModel> CoolingWaters { get; } = new ObservableCollection<ShakerAnlogViewModel>();
        public ObservableCollection<ShakerAnlogViewModel> ShakerAnlogs { get; } = new ObservableCollection<ShakerAnlogViewModel>();
        public ShakerDigitalGroupViewModel ShakerDigitalGroup { get; }
        public ShakerDigitalGroupViewModel ShakerDigitalGroup1 { get; }
        public ShakerDigitalGroupViewModel CoolingWaterGroup { get; }
        public PowerAmplifierViewModel PowerAmplifier { get; }
        public CoolingWaterViewModel CoolingWater { get; }
        public void ReadPlcValue()
        {
            if (!PLCControl.IsConnected) return;
            OperatingStatus = (OperatingStatus)PLCControl.ReadInt16(Model.OperatingStatus.Address);
            if(AllowCoolingWater) CoolingWaterOperatingStatus = (CoolingWaterOperatingStatus)PLCControl.ReadInt16(Model.CoolingWaterOperatingStatus.Address);
            foreach (var item in ShakerAnlogs)
            {
                item.ReadPlcValue();
            }
            if(AllowCoolingWater)
            {
                foreach(var item in CoolingWaters)
                {
                    item.ReadPlcValue();
                }
            }
            ShakerDigitalGroup.ReadPlcValue();
            ShakerDigitalGroup1.ReadPlcValue();
            if(AllowCoolingWater) CoolingWaterGroup.ReadPlcValue();
            PowerAmplifier.ReadPlcValue();
            CoolingWater.ReadPlcValue();
        }
        public ICommand ConnectCommand => new DelegateCommand(() =>
        {
            if (PLCControl.IsConnected) return;
            if (!PLCControl.Connect())
            {
                PromptViewModel.Default.Init();
                PromptViewModel.Default.IconType = IconType.Error;
                PromptViewModel.Default.NoVisibility = System.Windows.Visibility.Collapsed;
                PromptViewModel.Default.Message = "连接失败！";
                PromptViewModel.Default.IsOpen = true;
            }
            else
            {

            }
        });
        public ICommand DisConnectCommand => new DelegateCommand(() =>
        {
            PromptViewModel.Default.Init();
            PromptViewModel.Default.IconType = IconType.Ask;
            PromptViewModel.Default.Message = "是否断开连接?";
            PromptViewModel.Default.YesAction = () =>
            {
                if (!PLCControl.IsConnected) return;
                PublishLog("断开功放连接", LogType.Message);
                PLCControl.Disconnect();
            };
            PromptViewModel.Default.IsOpen = true;
        });
    }
}