DW5S/DW5S.App/MainForm.cs

using DevExpress.XtraBars;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using DevExpress.XtraBars.Docking2010.Views;
using DW5S.App.UserControl;
using DevExpress.XtraBars.Ribbon;
using System.Threading;
using DevExpress.XtraEditors;
using ExtensionsDev;
using DevExpress.XtraBars.Forms;
using DW5S.App.CorTools;
using System.IO;
using DW5S.DTO;
using DW5S.Entity;
using DW5S.Repostory;
using DW5S.KxcApi;
using System.Net.Http;
using DW5S.App.Properties;
using System.Windows.Documents;
using DW5S.App;
using System.Diagnostics;
using DevExpress.Utils.Extensions;
using System.Net;
using DW5S.WebApi;
using DW5S.DataEmulation;
using DxHelper;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using DevExpress.LookAndFeel.Design;
using System.Configuration;

using Microsoft.Extensions.Logging;
using DW5S.Service;
using System.Runtime.CompilerServices;

namespace DW5S
{
    public partial class MainForm : DevExpress.XtraBars.Ribbon.RibbonForm
    {
        [Autowired]
        private readonly ILogger logger;

        [Autowired]
        private readonly UnitOfWork unitOfWork;

        Dictionary<string, Type> ctrlTypes = new Dictionary<string, Type>();
        public MainForm()
        {
            WebApiHelper.Start(AppConfigHelper.Get("HttpPort", 8090), dllKey: "DW5S");
            InitializeComponent();
            ribbon.UseDefault();
            tabbedView1.UseDefault();
            ctrlTypes.Add("任务管理", typeof(CtrlHome));
            ctrlTypes.Add("参估结果", typeof(CtrlCgRes));
            ctrlTypes.Add("绘图管理", typeof(CtrlDraw));
            ctrlTypes.Add("星历管理", typeof(CtrlXl));
            ctrlTypes.Add("卫星管理", typeof(CtrlSat));
            ctrlTypes.Add("接收站管理", typeof(CtrlTx));
            ctrlTypes.Add("参考站管理", typeof(CtrlTx));
            ctrlTypes.Add("超短波管理", typeof(CtrlTx));
            ctrlTypes.Add("测向站管理", typeof(CtrlTx));
            ctrlTypes.Add("固定站管理", typeof(CtrlFixedStation));
            ctrlTypes.Add("信号管理", typeof(CtrlSignal));
            ctrlTypes.Add("目标管理", typeof(CtrlTarget));
            ctrlTypes.Add("系统设置", typeof(CtrlSysSettings));
            ctrlTypes.Add("变采样", typeof(ResampleForm));
            ctrlTypes.Add("GPU参估", typeof(GpuCalcForm));
            ctrlTypes.Add("检测参估", typeof(DetectToolForm));
            ctrlTypes.Add("星历推算", typeof(XlCalculateForm));
            ctrlTypes.Add("信号仿真", typeof(SignalEmulation));
            ctrlTypes.Add("服务状态", typeof(CtrlSvrs));
            ctrlTypes.Add("服务日志", typeof(CtrlSvrLog));
            DxHelper.WaitHelper.UpdateSplashMessage("正在检查数据库环境...");

        }
        private string text;
        private async void MainForm_Load(object sender, EventArgs e)
        {
            //this.text = this.Text;
            //this.HtmlText = $"<size=12>{this.text}";
            //var repsSys = unitOfWork.Of<SysSetings>();
            //var settings = await repsSys.FirstOrDefaultAsync();
            //btn_ItemClick(null, null);
            //ServerContext.Instance.Init();
            //this.HtmlText = $"<size=12>{text}(<size=9>{settings.TimeZoneDisplayName}</size>)";
            //Messenger.Defalut.Sub<SysSetings>("时区改变", settings =>
            //{
            //    this.HtmlText = $"<size=12>{text}(<size=9>{settings.TimeZoneDisplayName}</size>)";
            //});
            //StartProcess();
            //_ = XlScan();
            //_ = XlClear();
            //_ = ClearLocalFile();
            //_ = ClearLog();
            //_ = MonitorCpuAndMemory();
            //await XlLonCalc();
        }
        private Task MonitorCpuAndMemory()
        {
            if (!AppConfigHelper.Get("UseGatherDevState", true)) return Task.CompletedTask;
            return Task.Run(() =>
            {
                try
                {
                    int interval = 30000;
                    CpuMonitor sys = new CpuMonitor();
                    const int GB_DIV = 1024 * 1024 * 1024;
                    while (true)
                    {
                        //第二章方法获取系统CPU和内存使用情况
                        logger.LogInformation($"设备CPU：{sys.CpuLoad:f1}%，设备内存：{(sys.PhysicalMemory - sys.MemoryAvailable) / GB_DIV:f2}GB/{sys.PhysicalMemory / (double)GB_DIV:f2}GB，平台内存：{sys.ProcessMemory() / (double)GB_DIV:f2}GB，平台线程：{sys.ProcessThread()}");
                        Thread.Sleep(interval);
                    }
                }
                catch
                { }
            });

        }
        //自动导入Tle
        private async Task XlScan()
        {
            while (true)
            {
                await Task.Delay(10000);
                var repsSys = unitOfWork.Of<SysSetings>();
                var settings = await repsSys.FirstOrDefaultAsync();
                if (settings == null
                    || string.IsNullOrWhiteSpace(settings.XLDirectory)
                    || !Directory.Exists(settings.XLDirectory))
                {
                    continue;
                }
                DirectoryInfo dir = new DirectoryInfo(settings.XLDirectory);
                var backupSucceed = Path.Combine(dir.FullName, "Backup", "Succeed");
                var backupFailed = Path.Combine(dir.FullName, "Backup", "Failed");
                Directory.CreateDirectory(backupSucceed);
                Directory.CreateDirectory(backupFailed);

                var files = Directory.EnumerateFiles(settings.XLDirectory, "*", SearchOption.TopDirectoryOnly);
                foreach (string file in files)
                {
                    bool succeed = false;
                    try
                    {
                        var fileName = await HttpHelper.UploadFileAsync(file, SysConfig.GetBaseUrl());
                        XlImportDto dto = new XlImportDto() { File = fileName };
                        var res = await HttpHelper.PostRequestAsync<RecordRes>(SysConfig.GetUrl("Xl/ImportTleAsync"), dto);
                        if (res.code == 200)
                        {
                            logger.LogInformation($"星历文件[{file}]自动导入成功!");
                            try
                            {
                                //导入完成的文件放在备份目录
                                var newFile = Path.Combine(backupSucceed, Path.GetFileName(file));
                                if (File.Exists(newFile))
                                    File.Delete(newFile);
                                File.Move(file, newFile);
                            }
                            catch
                            {
                            }
                        }
                        else
                        {
                            logger.LogError($"星历文件[{file}]自动导入失败.{res.msg}");
                            try
                            {
                                //导入完成的文件放在备份目录
                                var newFile = Path.Combine(backupFailed, Path.GetFileName(file));
                                if (File.Exists(newFile))
                                    File.Delete(newFile);
                                File.Move(file, newFile);
                            }
                            catch
                            {
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        logger.LogError(ex, $"星历文件[{file}]自动导入失败");
                        try
                        {
                            //导入完成的文件放在备份目录
                            var newFile = Path.Combine(backupFailed, Path.GetFileName(file));
                            if (File.Exists(newFile))
                                File.Delete(newFile);
                            File.Move(file, newFile);
                        }
                        catch
                        {
                        }
                        await Task.Delay(5000);
                    }
                    finally
                    {
                        await Task.Delay(2000);
                    }
                }

            }
        }
        //清理1年之前导入的星历
        private async Task XlClear()
        {
            while (true)
            {
                try
                {
                    var repsXl = unitOfWork.Of<XlInfo>();
                    DateTime dt = DateTime.Now.AddYears(-1);
                    await repsXl.DeleteAsync(p => p.UpdateTime < dt);
                    await unitOfWork.SaveAsync();
                    await Task.Delay(60 * 1000);

                }
                catch (Exception ex)
                {
                    logger.LogError(ex, "清理过期星历异常");
                }
                finally
                {
                    await Task.Delay(2000);
                }

            }
        }

        //计算星历的轨道经度
        private async Task XlLonCalc()
        {
            while (true)
            {
                try
                {
                    List<XlInfo> calcItems = null;
                    List<SatInfo> satInfo = null;
                    var repsXl = unitOfWork.Of<XlInfo>();
                    var repsSat = unitOfWork.Of<SatInfo>();

                    calcItems = (await repsXl.FindAsync(p => p.Lon == null, p => p.SatCode, false)).Take(100).ToList();
                    satInfo = (await repsSat.GetAllAsync()).ToList();

                    if (calcItems != null && calcItems.Any())
                    {
                        var firstUpdateItems = calcItems.Where(p => satInfo.Any(t => t.SatCode == p.SatCode)).ToList();

                        await Task.Run(async () =>
                        {
                            List<XlInfo> Level1 = new List<XlInfo>();
                            foreach (var item in firstUpdateItems)
                            {
                                try
                                {
                                    var eph = EphHelper.Calc(item.TwoLine, item.TimeUTC);
                                    item.Lon = Math.Round(PhysicsHelper.EcefToGeo((eph.X, eph.Y, eph.Z)).lon, 1);
                                    Level1.Add(item);
                                    calcItems.Remove(item);
                                }
                                catch (Exception ex)
                                {
                                    item.Lon = -999;
                                    logger.LogError(ex, $"[{item.TwoLine}]推算XYZ星历出错!");
                                }
                            }
                            if (Level1.Any())
                            {
                                await repsXl.AddOrUpdateAsync(Level1);
                            }
                            List<XlInfo> Level2 = new List<XlInfo>();
                            foreach (var item in calcItems)
                            {
                                try
                                {
                                    var eph = EphHelper.Calc(item.TwoLine, item.TimeUTC);
                                    item.Lon = Math.Round(PhysicsHelper.EcefToGeo((eph.X, eph.Y, eph.Z)).lon, 1);
                                    Level2.Add(item);
                                }
                                catch (Exception ex)
                                {
                                    item.Lon = -999;
                                    logger.LogError(ex, $"[{item.TwoLine}]推算XYZ星历出错!");
                                }
                            }
                            if (Level2.Any())
                            {
                                await repsXl.AddOrUpdateAsync(Level2);
                            }
                        });
                        await unitOfWork.SaveAsync();
                    }
                    else
                    {
                        await Task.Delay(60 * 1000);
                    }
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, $"推算XYZ星历出错!");
                }
                finally
                {
                    await Task.Delay(5000);
                }
            }
        }

        //清理10分钟之前的文件
        private async Task ClearLocalFile()
        {
            while (true)
            {
                try
                {
                    var uploadFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "wwwroot");
                    var files = Directory.EnumerateFiles(uploadFolder);
                    foreach (var file in files)
                    {
                        FileInfo info = new FileInfo(file);
                        if (info.CreationTime < DateTime.Now.AddMinutes(-10))
                        {
                            try
                            {
                                info.Delete();
                            }
                            catch
                            {
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, "清理wwwroot历史文件异常");
                }
                await Task.Delay(60 * 1000);
            }
        }

        private async Task ClearLog()
        {
            while (true)
            {
                var repsLogRes = unitOfWork.Of<LogRes>();
                try
                {
                    var time1 = DateTime.Today.AddDays(-7);
                    var time2 = DateTime.Today.AddDays(-30);
                    //var delItems = (await repsLogRes.FindAsync(p => p.LogTime < time1 && p.LogType != Entity.EnumLogType.Error)).Take(500).ToList();
                    var deleteTime1 = await repsLogRes.DeleteAsync(p => p.LogTime < time1 && p.LogType != Entity.EnumLogType.Error);

                    //var delItems2 = (await repsLogRes.FindAsync(p => p.LogTime < time2 && p.LogType == Entity.EnumLogType.Error)).Take(500).ToList();
                    var deleteTime2 = await repsLogRes.DeleteAsync(p => p.LogTime < time2 && p.LogType == Entity.EnumLogType.Error);
                    await unitOfWork.SaveAsync();
                    if (deleteTime1 > 0 && deleteTime2 > 0)
                    {
                        break;
                    }
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, "清理日志信息异常");
                    await Task.Delay(10000);
                }
                finally
                {
                    await Task.Delay(5000);
                }
            }
        }

        private void btn_ItemClick(object sender, ItemClickEventArgs e)
        {
            var btnTxt = e?.Item?.Caption?.Trim() ?? "任务管理";
            BaseDocument doc = null;
            doc = tabbedView1.Documents.Find(p => p.Control.GetType() == ctrlTypes[btnTxt]).FirstOrDefault();
            if (doc == null)
            {
                doc = tabbedView1.AddDocument((Control)Activator.CreateInstance(ctrlTypes[btnTxt]), btnTxt);
                if (doc.Control is Form form)
                {
                    form.Text = "";
                    doc.Caption = btnTxt;
                }
                if (btnTxt == "任务管理")
                    doc.Properties.AllowClose = DevExpress.Utils.DefaultBoolean.False;
                else
                    doc.Properties.AllowClose = DevExpress.Utils.DefaultBoolean.True;

            }
            tabbedView1.ActivateDocument(doc.Control);
        }

        protected override void OnFormClosing(FormClosingEventArgs e)
        {
            if (e.CloseReason == CloseReason.UserClosing)
            {
                if (!DxHelper.MsgBoxHelper.ShowConfirm("确定要退出当前系统吗？"))
                {
                    e.Cancel = true;
                    return;
                }
            }
            KillProcess();
            Application.Exit();

        }

        private async void btnOpenApi_ItemClick(object sender, ItemClickEventArgs e)
        {
            string addr = $"http://{IpHelper.GetLocalIp()}:{AppConfigHelper.Get("HttpPort", 8090)}/swagger";
            try
            {
                //System.Diagnostics.Process.Start(addr);//NetFramework可用,NetCore使用CMD启动
                ProcessStartInfo info = new ProcessStartInfo();
                info.Arguments = $"/C start {addr}";
                info.FileName = "cmd";
                info.UseShellExecute = false;
                info.CreateNoWindow = true;
                Process.Start(info);
            }
            catch (Exception ex)
            {
                DxHelper.MsgBoxHelper.ShowError($"无法打开默认浏览器,请手动打开浏览器查看接口文档.地址{addr}");
            }
        }

        private void StartProcess()
        {
            Task.Run(async () =>
            {
                KillProcess();
                Process pro = new Process();
                var servicesDir = Directory.GetDirectories(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Service\\"), "*", SearchOption.TopDirectoryOnly);
                var repsSys = unitOfWork.Of<SysSetings>();
                var settings = await repsSys.FirstOrDefaultAsync();
                foreach (var item in servicesDir)
                {
                    try
                    {
                        string exeName = Path.GetFileNameWithoutExtension(item);
                        string exeFile = $"{item}\\{exeName}.exe";
                        pro.StartInfo.FileName = exeFile;
                        pro.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
                        pro.StartInfo.Arguments = $"http://127.0.0.1:{settings.HttpPort}";
                        pro.Start();
                    }
                    catch (Exception ex)
                    {
                        logger.LogError(ex, $"启动【{item}】中的服务异常");
                        DxHelper.MsgBoxHelper.ShowError($"启动【{item}】中的服务异常");
                    }
                }
            });

        }
        private void KillProcess()
        {
            try
            {
                List<Process> list = new List<Process>();
                var servicesDir = Directory.GetDirectories(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Service\\"), "*", SearchOption.TopDirectoryOnly);
                foreach (var item in servicesDir)
                {
                    string exeName = Path.GetFileNameWithoutExtension(item);
                    list.AddRange(Process.GetProcessesByName(exeName));
                }
                foreach (var item in list)
                {
                    try
                    {
                        item.Kill();
                    }
                    catch
                    {
                    }
                }
            }
            catch
            { }
        }
    }
}