StartServerWPF/StartServerWPF.Modules.Main/ViewModels/MainViewModel.cs

using Prism.Commands;
using Prism.Mvvm;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Controls;
using System.Windows;
using System.Collections.ObjectModel;
using StartServerWPF.Modules.Main.Models;
using System.Windows.Media;
using System.Timers;
using System.Windows.Threading;
using Org.BouncyCastle.Crypto.Modes.Gcm;
using System.Net.Http.Json;
using System.Text.Json.Serialization;
using System.Text.Json;
using System.Text.Encodings.Web;
using System.Text.Unicode;
using System.Security.Principal;

namespace StartServerWPF.Modules.Main.ViewModels
{
    public class MainViewModel : BindableBase
    {
        public MainViewModel(IDialogService dialogService, WebsocketClient websocket)
        {
            Message = "View A from your Prism Module";
            Console.WriteLine(System.Environment.CurrentDirectory + "\\" + JsonParser.systemConfigPath);
            sc = JsonParser.ReadSystemJsonFile(JsonParser.systemConfigPath);
            int moniTimeInd = sc.proMonitor.ProParams.IndexOf("-btime");
            string moniTimeStr = sc.proMonitor.ProParams.Substring(moniTimeInd + 7);
            int moniTimeIndEnd = moniTimeStr.IndexOf(">");
            moniTimeStr = moniTimeStr.Substring(0, moniTimeIndEnd - 1);
            MoniStartTime = DateTime.Parse(moniTimeStr);
            InitializeParams();
            JsonParser.UpdateApmsJson(sc.proApms.ProPath + "apms.json", sc.vpnInfo.DataSavePath);
            JsonParser.UpdateRecvJson(sc.proRecv.ProPath + "gw.recvftp.json", sc.vpnInfo.DataSavePath);
            sc.proMonitor.ProParams = JsonParser.CreateMonitorStartParam(sc.vpnInfo.DataSavePath, MoniStartTime);
            StartTime = DateTime.Now;
            // labelStartTime.Text = "启动时间：" + StartTime.ToString();

            remDb = new MySqlHelper(sc.remoteDb);
            Console.WriteLine(System.Environment.CurrentDirectory);
            Console.WriteLine(sc.remoteDb.ServerAddress + "\t" + sc.remoteDb.ServerPort
                + "\t" + sc.remoteDb.UserName + "\t" + sc.remoteDb.Password);
            this._dialogService = dialogService;
            this._websocket = websocket;
            _websocket.WebSocketInit(sc.remoteDb.WebsocketUrl);
            CurrentItemsList = ApmsProcessSliceList;
            _websocket.SiginServer(sc.remoteDb.Account,sc.remoteDb.Pwd);
        }


        #region  属性
        private string _message;
        public string Message
        {
            get { return _message; }
            set { SetProperty(ref _message, value); }
        }
        private DateTime startTime;
        private DateTime moniStartTime;
        public DateTime StartTime { get => startTime; set => SetProperty(ref startTime, value); }
        public DateTime MoniStartTime { get => moniStartTime; set => SetProperty(ref moniStartTime, value); }
        private string runTime;

        public string RunTime
        {
            get { return runTime; }
            set { SetProperty(ref runTime, value); }
        }
        private string vPNStatus;

        public string VPNStatus
        {
            get { return vPNStatus; }
            set { SetProperty(ref vPNStatus, value);
            }
        }
        private string vpnIP;

        public string VpnIP
        {
            get { return vpnIP; }
            set { SetProperty(ref vpnIP, value); }
        }
        private string vPNStatusForeColor;

        public string VPNStatusForeColor
        {
            get { return vPNStatusForeColor; }
            set { SetProperty(ref vPNStatusForeColor, value); }
        }

        private bool vPNIsConnect;

        public bool VPNIsConnect
        {
            get { return vPNIsConnect; }
            set { SetProperty(ref vPNIsConnect, value); }
        }
        
        private bool isIndeterminate=false;

        public bool IsIndeterminate
        {
            get { return isIndeterminate; }
            set { SetProperty(ref isIndeterminate, value); }
        }
        private ObservableCollection<string> reciveDataSource=new ObservableCollection<string>();

        public ObservableCollection<string> ReciveDataSource
        {
            get { return reciveDataSource; }
            set { reciveDataSource = value; }
        }
        private ObservableCollection<int> intervalTimesSource=new ObservableCollection<int>();

        public ObservableCollection<int> IntervalTimesSource
        {
            get { return intervalTimesSource; }
            set { intervalTimesSource = value; }
        }

        private int selectedIndex;

        public int SelectedIndex
        {
            get { return selectedIndex; }
            set { SetProperty(ref selectedIndex, value); }
        }

        private int proMonInterval = 10;
        public int ProMonInterval { get => proMonInterval;
            set => SetProperty(ref proMonInterval, value); 
        }

        private ObservableCollection<string> _OutPutItemsSource = new ObservableCollection<string>();
        public ObservableCollection<string> OutPutItemsSource
        {
            get => _OutPutItemsSource;
            set => SetProperty(ref _OutPutItemsSource, value);
        }


        private List<string> _apmsProcessSliceList= new List<string>();
        public List<string> ApmsProcessSliceList
        {
            get => _apmsProcessSliceList;
            set=>  SetProperty(ref _apmsProcessSliceList, value);
            
        }
        private List<string> _apmsEventList = new List<string>();
        public List<string> ApmsEventList
        {
            get => _apmsEventList;
            set => SetProperty(ref _apmsEventList, value);
        }

        private List<string> _toolsProcessSliceList = new List<string>();
        public List<string> ToolsProcessSliceList
        {
            get => _toolsProcessSliceList;
            set => SetProperty(ref _toolsProcessSliceList, value);
            
        }
        private List<string> _toolsEventList = new List<string>();
        public List<string> ToolsEventList
        {
            get => _toolsEventList;
            set => SetProperty(ref _toolsEventList, value);
        }

        public static void AddItems<T>(List<T> list, T t1)
        {
            if (list == null)
            {
                return;
            }
            list.Add(t1);
            if (list.Count > 10)
            {
                T item = list[0]; 
                list.RemoveAt(0);
            }
        }
        #endregion
        private List<string> CurrentItemsList;
        #region 事件
        public DelegateCommand LoadedCommand => new(Loaded);
        public DelegateCommand UnloadedCommand => new(Unloaded);

        public DelegateCommand ConnectVPNCommand => new(ConnectVPN);
        public DelegateCommand DisConnectVPNCommand => new(DisConnectVPN);
        public DelegateCommand GetVPNStatusCommand => new(GetVPNStatus);     
        public DelegateCommand SetVPNParaCommand => new(SetVPNPara);
        public DelegateCommand DisplayLogCommand => new(DisplayLog);
        public DelegateCommand OneKeyStartCommand => new(OneKeyStart);
        public DelegateCommand OneKeyStopCommand => new(OneKeyStop);
        public DelegateCommand DisplayRealWavesCommand => new(DisplayRealWaves);
        public DelegateCommand QueryDataCommand => new(QueryData);
        public DelegateCommand InsertDataCommand => new(InsertData);
        public DelegateCommand<object> OutputItemsCommand => new((obj)=>   
        {
            switch (obj.ToString())
            {
                case "apmsProcessSlice":
                    CurrentItemsList = ApmsProcessSliceList;
                    break;
                case "apmsEvent":
                    CurrentItemsList = ApmsEventList;
                    OutPutItemsSource.Clear();

                    break;
                case "toolsProcessSlice":
                    CurrentItemsList = ToolsProcessSliceList;

                    break;
                case "toolsEvent":
                    CurrentItemsList = ToolsEventList;
                    break;
                default:
                    break;
            }
            OutPutItemsSource.Clear();
            CurrentItemsList.ForEach((item) =>
            {
                OutPutItemsSource.Add(item);
            });
        });
        
        private void Loaded()
        {
            IntilVPN();
            SetControlstatus();
        }
        
        public void Unloaded()
        {
            //KillProcess(sc.proServer);
            //KillProcess(sc.proRecv);
            //KillProcess(sc.proApms);
            //KillProcess(sc.proMonitor);
            //KillProcess(sc.proTools);
            //string logStr = DateTime.Now.ToString("s") + "\t程序关闭";
            //WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);
            OneKeyStop();
        }

        private void ConnectVPN()
        {
            vpn.CreateOrUpdateVPN(sc.vpnInfo.VpnName, sc.vpnInfo.VpnIP);
            vpn.ConnectVPN(sc.vpnInfo.VpnName, sc.vpnInfo.VpnUserName, sc.vpnInfo.VpnPsw);
            Thread.Sleep(1000);
            string logStr = DateTime.Now.ToString("s") + "\tVPN手动连接";
            WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);
            SetControlstatus();
        }
        
        private void DisConnectVPN()
        {    
            if (MessageBox.Show("是否断开VPN连接？", "提示", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
            {
                vpn.DisConnectVPN(sc.vpnInfo.VpnName);
                Thread.Sleep(500);
                SetControlstatus();
                Thread.Sleep(100);
                string logStr = DateTime.Now.ToString("s") + "\tVPN手动断开";
                WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);
            }
        }
     
        private void GetVPNStatus()
        {
            if (vpn.CheckVpnStatus(sc.vpnInfo.VpnName))
            {
                MessageBox.Show("VPN已经连接!");
            }
            else
            {
                MessageBox.Show("VPN断开连接!");
            }
        }

        private void SetVPNPara()
        {
            DialogParameters param = new DialogParameters();
            param.Add("type", 1);// 编辑
            param.Add("model", sc);
            param.Add("moniTime", MoniStartTime);          
            _dialogService.ShowDialog(
                "SetParamDialog",
                param,
                new Action<IDialogResult>(result =>
                {
                    if (result != null && result.Result == ButtonResult.OK)
                    {
                        MessageBox.Show("数据已保存", "提示");
                    }
                }));           
        }

        private void DisplayLog()
        {
            Process.Start("explorer.exe", sc.vpnInfo.SystemLogPath);
        }

        private void OneKeyStart()
        {
            foreach (var item in sc.GetType().GetProperties())
            {
                var pro = item.GetValue(sc) as ProcessInfo;
                if (pro != null)
                {
                    StartTime = DateTime.Now;
                    pro.Pid= StartProcess(pro);
                    if (sc.proServer.Pid < 32)
                    {
                        ReciveDataSource.Add( pro.ProName+"服务器程序启动失败：" + StartTime.ToString());
                    }
                    Thread.Sleep(10);
                }
            }
            // labelStartTime.Text = "启动时间：" + StartTime.ToString();
            RunTime = DateDiff(DateTime.Now, StartTime);
            string logStr = StartTime.ToString("s") + "\t服务器程序启动";
            WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);
            IsIndeterminate =true;
            // btnSetParams.Enabled = false;
            timer1.Interval = TimeSpan.FromSeconds(ProMonInterval);
            timer1.Start();

            ReciveDataSource.Clear();
        }

        private void OneKeyStop()
        {
            foreach (var item in sc.GetType().GetProperties())
            {
                var pro = item.GetValue(sc) as ProcessInfo;
                if (pro != null)
                {
                    int indexPro = KillProcess(pro);
                    if (indexPro > -1)
                    {
                        ReciveDataSource.Add(pro.ProName + "结束成功");
                    }
                    else
                    {
                        ReciveDataSource.Add(pro.ProName + "结束失败");
                    }
                }
            }

            ReciveDataSource.Add("服务停止于：" + DateTime.Now.ToString());
            timer1.Stop();
            IsIndeterminate = false;
            string logStr = DateTime.Now.ToString("s") + "\t服务器程序关闭";
            WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);

            // labelStartTime.Text = "启动时间：";
            StartTime = new DateTime();
            //  buttonOneKeyStart.Enabled = true;
            // btnSetParams.Enabled = true;
        }

        private void DisplayRealWaves()
        {
            StartProcess(sc.proPlot);
        }

        private void QueryData()
        {
            string str = "2021-05-09T00:15:34.530406 -0.60000 -0.07969 0.6000 ML -3.05 14 13 0.048 ";
            MsEvent me = new MsEvent(str);
            // dataGridView1.DataSource = remDb.MySqlSelect("select ETime,X,Y,Z,ML,LocSta,MLSta,Rms from " + sc.remoteDb.TableName).Tables[sc.remoteDb.TableName];
        }

        private void InsertData()
        {
            string str = "2021-05-09T00:15:34.900406 -0.60000 -0.07969 0.6000 ML -3.05 14 13 0.048 ";
            MsEvent me = new MsEvent(str);
            bool insStat = remDb.InsertEvent(me);
            if (insStat)
            {
                Console.WriteLine("新增成功");
            }
            else
            {
                Console.WriteLine("已有该记录");
            }
        }
        #endregion
        private void ConnectVpn()
        {
            // 系统路径 C:\windows\system32\
            string WinDir = Environment.GetFolderPath(Environment.SpecialFolder.SystemX86) + @"";
            Console.WriteLine(WinDir);
            // rasdial.exe
            string RasDialFileName = "rasdial.exe";

            // VPN路径 C:\windows\system32\rasdial.exe
            string VPNPROCESS = WinDir + "\\" + RasDialFileName;
            // VPN地址
            //string IPToPing = "49.232.209.49";

            // VPN名称
            string VPNName = "余吾手动";

            // VPN用户名
            string UserName = "lzvpn";

            // VPN密码
            string PassWord = "Lz123456789";
            string args = string.Format("{0} {1} {2}", VPNName, UserName, PassWord);

            ProcessStartInfo myProcess = new ProcessStartInfo(VPNPROCESS, args);

            myProcess.CreateNoWindow = true;

            myProcess.UseShellExecute = false;

            Process.Start(myProcess);
        }
        private void IntilVPN()
        {
            vpn = new VPNHelper(sc.vpnInfo.VpnName, sc.vpnInfo.VpnIP, sc.vpnInfo.VpnUserName, sc.vpnInfo.VpnPsw);
        }


        [DllImport("shell32.dll")]
        public static extern int ShellExecute(IntPtr hwnd, StringBuilder lpszOp, StringBuilder lpszFile, StringBuilder lpszParams, StringBuilder lpszDir, int FsShowCmd);


        public VPNHelper vpn;

        public bool vpnStatus = false;
        public SystemConfig sc;

        MySqlHelper remDb;

        private DispatcherTimer  timer1= new  DispatcherTimer();
        private readonly IDialogService _dialogService;
        private readonly WebsocketClient _websocket;

        public void InitializeParams()
        {
            timer1.Interval = TimeSpan.FromSeconds(ProMonInterval);
            timer1.Tick += timer1_Tick;
            this.Message = "服务器版本：" + JsonParser.serverVision;
            IntervalTimesSource.Add(5);
            IntervalTimesSource.Add(10);
            IntervalTimesSource.Add(15);
            IntervalTimesSource.Add(20);
            IntervalTimesSource.Add(30);
            IntervalTimesSource.Add(60);
            SelectedIndex = 1;
            JsonParser.systemLogFileName = "SerLog_" + DateTime.Now.ToString("yyyyMMdd") + ".txt";
            string logStr = DateTime.Now.ToString("s") + "\t程序启动";
            WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);
            //CheckIp();
        }
        #region 方法
        private bool CMDStartProcess(ProcessInfo proInfo)
        {
            //* Create your Process
            Process process = new Process();
            process.Exited += Process_Exited;
            process.EnableRaisingEvents = true;
            process.StartInfo.FileName = Path.GetFullPath(proInfo.ProPath + proInfo.ProName+".exe");
            process.StartInfo.WorkingDirectory = Path.GetFullPath(proInfo.ProPath);
            process.StartInfo.Arguments = proInfo.ProParams;
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.RedirectStandardOutput = true;
            process.StartInfo.RedirectStandardError = true;

            process.StartInfo.CreateNoWindow = true;
            //* Set your output and error (asynchronous) handlers
            process.OutputDataReceived += new DataReceivedEventHandler(OutputHandler);
            process.ErrorDataReceived += new DataReceivedEventHandler(OutputHandler);
            //* Start process and handlers
            bool res=  process.Start();
            process.BeginOutputReadLine();
            process.BeginErrorReadLine();

            return res;
          //  process.WaitForExit();
        }

        private void Process_Exited(object? sender, EventArgs e)
        {

        }

        void OutputHandler(object sendingProcess, DataReceivedEventArgs outLine)
        {
            Debug.WriteLine("output*************:{0},{1}",sendingProcess.ToString(), outLine.Data);
            if (string.IsNullOrEmpty(outLine.Data)) return;
            if (outLine.Data.Contains("ProcessSlice:"))
            {
                var pro = sendingProcess as Process;
                if (pro != null)
                {
                    if (pro.MainModule.ModuleName.Contains(sc.proApms.ProName))
                    {
                        AddItems(ApmsProcessSliceList, outLine.Data);
                    }
                    else if (pro.MainModule.ModuleName.Contains(sc.proTools.ProName))
                    {
                        AddItems(ToolsProcessSliceList, outLine.Data);
                    }
                }
            }
            else if (outLine.Data.Contains("ML "))
            {
                var pro = sendingProcess as Process;
                if (pro != null)
                {
                    if (pro.MainModule.ModuleName.Contains(sc.proApms.ProName))
                    {
                        AddItems(ApmsEventList, outLine.Data);
                    }
                    else if (pro.MainModule.ModuleName.Contains(sc.proTools.ProName))
                    {
                        AddItems(ToolsEventList, outLine.Data);
                    }
                }
            }
            Application.Current.Dispatcher.BeginInvoke(() =>
            {
                OutPutItemsSource.Clear();
                CurrentItemsList.ForEach((item) =>
                {
                    OutPutItemsSource.Add(item);
                });
            });
        }



        /// <summary>
        /// 启动进程
        /// </summary>
        /// <param name="proInfo"></param>
        /// <returns>进程启动返回值</returns>
        private int StartProcess(ProcessInfo proInfo)
        {
             bool res= CMDStartProcess(proInfo);
            int seInd = res ? 37 : 1;
            //int seInd = ShellExecute(IntPtr.Zero, new StringBuilder("open"), new StringBuilder(proInfo.ProName + ".exe")
            //          , new StringBuilder(proInfo.ProParams), new StringBuilder(proInfo.ProPath), proInfo.ShowState);
            return seInd;

        }
        /// <summary>
        /// 结束进程
        /// </summary>
        /// <param name="processInfo"></param>
        /// <returns>0=成功;1=未找到进程;-1=失败</returns>
        private int KillProcess(ProcessInfo processInfo)
        {
            int ri = 0;
            if (processInfo != null)
            {
                if (processInfo.ProName != null)
                {
                    try
                    {

                        Process[] localByName = Process.GetProcessesByName(processInfo.ProName);
                        if (localByName.Length == 0)
                        {
                            ri = 1;
                            return ri;
                        }
                        foreach (var item in localByName)
                        {
                            Console.WriteLine(item.Id);
                            item.Kill();
                        }
                        return ri;
                    }
                    catch (Exception)
                    {
                        return -1;
                    }
                }
                else
                {
                    return 0;
                }
            }
            else
            {
                return 0;
            }
        }
        /// <summary>
        /// 查找进程
        /// </summary>
        /// <param name="processInfo"></param>
        /// <returns>0=正在运行;1=未运行;-1=系统错误</returns>
        private int FindProcess(ProcessInfo processInfo)
        {
            int ri = 0;
            try
            {
                Process[] localByName = Process.GetProcessesByName(processInfo.ProName);
                if (localByName.Length == 0)
                {
                    ri = 1;
                    return ri;
                }
                return ri;
            }
            catch (Exception)
            {
                return -1;
            }
        }
        private string DateDiff(DateTime DateTime1, DateTime DateTime2)
        {
            string dateDiff = null;
            TimeSpan ts1 = new TimeSpan(DateTime1.Ticks);
            TimeSpan ts2 = new
            TimeSpan(DateTime2.Ticks);
            TimeSpan ts = ts1.Subtract(ts2).Duration();
            if (ts.Days > 0)
            {
                dateDiff += ts.Days.ToString() + "天";
            }
            if (ts.Hours > 0)
            {
                dateDiff += ts.Hours.ToString() + "小时";
            }
            if (ts.Minutes > 0)
            {
                dateDiff += ts.Minutes.ToString() + "分钟";
            }

            dateDiff += ts.Seconds.ToString() + "秒";
            return dateDiff;
        }


        private void timer1_Tick(object? sender, EventArgs e)
        {
            ReciveDataSource.Clear();
            ReciveDataSource.Add(DateTime.Now.ToString());

            foreach (var item in sc.GetType().GetProperties())
            {
                var pro = item.GetValue(sc) as ProcessInfo;
                if (pro != null)
                {
                    int sfp = FindProcess(pro);
                    if (sfp == 0)
                    {
                        ReciveDataSource.Add(pro.ProName+"服务器程序运行正常");
                    }
                    else
                    {
                        ReciveDataSource.Add(pro.ProName + "服务器程序未运行");
                        Thread.Sleep(2);
                        StartProcess(pro);
                        Thread.Sleep(20);
                        ReciveDataSource.Add(pro.ProName + "服务器程序重启成功");
                        string logStr = DateTime.Now.ToString("s") + "\t服务器程序" + pro.ProName + "重启";
                        WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);

                        string jsonStr= JsonSerializer.Serialize(new CSDeviceWebhook
                        {
                            type= CSMessage.webhook,
                             message=logStr,
                        }, new JsonSerializerOptions
                        {
                            // 整齐打印
                            WriteIndented = true,
                            //重新编码，解决中文乱码问题
                            Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
                        });
                        _websocket.SendMes(jsonStr);
                    }
                }
            }
            #region 注释
            //int sfp = FindProcess(sc.proServer);
            //if (sfp == 0)
            //{
            //    ReciveDataSource.Add("服务器程序运行正常");
            //}
            //else
            //{
            //    ReciveDataSource.Add("服务器程序未运行");
            //    Thread.Sleep(2);
            //    StartProcess(sc.proServer);
            //    Thread.Sleep(20);
            //    ReciveDataSource.Add("服务器程序重启成功");
            //    string logStr = DateTime.Now.ToString("s") + "\t服务器程序" + sc.proServer.ProName + "重启";
            //    WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);
            //}
            //sfp = FindProcess(sc.proRecv);
            //if (sfp == 0)
            //{
            //    ReciveDataSource.Add("接收数据程序运行正常");
            //}
            //else
            //{
            //    ReciveDataSource.Add("接收数据程序未运行");
            //    Thread.Sleep(2);
            //    StartProcess(sc.proRecv);
            //    Thread.Sleep(20);
            //    ReciveDataSource.Add("接收数据程序重启成功");
            //    string logStr = DateTime.Now.ToString("s") + "\t接收数据程序" + sc.proRecv.ProName + "重启";
            //    WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);
            //}
            //sfp = FindProcess(sc.proApms);
            //if (sfp == 0)
            //{
            //    ReciveDataSource.Add("自动识别程序运行正常");
            //}
            //else
            //{
            //    ReciveDataSource.Add("自动识别程序未运行");
            //    Thread.Sleep(2);
            //    StartProcess(sc.proApms);
            //    Thread.Sleep(20);
            //    ReciveDataSource.Add("自动识别程序重启成功");
            //    string logStr = DateTime.Now.ToString("s") + "\t自动识别程序" + sc.proApms.ProName + "重启";
            //    WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);
            //}
            //sfp = FindProcess(sc.proMonitor);
            //if (sfp == 0)
            //{
            //    ReciveDataSource.Add("网页服务程序运行正常");
            //}
            //else
            //{
            //    ReciveDataSource.Add("网页服务程序未运行");
            //    Thread.Sleep(2);
            //    StartProcess(sc.proMonitor);
            //    Thread.Sleep(20);
            //    ReciveDataSource.Add("网页服务程序重启成功");
            //    string logStr = DateTime.Now.ToString("s") + "\t网页服务程序" + sc.proMonitor.ProName + "重启";
            //    WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);
            //}
            #endregion
            RunTime = DateDiff(DateTime.Now, StartTime);
            vpnStatus = vpn.CheckVpnStatus(sc.vpnInfo.VpnName);
            if (!vpnStatus)
            {
                vpn.ConnectVPN(sc.vpnInfo.VpnName, sc.vpnInfo.VpnUserName, sc.vpnInfo.VpnPsw);
                Thread.Sleep(1000);
                string logStr = DateTime.Now.ToString("s") + "\tVPN断开，重连";
                WriteSerLog(sc.vpnInfo.SystemLogPath + JsonParser.systemLogFileName, logStr);

                string jsonStr = JsonSerializer.Serialize(new CSDeviceWebhook
                {
                    type = CSMessage.webhook,
                    message = logStr,

                }, new JsonSerializerOptions
                {
                    // 整齐打印
                    WriteIndented = true,
                    //重新编码，解决中文乱码问题
                    Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
                });
                _websocket.SendMes(jsonStr);

            }
        }
        public void GetLocalIp()
        {
            ///获取本地的IP地址
            string AddressIP = string.Empty;
            foreach (IPAddress _IPAddress in Dns.GetHostEntry(Dns.GetHostName()).AddressList)
            {
                if (_IPAddress.AddressFamily.ToString() == "InterNetwork")
                {
                    AddressIP = _IPAddress.ToString();
                    if (AddressIP.Contains("172.16"))
                    {
                        sc.vpnInfo.VpnIP = AddressIP;
                    }
                }
            }
            //return AddressIP;
        }

      
        public void SetControlstatus()
        {
            vpnStatus = vpn.CheckVpnStatus(sc.vpnInfo.VpnName);
            if (vpnStatus)
            {
                VPNIsConnect = true;
 
                VPNStatusForeColor = "#FF008000";
                VPNStatus = "VPN已连接";
                VpnIP = vpn.GetLocalIp();
            }
            else
            {
                VPNIsConnect = false;
                VPNStatusForeColor = "#FFFF0000";
                VPNStatus = "VPN断开连接";
            }
        }

        public void WriteSerLog(string fn, string logstr)
        {            
           if(!File.Exists(fn))
            {
                Directory.CreateDirectory(Path.GetDirectoryName(fn));           
            }
            StreamWriter sw = new StreamWriter(fn, true, Encoding.Default);
            sw.WriteLine(logstr);
            sw.Close();
        }
        #endregion
    }



}