Sanya-ips/ipstool/ipssps2/Ips.Sps.Host.Win/Ephs/EphImportForm.cs

using DevExpress.Office.Internal;
using DevExpress.PivotGrid.Criteria.Validation;
using DevExpress.Utils.Win.Hook;
using DevExpress.Xpo;
using DevExpress.XtraEditors;
using Ips.Eph.ResolveUtil;
using Ips.Library.Basic;
using Ips.Library.DxpLib;
using Ips.Library.Entity;
using Ips.Sps.Sats;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Ips.Sps.Ephs
{
    public partial class EphImportForm : DevExpress.XtraEditors.XtraForm
    {
        public EphImportForm()
        {
            InitializeComponent();
            txtEphFiles.EnableDragDropFile();
            _session = new Session();
        }

        Session _session;

        private bool _imported;
        List<EphImportVo> _ephFileList;
        List<Sat> _allSatList;

        private void EphImportForm_Load(object sender, EventArgs e)
        {
            _allSatList = _session.Query<Sat>().Where(m => m.Enable).ToList();
        }

        private void txtEphFiles_ButtonClick(object sender, DevExpress.XtraEditors.Controls.ButtonPressedEventArgs e)
        {
            bool isFile = e.Button.Caption == "文件";
            if (isFile)
            {
                string files = ToolDialog.OpenFile("", "星历文件", null, "所有文件 (*.*)|*.*", true);
                if (files.IsNullOrEmpty()) return;
                txtEphFiles.Text = files;
            }
            else
            {
                string folder = ToolDialog.OpenFolder("星历文件夹");
                txtEphFiles.Text = folder;
            }
        }

        private void txtEphFiles_EditValueChanged(object sender, EventArgs e)
        {
            BindImportList();
        }

        private void txtImportAll_CheckedChanged(object sender, EventArgs e)
        {
            BindImportList();
        }

        private void BindImportList()
        {
            string ephFileText = txtEphFiles.Text;
            if (ephFileText.IsNullOrWhitespace()) return;
            var ephFileList = ephFileText.Split(";", StringSplitOptions.RemoveEmptyEntries);
            _ephFileList = new List<EphImportVo>();
            foreach (var ephFile in ephFileList)
            {
                if (File.Exists(ephFile))
                {
                    AddFileToList(ephFile);
                }
                else if (Directory.Exists(ephFile))
                {
                    var files = Directory.GetFiles(ephFile, "*", SearchOption.AllDirectories);
                    files.ForEach(m => AddFileToList(m));
                }
            }
            grdEphFiles.DataSource = _ephFileList;
            grdEphFiles.RefreshDataSource();
        }

        private void AddFileToList(string fullName)
        {
            if (!File.Exists(fullName)) return;
            string ext = Path.GetExtension(fullName).ToLower();
            if (ext == ".dat")
            {
                string fileName = Path.GetFileNameWithoutExtension(fullName);
                var index = fileName.IndexOf('_');
                if (index < 0) return;
                var satNumsStr = fileName.Substring(0, index);
                int satNum = 0;
                int.TryParse(satNumsStr, out satNum);
                if (!txtImportAll.Checked)
                {
                    if (satNum == 0 || !_allSatList.Any(m => m.SatNum == satNum)) return;
                }

                _ephFileList.Add(new EphImportVo(fullName, EphType.High, satNum));
            }
            else if (ext == ".txt")
            {
                _ephFileList.Add(new EphImportVo(fullName, EphType.Tle));
            }
        }

        private void btnImport_Click(object sender, EventArgs e)
        {
            var ephFileList = grdEphFiles.DataSource as List<EphImportVo>;
            if (ephFileList.IsNullOrEmpty())
            {
                MsgHelper.ShowMsg("导入文件列表空！");
                return;
            }
            _imported = true;
            bgImportWorker.RunWorkerAsync(ephFileList);
            SetImportState(true);
        }

        private void SetImportState(bool importing)
        {
            btnImport.Enabled = txtEphFiles.Enabled = txtImportAll.Enabled = !importing;
        }

        private void bgImportWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            var fileList = e.Argument as List<EphImportVo>;
            Parallel.For(0, fileList.Count, new ParallelOptions() { MaxDegreeOfParallelism = 10 }, i =>
            {
                if (e.Cancel) return;
                var fileItem = fileList[i];
                bgImportWorker.ReportProgress(i, ImportState.Import);
                try
                {
                    ImportEph(fileItem);
                    bgImportWorker.ReportProgress(i, ImportState.Success);
                }
                catch (Exception ex)
                {
                    bgImportWorker.ReportProgress(i, ImportState.Fail);
                    fileItem.Message = ex.Message;
                }
            });
        }

        private void bgImportWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            _ephFileList[e.ProgressPercentage].State = (ImportState)e.UserState;
            gvEphFiles.RefreshRowCell(gvEphFiles.GetRowHandle(e.ProgressPercentage), colState);
        }

        private void bgImportWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            SetImportState(false);
        }

        private void EphImportForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (bgImportWorker.IsBusy)
            {
                bool isYes = MsgHelper.ShowConfirm("正在导入星历文件，你确定要关闭吗？");
                if (isYes)
                {
                    bgImportWorker.CancelAsync();
                    e.Cancel = false;
                }
                else
                {
                    e.Cancel = true;
                }
            }
            this.DialogResult = _imported ? DialogResult.OK : DialogResult.Cancel;
        }

        private void gvEphFiles_RowCellStyle(object sender, DevExpress.XtraGrid.Views.Grid.RowCellStyleEventArgs e)
        {
            if (e.Column == colState)
            {
                var state = (ImportState)e.CellValue;
                switch (state)
                {
                    case ImportState.Import:
                        e.Appearance.BackColor = Color.Blue;
                        e.Appearance.ForeColor = Color.White;
                        break;
                    case ImportState.Success:
                        e.Appearance.BackColor = Color.Green;
                        e.Appearance.ForeColor = Color.White;
                        break;
                    case ImportState.Fail:
                        e.Appearance.BackColor = Color.Red;
                        e.Appearance.ForeColor = Color.White;
                        break;
                }
            }
        }

        private void ImportEph(EphImportVo ephItem)
        {
            switch (ephItem.EphType)
            {
                case EphType.Tle:
                    ImportTle(ephItem.FullName);
                    break;
                case EphType.High:
                    ImportHigh(ephItem.FullName, ephItem.SatNum);
                    break;
            }
            EphManager.Default.ClearCache();
        }

        private void ImportTle(string fileName)
        {
            var tles = TleResolveUtil.ParseFile(fileName);
            List<Eph> ephList = new List<Eph>();
            using var uow = new UnitOfWork();
            foreach (var item in tles)
            {
                var sat = _allSatList.Find(m => m.SatNum == item.getSatNumber());
                if (sat == null && txtImportAll.Checked == false) continue;

                Eph eph = new Eph(uow);
                eph.SatNum = item.getSatNumber();
                eph.SatName = sat?.Name ?? item.getName();
                eph.EphType = EphType.Tle;
                eph.StartTime = item.getEpochTime();
                eph.EndTime = eph.StartTime.AddYears(10);
                eph.Content = $"{item.Line1};{item.Line2}";
                ephList.Add(eph);
            }
            uow.CommitChanges();
        }

        private void ImportHigh(string fileName, int satNum)
        {
            var sat = _allSatList.Find(m => m.SatNum == satNum);
            if (sat == null && txtImportAll.Checked == false) return;
            using var uow = new UnitOfWork();
            Eph eph = new Eph(uow);
            eph.SatNum = sat?.SatNum ?? satNum;
            eph.SatName = sat?.Name ?? "";
            eph.EphType = EphType.High;
            eph.StartTime = DateTime.MinValue;
            eph.EndTime = DateTime.MinValue;
            eph.Content = Path.GetFileName(fileName);
            uow.CommitChanges();
            var ephList = HpeResolveUtil.ParseFile(fileName, satNum);
            DateTime? startTime = null, endTime = null;
            foreach (var res in ephList)
            {
                EphHigh item = new EphHigh(uow);
                item.EphId = eph.Id;
                item.EphTime = res.Time;
                item.X = res.X;
                item.Y = res.Y;
                item.Z = res.Z;
                startTime = startTime ?? res.Time;
                endTime = res.Time;
            }
            eph.StartTime = startTime ?? DateTime.MinValue;
            eph.EndTime = endTime ?? DateTime.MinValue;
            uow.CommitChanges();
        }
    }
}