Sanya-ips/ipstool/ipssps2/Ips.Sps.Scheduling/SigAds/AdFsHistoryWorker.cs

using DevExpress.Xpo;
using Ips.Library.Basic;
using Ips.Library.Entity;
using Ips.Library.LocLib;
using Ips.Library.Signals;
using Ips.Sps.Adcs;
using Ips.Sps.Scheduling.Entities;
using Ips.Sps.Sigs;
using Ips.Sps.TskResults.Pases;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Ips.Sps.Scheduling.SigAds
{
    public class AdFsHistoryWorker : AdWorkerBase
    {
        public AdFsHistoryWorker(RunTsk context) : base(context)
        {

        }

        public override void Execute(CancellationToken token = default)
        {
            if (CurrentTsk.SigTime < CurrentTsk.StartTime)
            {
                CurrentTsk.SigTime = CurrentTsk.StartTime;
            }
            try
            {
                ExcuteInternal(token);
            }
            finally
            {
                CurrentTsk.SigTime = CurrentTsk.StopTime;
            }
        }

        private void ExcuteInternal(CancellationToken token)
        {
            var startTime = CurrentTsk.StartTime;
            var stopTime = CurrentTsk.StopTime;
            var adCard = CurrentTsk.AdCard;
            if (string.IsNullOrWhiteSpace(adCard.StorePath))
            {
                throw new Exception($"采集管理->{adCard.CardName}未设置落盘目录!");
            }
            try
            {
                Directory.CreateDirectory(adCard.StorePath);
            }
            catch
            {
                throw new Exception($"采集管理->{adCard.CardName}设置的落盘目录{adCard.StorePath}创建失败!");
            }
            var storeDir = new DirectoryInfo(adCard.StorePath);
            var fileTimeLen = SignalFile.SigTimeFileFormat.Length;
            var allSigList = CurrentTsk.RefSigList.Concat(CurrentTsk.TarSigList);
            SortedDictionary<DateTime, Dictionary<RunSig, List<SignalFile>>> timeFileList = new();
            foreach (var dateDir in storeDir.EnumerateDirectories("????????_??"))
            {
                if (token.IsCancellationRequested) break;
                if (DateTime.TryParseExact(dateDir.Name, SignalFile.SigTimeFolderFormat, null, DateTimeStyles.None, out DateTime date))
                {
                    if (date.AddHours(1) > startTime && date < stopTime)
                    {
                        foreach (var fileItem in dateDir.EnumerateFiles("*.dat"))
                        {
                            if (token.IsCancellationRequested) break;
                            var fileTimeStr = fileItem.Name.Left(fileTimeLen);
                            if (fileTimeStr.Length != fileTimeLen) continue;
                            if (DateTime.TryParseExact(fileTimeStr, SignalFile.SigTimeFileFormat, null, DateTimeStyles.None, out DateTime fileTime))
                            {
                                if (fileTime < startTime && fileTime > stopTime) continue;
                                var sigFile = SignalFile.Parse(fileItem.Name);
                                if (sigFile.AdcCode != CurrentTsk.AdCard.CardCode) continue;
                                if (CurrentTsk.AdCard.Channels.Any(m => m.AntCode == sigFile.SiteCode) is false) continue;
                                var runSig = allSigList.FirstOrDefault(m => m.SigFreq == sigFile.SigFreq
                                                    && m.BandWidth == sigFile.BandWidth
                                                    && m.Fs == sigFile.Fs);
                                if (runSig == null) continue;
                                if (!timeFileList.ContainsKey(fileTime))
                                {
                                    timeFileList.Add(fileTime, new Dictionary<RunSig, List<SignalFile>>());
                                }
                                if (!timeFileList[fileTime].ContainsKey(runSig))
                                {
                                    timeFileList[fileTime].Add(runSig, new List<SignalFile>());
                                }
                                timeFileList[fileTime][runSig].Add(sigFile);

                            }
                        }
                    }
                }
            }
            foreach (var timeFiles in timeFileList)
            {
                if (token.IsCancellationRequested) break;
                var sigTime = timeFiles.Key;
                DateTime groupTime = sigTime;
                var adGroup = new AdSigGroup(CurrentTsk.TskId, groupTime);
                OnAdSigGroupStart(new AdSigGroupStartEventArgs(adGroup));

                foreach (var sigFiles in timeFiles.Value.OrderBy(m => m.Key.SigCategory != SignalCategory.RefSig))
                {
                    var runSig = sigFiles.Key;
                    List<Pas> pasList = new List<Pas>();
                    foreach (var sigFile in sigFiles.Value)
                    {
                        if (token.IsCancellationRequested) break;
                        var satNum = sigFile.SatNum.To(0);
                        var ch = CurrentTsk.AdCard.Channels.Find(m => m.Sats.Any(m => m.SatNum == satNum));
                        var sat = ch.Sats.Find(m => m.SatNum == satNum);
                        if (ch != null && sat != null)
                        {
                            //var freqInfo = SigCalcUtil.GetFreqPointBySigFreq(sig.SigFreq, sat.SatType, sat.SatTurn, ch.FrqTurn);
                            //var adfile = SignalFile.Create(sigTime, runSig.SigFreq, runSig.BandWidth, runSig.Fs, ch.AntCode, adCard.CardCode, ch.ChNum, satNum);
                            var pas = CreatePas(runSig, adGroup.GroupTime, sigTime, sat, adCard, ch, sigFile);
                            if (pas != null)
                                pasList.Add(pas);
                        }
                    }
                    var adSigResult = new AdSigResult(adGroup.TskId, adGroup.GroupTime, runSig, sigTime, pasList);
                    adGroup.GroupSigList.Add(adSigResult);
                }

                foreach (var sig in CurrentTsk.RefSigList.Concat(CurrentTsk.TarSigList))
                {
                    token.ThrowIfCancellationRequested();
                    var pasList = FindSigFileByTime(sig, CurrentTsk.SigTime, CurrentTsk.AdCard, adGroup, token);
                    var adSigResult = new AdSigResult(adGroup.TskId, adGroup.GroupTime, sig, sigTime, pasList);
                    adGroup.GroupSigList.Add(adSigResult);
                }
                adGroup.GroupSigList.CompleteAdding();
            }

        }
        protected virtual void ExecuteFixTimeFile(CancellationToken token = default)
        {
            if (CurrentTsk.SigTime < CurrentTsk.StartTime)
            {
                CurrentTsk.SigTime = CurrentTsk.StartTime.AddSeconds(CurrentTsk.StartTime.Second / 15 * 15);
            }

            while (CurrentTsk.SigTime < CurrentTsk.StopTime)
            {
                DateTime groupTime = CurrentTsk.SigTime;
                var adGroup = new AdSigGroup(CurrentTsk.TskId, groupTime);
                OnAdSigGroupStart(new AdSigGroupStartEventArgs(adGroup));

                foreach (var sig in CurrentTsk.RefSigList.Concat(CurrentTsk.TarSigList))
                {
                    token.ThrowIfCancellationRequested();
                    var pasList = FindSigFileByTime(sig, CurrentTsk.SigTime, CurrentTsk.AdCard, adGroup, token);
                    var adSigResult = new AdSigResult(adGroup.TskId, adGroup.GroupTime, sig, CurrentTsk.SigTime, pasList);
                    adGroup.GroupSigList.Add(adSigResult);
                }
                adGroup.GroupSigList.CompleteAdding();
                CurrentTsk.SigTime = CurrentTsk.SigTime.AddSeconds(15);
            }
        }

        protected List<Pas> FindSigFileByTime(RunSig sig, DateTime sigTime, RunAdCard adCard, AdSigGroup adGroup, CancellationToken token = default)
        {
            var fs = SigCalcUtil.CalcFs(adCard.ClockFreq, sig.BandWidth, adCard.Mutil);
            List<Pas> pasList = new List<Pas>();
            if (sig.MainSatId > 0)
            {
                var pas = FindSigSatPas(sig.MainSatId, sig, sigTime, adCard, adGroup);
                pasList.AddIf(pas != null, pas);
            }

            foreach (var satid in sig.AdjaSatIds)
            {
                var pas = FindSigSatPas(satid, sig, sigTime, adCard, adGroup);
                pasList.AddIf(pas != null, pas);
            }

            return pasList;
        }

        protected Pas FindSigSatPas(int satId, RunSig sig, DateTime sigTime, RunAdCard adCard, AdSigGroup adGroup)
        {
            Pas result = null;
            var ch = adCard.Channels.Find(m => m.Sats.Any(m => m.SatId == satId));
            if (ch != null)
            {
                var sat = ch.Sats.Find(m => m.SatId == satId);
                var freqInfo = SigCalcUtil.GetFreqPointBySigFreq(sig.SigFreq, sat.SatType, sat.SatTurn, ch.FrqTurn);
                var adfile = SignalFile.Create(sigTime, sig.SigFreq, sig.BandWidth, sig.Fs, ch.AntCode, adCard.CardCode, ch.ChNum, satId.ToString());
                result = CreatePas(sig, adGroup.GroupTime, sigTime, sat, adCard, ch, adfile);
            }
            return result;
        }

        protected Pas CreatePas(RunSig sig, DateTime groupTime, DateTime sigTime, RunSat sat, RunAdCard adCard, RunAdCh adCh, SignalFile adFile)
        {
            string fullName = adFile.GetLocalFullName(adCard.StorePath);
            if (!File.Exists(fullName)) return null;

            Pas pas = new Pas();
            pas.TskId = CurrentTsk.TskId;
            pas.GroupTime = groupTime;
            pas.SigId = sig.SigId;
            pas.EmtId = sig.EmtId;
            pas.SigTime = sigTime;
            pas.SigFreq = sig.SigFreq;
            pas.BandWidth = sig.BandWidth;
            pas.CreateTime = DateTime.Now;

            pas.SatId = sat.SatId;
            pas.SatNum = sat.SatNum;
            pas.SigCategory = sig.SigCategory;
            pas.SigType = sig.SigType;
            pas.SigLen = sig.SigLen;
            pas.Fs = SigCalcUtil.CalcFs(adCard.ClockFreq, sig.BandWidth, adCard.Mutil);
            pas.SatCode = sat.SatCode;
            pas.AdCardId = adCard.CardId;
            pas.AdChId = adCh.ChId;
            pas.ChNum = adFile.ChNum;
            pas.FolderName = adFile.DirectoryName;
            pas.FileName = adFile.FileName;
            pas.AntId = adCh.AntId;
            pas.AntCode = adCh.AntCode;
            pas.AntLon = adCh.AntLon;
            pas.AntLat = adCh.AntLat;
            pas.AntAlt = adCh.AntAlt;

            return pas;
        }

        protected void FindFile(CancellationToken token)
        {

        }
    }
}