XdCxRhDW/Service/X2D1NoRefTaskServer/Service/TaskService.cs

using DevExpress.Utils.Extensions;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using XdCxRhDW.Dto;

namespace X2D1NoRefTaskServer.Service
{
    public class TaskService
    {
        private readonly string baseUrl;
        Dictionary<int, CancellationTokenSource> dicCts = new Dictionary<int, CancellationTokenSource>();
        public TaskService()
        {
            var posPlatformAddr = ConfigurationManager.AppSettings["PosPlatformAddr"].Trim();//like http://127.0.0.1:8091 or http://127.0.0.1:8091/
            if (posPlatformAddr.EndsWith("/"))
                this.baseUrl = posPlatformAddr + "api/";
            else
                this.baseUrl = posPlatformAddr + "/api/";
        }

        /// <summary>
        /// 启动历史任务
        /// </summary>
        /// <param name="dto"></param>
        public void StartHistoryAsync(X2D1NoRefTaskHandleDto dto)
        {
            var cts = new CancellationTokenSource();
            if (dicCts.ContainsKey(dto.ID))
                dicCts[dto.ID] = cts;
            else
                dicCts.Add(dto.ID, cts);

            Task.Run(async () =>
            {
                if (!Directory.Exists(dto.CapDir))
                {
                    StopTask(dto.ID, EnumTaskStopType.Error, $"文件路径[{dto.CapDir}]不存在,任务结束");
                    return;
                }
                if (dto.DateDirFormat.Contains("\\"))
                {
                    StopTask(dto.ID, EnumTaskStopType.Error, $"子目录日期格式不能包含多级目录格式");
                    return;
                }

                LogHelper.Info($"【任务{dto.ID}】开始执行...");
                int.TryParse(ConfigurationManager.AppSettings["PosDtoFactor"], out int posDtoFactor);
                if (posDtoFactor == 0) posDtoFactor = 1;//定位时时差系数
                LogHelper.Info($"【任务{dto.ID}】定位时差系数={posDtoFactor}");
                bool canConnected = CanGetSatIdFromMySql();
                DateTime preTime = dto.StartTime;
                int formatFlag;
                if (string.IsNullOrWhiteSpace(dto.DateDirFormat))
                {
                    //没有日期目录,处理完目录中的数据后停止任务
                    formatFlag = 0;
                }
                else if (dto.DateDirFormat.ToLower().EndsWith("dd"))
                {
                    //处理完一个目录后跳转到第二天的目录
                    formatFlag = 1;
                }
                else if (dto.DateDirFormat.ToUpper().EndsWith("HH"))
                {
                    //处理完一个目录后跳转到下一个小时的目录
                    formatFlag = 2;
                }
                else
                {
                    StopTask(dto.ID, EnumTaskStopType.Error, $"执行异常,不支持的日期目录格式");
                    return;
                }

                while (!cts.IsCancellationRequested && preTime <= dto.EndTime)
                {
                    string filesDir = dto.CapDir;
                    try
                    {
                        if (formatFlag != 0)
                        {
                            filesDir = Path.Combine(dto.CapDir, $"{preTime.ToString(dto.DateDirFormat)}");//yyyyMMdd
                        }

                        IEnumerable<string> files;
                        if (!Directory.Exists(filesDir))
                        {
                            LogHelper.Info($"【任务{dto.ID}】目录[{filesDir}]不存在,跳过此目录");
                            ResetTime(formatFlag, ref preTime);
                            continue;
                        }
                        LogHelper.Info($"【任务{dto.ID}】正在处理[{filesDir}]目录中的数据...");
                        files = Directory.EnumerateFiles(filesDir, "*.dat");
                        if (!files.Any())
                        {
                            LogHelper.Info($"【任务{dto.ID}】目录[{filesDir}]中没有文件,跳过此目录");
                            ResetTime(formatFlag, ref preTime);
                            continue;
                        }

                        IOrderedEnumerable<IGrouping<DateTime, HistoryFile>> groups = null;
                        groups = files.Select(f => FileToHistoryFile(dto, f, canConnected)).GroupBy(m => m.CapTime).OrderBy(m => m.Key);
                        foreach (var item in groups)
                        {
                            if (cts.IsCancellationRequested) break;

                            var xdgbInfos = item.GroupBy(m => m.XdIndex);
                            foreach (var xdInfos in xdgbInfos)
                            {
                                var finfos = xdInfos.ToList();
                                var capTime = finfos.First().CapTime;
                                if (capTime < dto.StartTime) continue;
                                if (capTime > dto.EndTime) break;
                                if (finfos.Count < 3)
                                {
                                    LogHelper.Warning($"【任务{dto.ID}】{capTime:yyyyMMddHHmmss}时刻文件数量只有{finfos.Count}个,跳过此组数据");
                                    continue;
                                }
                                //超短波信号
                                var dinfo = finfos.FirstOrDefault(m => m.Ch == 1);
                                if (dinfo == null)
                                {
                                    LogHelper.Warning($"【任务{dto.ID}】{capTime:yyyyMMddHHmmss}时刻未找到超短波信号ch1文件,跳过此组数据");
                                    continue;
                                }
                                var taskSig = dto.Sigs.FirstOrDefault(p => p.FreqUp == dinfo.FreqHz);
                                if (taskSig == null)
                                {
                                    continue;//跳过不是任务处理的频点
                                }
                                //主星
                                var minfo = finfos.FirstOrDefault(m => m.Ch == 2);
                                if (minfo == null)
                                {
                                    LogHelper.Warning($"【任务{dto.ID}】信号[{taskSig.FreqUp / 1e6}],{capTime:yyyyMMddHHmmss}时刻未找到主星信号ch2文件,跳过此组数据");
                                    continue;
                                }
                                //邻1
                                var ninfo = finfos.FirstOrDefault(m => m.Ch == 3);
                                if (ninfo == null)
                                {
                                    LogHelper.Info($"【任务{dto.ID}】信号[{taskSig.FreqUp / 1e6}],{capTime:yyyyMMddHHmmss}时刻未找到邻星信号ch3文件,跳过此组数据");
                                    continue;
                                }
                                try
                                {
                                    var delay1 = taskSig.SigDelay.FirstOrDefault(p => p.SatInfoSatCode == minfo.SatId)?.Delay;
                                    var delay2 = taskSig.SigDelay.FirstOrDefault(p => p.SatInfoSatCode == ninfo.SatId)?.Delay;
                                    if (delay1 == null) delay1 = 0;
                                    if (delay2 == null) delay2 = 0;
                                    LogHelper.Info($"【任务{dto.ID}】信号[{taskSig.FreqUp / 1e6}],主星[{minfo.SatId}],转发时延{delay1}us");
                                    LogHelper.Info($"【任务{dto.ID}】信号[{taskSig.FreqUp / 1e6}],邻星[{ninfo.SatId}],转发时延{delay2}us");
                                    string mainFile = await HttpHelper.UploadFileAsync(minfo.FilePath, baseUrl + "File/UploadFileAsync", token: cts.Token);//主星文件
                                    string adjaFile = await HttpHelper.UploadFileAsync(ninfo.FilePath, baseUrl + "File/UploadFileAsync", token: cts.Token);//邻星文件
                                    string cdbFile = await HttpHelper.UploadFileAsync(dinfo.FilePath, baseUrl + "File/UploadFileAsync", token: cts.Token);//超短文件

                                    DetectDto detectDto = new DetectDto()
                                    {
                                        file1 = cdbFile,//11局使用上行泄露信号进行检测
                                        dmcType = taskSig.SigType,//上行信号检测目前的算法只能使用基于能量的KY或IBS检测
                                        fsHz = minfo.FsHz,
                                        mergeRes = true,
                                    };
                                    detectDto.dmcType = detectDto.dmcType & ~EnumSigCheckTypeDto.DAMA;//DAMA不支持上行信号检测,在这里移除掉
                                    if (detectDto.dmcType == EnumSigCheckTypeDto.DAMA)
                                    {
                                        LogHelper.Warning($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},上行信号不支持DAMA检测,请使用能量检测");
                                        continue;
                                    }
                                    var deteResp = await HttpHelper.PostRequestAsync<List<DetectResDto>>(baseUrl + "DetectCg/DetectCalc", detectDto, token: cts.Token);
                                    if (deteResp.code != 200)
                                    {
                                        LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻信号检测出错.{deteResp.msg}");
                                        continue;
                                    }
                                    LogHelper.Info($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻信号检测完成,共{deteResp.data.Count}个时隙");
                                    var smps = deteResp.data.Select(m => new SmpPosition(m.Start, m.Length)).ToList();//怎么补0?
                                    var cgDto = new CpuCgMultiDto()
                                    {
                                        dtCenter = 260000,
                                        dtRange = 50000,
                                        file1 = cdbFile,
                                        file2 = mainFile,
                                        samplingRate = minfo.FsHz,
                                        smpPositions = smps,
                                        snrThreshold = 15,
                                    };
                                    var result1 = await HttpHelper.PostRequestAsync<List<CpuCgResDto>>(baseUrl + "DetectCg/CpuCgMultiCalc", cgDto, token: cts.Token);
                                    if (result1.code != 200)
                                    {
                                        LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻主星超短CPU参估出错.{result1.msg}");
                                        continue;
                                    }
                                    LogHelper.Info($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻主星超短CPU参估完成.");
                                    cgDto = new CpuCgMultiDto()
                                    {
                                        dtCenter = 260000,
                                        dtRange = 50000,
                                        file1 = cdbFile,
                                        file2 = adjaFile,
                                        samplingRate = minfo.FsHz,
                                        smpPositions = smps,
                                        snrThreshold = 15,
                                    };
                                    var result2 = await HttpHelper.PostRequestAsync<List<CpuCgResDto>>(baseUrl + "DetectCg/CpuCgMultiCalc", cgDto, token: cts.Token);
                                    if (result2.code != 200)
                                    {
                                        LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻邻星超短CPU参估出错.{result2.msg}");
                                        continue;
                                    }
                                    LogHelper.Info($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻邻星超短CPU参估完成");
                                    var data1 = result1.data;
                                    var data2 = result2.data;
                                    if (data1.Count != data2.Count || data1.Count != deteResp.data.Count)
                                    {
                                        LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻参估结果个数和检测结果个数不匹配");
                                        continue;
                                    }
                                    for (int i = 0; i < data1.Count; i++)
                                    {
                                        try
                                        {
                                            if (cts.IsCancellationRequested) break;



                                            X2D1NoXlNoParlPosDto x2D1 = new X2D1NoXlNoParlPosDto()
                                            {
                                                TaskID = dto.ID,
                                                SigTime = minfo.CapTime.AddSeconds(data1[i].Smpstart / minfo.FsHz),
                                                MainCode = minfo.SatId,
                                                AdjaCode = ninfo.SatId,
                                                //卫星转发某些频点可能有时延,无参定位由于不能抵消需要减去这个时延
                                                SxDto = data1[i].Dt * posDtoFactor - data2[i].Dt * posDtoFactor - delay1.Value + delay2.Value,
                                                SxDfo = data1[i].Df,
                                                SxSnr = data1[i].Snr,
                                                XdDto = data1[i].Dt * posDtoFactor - delay1.Value,
                                                XdDfo = data2[i].Df,
                                                XdSnr = data2[i].Snr,
                                                SatTxLon = dto.CapLon,
                                                SatTxLat = dto.CapLat,
                                                CdbTxLon = dto.CapLon,
                                                CdbTxLat = dto.CapLat,
                                                FreqDown = minfo.FreqHz,
                                                FreqUp = dinfo.FreqHz,
                                                CheckRes = new CheckResDto()
                                                {
                                                    FileName = Path.GetFileName(dinfo.FilePath),
                                                    ModRate = deteResp.data[i].ModRate,
                                                    ModType = deteResp.data[i].ModType,
                                                    SmpCount = deteResp.data[i].Length,
                                                    SmpStart = deteResp.data[i].Start,
                                                    UserName = deteResp.data[i].UserName,
                                                    PosCheckType = deteResp.data[i].DmcType.GetEnumByDisplayName<EnumPosCheckTypeDto>(),
                                                }
                                            };
                                            var result = await HttpHelper.PostRequestAsync<PosResDto>(baseUrl + "Pos/PosX2D1NoXlNoParAsync", x2D1);
                                            if (result.code != 200)
                                            {
                                                LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻时隙位置{data1[i].Smpstart}定位异常.{result.msg}");
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻时隙位置{data1[i].Smpstart}定位异常", ex);
                                        }
                                    }
                                    LogHelper.Info($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻定位完成");

                                }
                                catch (Exception ex)
                                {
                                    LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻文件处理异常", ex);
                                    continue;
                                }

                            }


                        }
                        ResetTime(formatFlag, ref preTime);
                        LogHelper.Info($"【任务{dto.ID}】目录[{filesDir}]中的数据处理完成");
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error($"【任务{dto.ID}】目录[{filesDir}]中的数据处理出错,跳过此目录", ex);
                        ResetTime(formatFlag, ref preTime);
                    }
                }
                StopTask(dto.ID, EnumTaskStopType.Properly, "数据处理完成,任务结束");
            }, cts.Token);
        }

        /// <summary>
        /// 启动实时任务
        /// </summary>
        /// <param name="dto"></param>
        public void StarRealAsync(X2D1NoRefTaskHandleDto dto)
        {
            var cts = new CancellationTokenSource();
            if (dicCts.ContainsKey(dto.ID))
                dicCts[dto.ID] = cts;
            else
                dicCts.Add(dto.ID, cts);

            Task.Run(async () =>
            {
                if (!Directory.Exists(dto.CapDir))
                {
                    StopTask(dto.ID, EnumTaskStopType.Error, $"文件路径[{dto.CapDir}]不存在,任务结束");
                    return;
                }
                if (dto.DateDirFormat.Contains("\\"))
                {
                    StopTask(dto.ID, EnumTaskStopType.Error, $"子目录日期格式不能包含多级目录格式");
                    return;
                }

                LogHelper.Info($"【任务{dto.ID}】开始执行...");
                int.TryParse(ConfigurationManager.AppSettings["PosDtoFactor"], out int posDtoFactor);
                if (posDtoFactor == 0) posDtoFactor = 1;//定位时时差系数
                LogHelper.Info($"【任务{dto.ID}】定位时差系数={posDtoFactor}");

                bool canConnected = CanGetSatIdFromMySql();
                DateTime preTime = DateTime.Now;
                int formatFlag;
                if (string.IsNullOrWhiteSpace(dto.DateDirFormat))
                {
                    //没有日期目录,处理完目录中的数据后停止任务
                    formatFlag = 0;
                }
                else if (dto.DateDirFormat.ToLower().EndsWith("dd"))
                {
                    //处理完一个目录后跳转到第二天的目录
                    formatFlag = 1;
                }
                else if (dto.DateDirFormat.ToUpper().EndsWith("HH"))
                {
                    //处理完一个目录后跳转到下一个小时的目录
                    formatFlag = 2;
                }
                else
                {
                    StopTask(dto.ID, EnumTaskStopType.Error, $"执行异常,不支持的日期目录格式");
                    return;
                }

                while (!cts.IsCancellationRequested)
                {
                    string filesDir = dto.CapDir;
                    try
                    {
                        if (formatFlag != 0)
                        {
                            filesDir = Path.Combine(dto.CapDir, $"{preTime.ToString(dto.DateDirFormat)}");//yyyy_MM_dd_HH
                        }
                        bool doNextHour = false;
                        while (!Directory.Exists(filesDir))
                        {
                            LogHelper.Info($"【任务{dto.ID}】目录[{filesDir}]不存在,等待5秒...");
                            Thread.Sleep(5000);
                            if (DateTime.Now.Hour != preTime.Hour)
                            {
                                preTime = DateTime.Now;
                                doNextHour = true;
                                break;
                            }
                            if (cts.IsCancellationRequested) break;
                        }
                        if (cts.IsCancellationRequested) return;
                        if (doNextHour)
                        {
                            continue;
                        }
                        LogHelper.Info($"【任务{dto.ID}】正在处理[{filesDir}]目录中的数据...");
                        var files = Directory.EnumerateFiles(filesDir, "*.dat");
                        if (!files.Any())
                        {
                            LogHelper.Info($"【任务{dto.ID}】目录[{filesDir}]中没有文件,跳过此目录");
                            ResetTime(formatFlag, ref preTime);
                            await Task.Delay(1000);
                            continue;
                        }

                        IOrderedEnumerable<IGrouping<DateTime, HistoryFile>> groups = null;
                        groups = files.Select(f => FileToHistoryFile(dto, f, canConnected)).GroupBy(m => m.CapTime).OrderBy(m => m.Key);
                        foreach (var item in groups)
                        {
                            if (cts.IsCancellationRequested) break;

                            var xdgbInfos = item.GroupBy(m => m.XdIndex);
                            foreach (var xdInfos in xdgbInfos)
                            {
                                var finfos = xdInfos.ToList();
                                var capTime = finfos.First().CapTime;
                                if (capTime < dto.StartTime) continue;
                                if (capTime > dto.EndTime) break;
                                if (finfos.Count < 3)
                                {
                                    LogHelper.Warning($"【任务{dto.ID}】{capTime:yyyyMMddHHmmss}时刻文件数量只有{finfos.Count}个,跳过此组数据");
                                    continue;
                                }
                                //超短波信号
                                var dinfo = finfos.FirstOrDefault(m => m.Ch == 1);
                                if (dinfo == null)
                                {
                                    LogHelper.Warning($"【任务{dto.ID}】{capTime:yyyyMMddHHmmss}时刻未找到超短波信号ch1文件,跳过此组数据");
                                    continue;
                                }
                                var taskSig = dto.Sigs.FirstOrDefault(p => p.FreqUp == dinfo.FreqHz);
                                if (taskSig == null)
                                {
                                    continue;//跳过不是任务处理的频点
                                }
                                //主星
                                var minfo = finfos.FirstOrDefault(m => m.Ch == 2);
                                if (minfo == null)
                                {
                                    LogHelper.Warning($"【任务{dto.ID}】信号[{taskSig.FreqUp / 1e6}],{capTime:yyyyMMddHHmmss}时刻未找到主星信号ch2文件,跳过此组数据");
                                    continue;
                                }
                                //邻1
                                var ninfo = finfos.FirstOrDefault(m => m.Ch == 3);
                                if (ninfo == null)
                                {
                                    LogHelper.Info($"【任务{dto.ID}】信号[{taskSig.FreqUp / 1e6}],{capTime:yyyyMMddHHmmss}时刻未找到邻星信号ch3文件,跳过此组数据");
                                    continue;
                                }
                                try
                                {
                                    var delay1 = taskSig.SigDelay.FirstOrDefault(p => p.SatInfoSatCode == minfo.SatId)?.Delay;
                                    var delay2 = taskSig.SigDelay.FirstOrDefault(p => p.SatInfoSatCode == ninfo.SatId)?.Delay;
                                    if (delay1 == null) delay1 = 0;
                                    if (delay2 == null) delay2 = 0;
                                    LogHelper.Info($"【任务{dto.ID}】信号[{taskSig.FreqUp / 1e6}],主星[{minfo.SatId}],转发时延{delay1}us");
                                    LogHelper.Info($"【任务{dto.ID}】信号[{taskSig.FreqUp / 1e6}],邻星[{ninfo.SatId}],转发时延{delay2}us");
                                    string mainFile = await HttpHelper.UploadFileAsync(minfo.FilePath, baseUrl + "File/UploadFileAsync", token: cts.Token);//主星文件
                                    string adjaFile = await HttpHelper.UploadFileAsync(ninfo.FilePath, baseUrl + "File/UploadFileAsync", token: cts.Token);//邻星文件
                                    string cdbFile = await HttpHelper.UploadFileAsync(dinfo.FilePath, baseUrl + "File/UploadFileAsync", token: cts.Token);//超短文件

                                    DetectDto detectDto = new DetectDto()
                                    {
                                        file1 = cdbFile,//11局使用上行泄露信号进行检测
                                        dmcType = taskSig.SigType,//上行信号检测目前的算法只能使用基于能量的KY或IBS检测
                                        fsHz = minfo.FsHz,
                                    };
                                    detectDto.dmcType = detectDto.dmcType & ~EnumSigCheckTypeDto.DAMA;//DAMA不支持上行信号检测,在这里移除掉
                                    if (detectDto.dmcType == EnumSigCheckTypeDto.DAMA)
                                    {
                                        LogHelper.Warning($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},上行信号不支持DAMA检测");
                                        continue;
                                    }
                                    var deteResp = await HttpHelper.PostRequestAsync<List<DetectResDto>>(baseUrl + "DetectCg/DetectCalc", detectDto, token: cts.Token);
                                    if (deteResp.code != 200)
                                    {
                                        LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻信号检测出错.{deteResp.msg}");
                                        continue;
                                    }
                                    LogHelper.Info($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻信号检测完成,共{deteResp.data.Count}个时隙");
                                    var smps = deteResp.data.Select(m => new SmpPosition(m.Start, m.Length)).ToList();//怎么补0?
                                    var cgDto = new CpuCgMultiDto()
                                    {
                                        dtCenter = 260000,
                                        dtRange = 50000,
                                        file1 = cdbFile,
                                        file2 = mainFile,
                                        samplingRate = minfo.FsHz,
                                        smpPositions = smps,
                                        snrThreshold = 15,
                                    };
                                    var result1 = await HttpHelper.PostRequestAsync<List<CpuCgResDto>>(baseUrl + "DetectCg/CpuCgMultiCalc", cgDto, token: cts.Token);
                                    if (result1.code != 200)
                                    {
                                        LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻主星超短CPU参估出错.{result1.msg}");
                                        continue;
                                    }
                                    LogHelper.Info($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻主星超短CPU参估完成.");
                                    cgDto = new CpuCgMultiDto()
                                    {
                                        dtCenter = 260000,
                                        dtRange = 50000,
                                        file1 = cdbFile,
                                        file2 = adjaFile,
                                        samplingRate = minfo.FsHz,
                                        smpPositions = smps,
                                        snrThreshold = 15,
                                    };
                                    var result2 = await HttpHelper.PostRequestAsync<List<CpuCgResDto>>(baseUrl + "DetectCg/CpuCgMultiCalc", cgDto, token: cts.Token);
                                    if (result2.code != 200)
                                    {
                                        LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻邻星超短CPU参估出错.{result2.msg}");
                                        continue;
                                    }
                                    LogHelper.Info($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻邻星超短CPU参估完成");
                                    var data1 = result1.data;
                                    var data2 = result2.data;
                                    if (data1.Count != data2.Count || data1.Count != deteResp.data.Count)
                                    {
                                        LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻参估结果个数和检测结果个数不匹配");
                                        continue;
                                    }
                                    for (int i = 0; i < data1.Count; i++)
                                    {
                                        try
                                        {
                                            if (cts.IsCancellationRequested) break;



                                            X2D1NoXlNoParlPosDto x2D1 = new X2D1NoXlNoParlPosDto()
                                            {
                                                TaskID = dto.ID,
                                                SigTime = minfo.CapTime.AddSeconds(data1[i].Smpstart / minfo.FsHz),
                                                MainCode = minfo.SatId,
                                                AdjaCode = ninfo.SatId,
                                                //卫星转发某些频点可能有时延,无参定位由于不能抵消需要减去这个时延
                                                SxDto = data1[i].Dt * posDtoFactor - data2[i].Dt * posDtoFactor - delay1.Value + delay2.Value,
                                                SxDfo = data1[i].Df,
                                                SxSnr = data1[i].Snr,
                                                XdDto = data1[i].Dt * posDtoFactor - delay1.Value,
                                                XdDfo = data2[i].Df,
                                                XdSnr = data2[i].Snr,
                                                SatTxLon = dto.CapLon,
                                                SatTxLat = dto.CapLat,
                                                CdbTxLon = dto.CapLon,
                                                CdbTxLat = dto.CapLat,
                                                FreqDown = minfo.FreqHz,
                                                FreqUp = dinfo.FreqHz,
                                                CheckRes = new CheckResDto()
                                                {
                                                    FileName = Path.GetFileName(dinfo.FilePath),
                                                    ModRate = deteResp.data[i].ModRate,
                                                    ModType = deteResp.data[i].ModType,
                                                    SmpCount = deteResp.data[i].Length,
                                                    SmpStart = deteResp.data[i].Start,
                                                    UserName = deteResp.data[i].UserName,
                                                    PosCheckType = deteResp.data[i].DmcType.GetEnumByDisplayName<EnumPosCheckTypeDto>(),
                                                }
                                            };
                                            var result = await HttpHelper.PostRequestAsync<PosResDto>(baseUrl + "Pos/PosX2D1NoXlNoParAsync", x2D1);
                                            if (result.code != 200)
                                            {
                                                LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻时隙位置{data1[i].Smpstart}定位异常.{result.msg}");
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻时隙位置{data1[i].Smpstart}定位异常", ex);
                                        }
                                    }
                                    LogHelper.Info($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻定位完成");

                                }
                                catch (Exception ex)
                                {
                                    LogHelper.Error($"【任务{dto.ID}】信号{taskSig.FreqUp / 1e6:f3},{capTime:yyyyMMddHHmmss}时刻文件处理异常", ex);
                                    continue;
                                }

                            }


                        }
                        ResetTime(formatFlag, ref preTime);
                        LogHelper.Info($"【任务{dto.ID}】目录[{filesDir}]中的数据处理完成");
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error($"【任务{dto.ID}】目录[{filesDir}]中的数据处理出错,跳过此目录", ex);
                        ResetTime(formatFlag, ref preTime);
                    }
                }
                StopTask(dto.ID, EnumTaskStopType.Properly, "数据处理完成,任务结束");
            }, cts.Token);
        }
        private void ResetTime(int formatFlag, ref DateTime time)
        {
            if (formatFlag == 0)
            {
                time = DateTime.MaxValue;
            }
            else if (formatFlag == 1)
            {
                time = time.AddHours(24);
            }
            else
            {
                time = time.AddHours(1);
            }
        }
        private HistoryFile FileToHistoryFile(X2D1NoRefTaskHandleDto dto, string filePath, bool canConnected)
        {  //读取采集文件
           //2024_01_31_10_01_51_000000000_ch11_-1_＿Nxx.xxxxxx_Exx.xxxxxx_xxxxx.xxxHz_xxx.xxxMHz_ch1_xd1.dat
            HistoryFile historyFile = new HistoryFile();
            historyFile.FilePath = filePath;
            var fileName = Path.GetFileNameWithoutExtension(filePath);
            var strs = fileName.Split(new string[] { "_", "MHz", "Hz", "ch", "xd" }, StringSplitOptions.RemoveEmptyEntries);

            //采集时间
            var datestr = string.Join("_", strs.Take(6));
            DateTime dateTime;
            bool istime = DateTime.TryParseExact(datestr, "yyyy_MM_dd_HH_mm_ss", null, DateTimeStyles.None, out dateTime);
            if (!istime) return historyFile;
            historyFile.CapTime = dateTime;


            //采集通道
            var chstr = strs.Skip(strs.Length - 2).Take(1).First();
            int.TryParse(chstr, out int ch);

            //上行信号分组
            var xdIndexstr = strs.Skip(strs.Length - 1).Take(1).First();
            int.TryParse(xdIndexstr, out int xdIndex);

            //采集频点
            var freqstr = strs.Skip(strs.Length - 3).Take(1).First();
            double freqMHz;
            double.TryParse(freqstr, out freqMHz);

            //采样率
            var fsstr = strs.Skip(strs.Length - 4).Take(1).First();
            double.TryParse(fsstr, out double fsHz);

            historyFile.FreqHz = (long)((decimal)freqMHz * 1000000);
            historyFile.Ch = ch;
            historyFile.FsHz = fsHz;
            historyFile.XdIndex = xdIndex;
            if (!canConnected)
            {
                if (ch == 2)
                    historyFile.SatId = dto.MainSatCode;
                else if (ch == 3)
                    historyFile.SatId = dto.AdjaSatCode;
            }
            else
            {
                if (ch == 2)
                {
                    historyFile.SatId = GetSatId(historyFile.FreqHz / 1e6);
                    if (historyFile.SatId == 0)
                    {
                        LogHelper.Warning($"【任务{dto.ID}】频点{historyFile.FreqHz / 1e6:f3}无法通过MySql查询到卫星编号,使用任务中的卫星[{dto.MainSatCode}]");
                        historyFile.SatId = dto.MainSatCode;
                    }
                }
                else if (ch == 3)
                {
                    historyFile.SatId = GetSatId(historyFile.FreqHz / 1e6);
                    if (historyFile.SatId == 0)
                    {
                        LogHelper.Warning($"【任务{dto.ID}】频点{historyFile.FreqHz / 1e6:f3}无法通过MySql查询到卫星编号,使用任务中的卫星[{dto.AdjaSatCode}]");
                        historyFile.SatId = dto.AdjaSatCode;
                    }
                }
            }


            return historyFile;
        }

        private int GetSatId(double freqdownMHz)
        {
            int satId = 0;
            string sql = $"select 卫星ID from freguencysatid where 下行 = '{freqdownMHz}'and 洋区 = 'I' LIMIT 1";
            try
            {
                var res = MySqlTools.ExecuteScalar(System.Data.CommandType.Text, sql);
                if (res == null || res == DBNull.Value)
                {
                    LogHelper.Warning($"下行频点{freqdownMHz}未能从MySql中找到对应的卫星编号.SQL={sql}");
                }
                else
                {
                    bool isInt = int.TryParse($"{res}", out satId);
                    if (!isInt)
                    {
                        LogHelper.Error($"卫星编号转换失败,obj={res}");
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Warning($"下行频点{freqdownMHz}MySql查询卫星编号异常.ConnectionString={System.Configuration.ConfigurationManager.ConnectionStrings["MySql"].ConnectionString}", ex);
            }
            return satId;
        }
        private bool CanGetSatIdFromMySql()
        {
            string sql = $"select 卫星ID from freguencysatid where 下行 = '{0}'and 洋区 = 'I' LIMIT 1";
            try
            {
                var res = MySqlTools.ExecuteScalar(System.Data.CommandType.Text, sql);
                return true;
            }
            catch
            {
                return false;
            }
        }
        private void StopTask(int taskID, EnumTaskStopType type, string stopReason)
        {
            Thread.Sleep(2000);
            if (type == EnumTaskStopType.Properly)
            {
                LogHelper.Info($"【任务{taskID}】{stopReason}");
            }
            else
            {
                LogHelper.Error($"【任务{taskID}】{stopReason}");
            }
            TaskStopHandleDto stopDto = new TaskStopHandleDto() { ID = taskID, StopType = type, StopReason = stopReason };
            var stopResp = HttpHelper.PostRequestAsync(baseUrl + "Task/StopTask", stopDto).Result;
            if (stopResp.code != 200)
            {
                LogHelper.Error($"【任务{taskID}】停止异常.{stopResp.msg}");
            }
            if (dicCts.ContainsKey(taskID))
                dicCts.Remove(taskID);
        }

        /// <summary>
        /// 停止任务
        /// </summary>
        public void Stop(int taskID)
        {
            if (!dicCts.ContainsKey(taskID)) return;
            dicCts[taskID]?.Cancel();
            dicCts.Remove(taskID);
        }
    }
}