XdCxRhDW/XdCxRhDW.App/Controllers/ResultController.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http;
using XdCxRhDW.Dto;
using XdCxRhDW.Repostory;
using System.IO;
using XdCxRhDW.Entity;
using XdCxRhDW.Api;
using XdCxRhDW.WebApi;
using DPP_YH_Core.Extensions;
using XdCxRhDW.App.Model;
using System.Diagnostics;
using System.Configuration;

namespace XdCxRhDW.App.Controllers
{
    /// <summary>
    /// 结果查询相关接口
    /// </summary>
    public class ResultController : BaseController
    {

        /// <summary>
        /// 根据时间范围查询参估结果
        /// </summary>
        /// <param name="dto"><see cref="CgResQueryDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        public async Task<AjaxResult<List<CgResDto>>> GetCgResByTimeRange(CgResQueryDto dto)
        {
            List<CgResDto> cgList = new List<CgResDto>();
            try
            {
                DateTime start = dto.BeginTime;
                DateTime end = dto.EndTime;
                var dir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DbPart");
                if (!Directory.Exists(dir)) return Success(cgList);
                List<string> list = new List<string>();
                DateTime tempStart = new DateTime(start.Year, start.Month, start.Day);
                while (end >= tempStart)
                {
                    list.Add(end.ToString("yyyy") + "\\" + end.ToString("MMdd") + ".db");
                    end = end.AddDays(-1);
                }
                end = dto.EndTime;
                foreach (var item in list)
                {
                    var dayFile = Path.Combine(dir, item);
                    using (RHDWPartContext db = RHDWPartContext.GetContext(dayFile))
                    {
                        if (db == null) continue;
                        var query = db.PosRes.Where(p => p.SigTime >= start && p.SigTime <= end && p.TaskInfoID == dto.TaskInfoID);
                        if (!dto.IncludeInvalidate)
                            query = query.Where(p => p.PosLon != 999);
                        if (dto.TarFrequpHz != null && dto.TarFrequpHz > 0)
                            query = query.Where(p => p.FreqUpHz == dto.TarFrequpHz.Value);
                        var cgRes = await query.Include(p => p.CgRes).Select(t => t.CgRes).Include(t => t.StationRes).OrderByDescending(p => p.SigTime).ToListAsync();
                        var listDto = MapCgDto(cgRes);
                        cgList.AddRange(listDto);
                    }
                }
                return Success(cgList);
            }
            catch (TaskCanceledException)
            {
                string msg = $"参估结果时间范围查询超时.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                XdCxRhDW.Framework.LogHelper.Error(msg);
                return Error<List<CgResDto>>("参估结果时间范围查询超时");
            }
            catch (Exception ex)
            {
                string msg = $"参估结果时间范围查询异常.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<CgResDto>>("参估结果时间范围查询异常");
            }
        }

        /// <summary>
        /// 获取指定任务的所有上行频点
        /// </summary>
        /// <param name="dto">任务频点查询模型</param>
        /// <returns>任务所有频点信息</returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        public async Task<AjaxResult<List<TaskFreqResDto>>> GetTaskFreqs(TaskFreqQueryDto dto)
        {
            var posList = new List<long>();
            try
            {
                var dir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DbPart");
                if (!Directory.Exists(dir)) return Success(new List<TaskFreqResDto>());
                var yearDirs = Directory.EnumerateDirectories(dir).OrderByDescending(p => Convert.ToInt32(new DirectoryInfo(p).Name));//年目录,倒叙排列
                DateTime max = DateTime.MinValue;
                foreach (var yearDir in yearDirs)
                {
                    if (max != DateTime.MinValue) break;
                    //每一天的db文件,倒序排列
                    var dayFiles = Directory.EnumerateFiles(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, yearDir), "*.db").OrderByDescending(p => Convert.ToInt32(new DirectoryInfo(p).Name.Substring(0, 4)));
                    foreach (var dayFile in dayFiles)
                    {
                        using (RHDWPartContext db = RHDWPartContext.GetContext(dayFile))
                        {
                            if (db == null) continue;

                            var listFrequp = await db.PosRes.Where(p => p.TaskInfoID == dto.TaskInfoID).Select(p => p.FreqUpHz).Distinct().ToListAsync();
                            foreach (var item in listFrequp)
                            {
                                if (!posList.Contains(item))
                                    posList.Add(item);
                            }
                        }
                    }
                }
                var res = posList.Select(p => new TaskFreqResDto() { FreqUpHz = p }).OrderBy(o => o.FreqUpHz).ToList();
                return Success(res);
            }
            catch (Exception ex)
            {
                string msg = $"定位结果查询异常-任务编号:{dto.TaskInfoID}";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<TaskFreqResDto>>("定位结果查询异常");
            }
        }

        /// <summary>
        /// 获取所有执行中的任务
        /// </summary>
        [HttpPost]
        public async Task<AjaxResult<List<TaskQueryResDto>>> GetRunningTasks()
        {
            try
            {
                using (RHDWContext db = new RHDWContext())
                {
                    var tasks = await db.TaskInfos.Where(p => p.TaskState == EnumTaskState.Running).ToListAsync();
                    var res = tasks.Select(t => new TaskQueryResDto()
                    {
                        TaskID = t.ID,
                        PosType = (EnumPosTypeDto)(int)t.PosType,
                        TaskType = (EnumTaskTypeDto)(int)t.TaskType,
                    });
                    return Success(res.ToList());
                }
            }
            catch (Exception ex)
            {
                string msg = $"查询执行中的任务异常";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<TaskQueryResDto>>("查询执行中的任务异常");
            }
        }

        #region 定位结果查询接口
        /// <summary>
        /// 根据时间范围查询定位结果
        /// </summary>
        /// <param name="dto"><see cref="PosRequestByTimeRangeDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        public async Task<AjaxResult<List<PosResDto>>> GetPosResByTimeRange(PosRequestByTimeRangeDto dto)
        {
            var response = (await GetPosResByTimeRangeObsolete(dto));
            if (response.code == 200)
            {
                var listDto = response.data?.Select(p => MapDto(p)).ToList();
                return Success(listDto);
            }
            else
            {
                return Error<List<PosResDto>>(response.msg);
            }
        }

        /// <summary>
        /// 查询最后X小时的的定位结果
        /// </summary>
        /// <param name="dto"><see cref="PosRequestByLastRangeDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        public async Task<AjaxResult<List<PosResDto>>> GetPosResByLastHours(PosRequestByLastRangeDto dto)
        {
            var response = (await GetPosResByLastHoursObsolete(dto));
            if (response.code == 200)
            {
                var listDto = response.data?.Select(p => MapDto(p)).ToList();
                return Success(listDto);
            }
            else
            {
                return Error<List<PosResDto>>(response.msg);
            }
        }


        /// <summary>
        /// 根据时间范围查询定位结果(此方法内部调用)
        /// </summary>
        /// <param name="dto"><see cref="PosRequestByTimeRangeDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        [Obsolete]
        public async Task<AjaxResult<List<PosRes>>> GetPosResByTimeRangeObsolete(PosRequestByTimeRangeDto dto)
        {
            List<PosRes> posList = new List<PosRes>();
            try
            {
                DateTime start = dto.BeginTime;
                DateTime end = dto.EndTime;
                var dir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DbPart");
                if (!Directory.Exists(dir)) return Success(posList);
                List<string> list = new List<string>();
                DateTime tempStart = new DateTime(start.Year, start.Month, start.Day);
                while (end >= tempStart)
                {
                    list.Add(end.ToString("yyyy") + "\\" + end.ToString("MMdd") + ".db");
                    end = end.AddDays(-1);
                }
                end = dto.EndTime;
                List<TargetInfo> targets;
                using (RHDWContext dbBasic = new RHDWContext())
                {
                    targets = await dbBasic.TargetInfos.ToListAsync();
                }
                foreach (var item in list)
                {
                    var dayFile = Path.Combine(dir, item);
                    using (RHDWPartContext db = RHDWPartContext.GetContext(dayFile))
                    {
                        for (int i = 0; i < 2; i++)
                        {
                            try
                            {
                                if (db == null) continue;
                                var query = db.PosRes.Where(p => p.SigTime >= start && p.SigTime <= end && p.TaskInfoID == dto.TaskInfoID);
                                if (!dto.IncludeInvalidate)
                                    query = query.Where(p => p.PosLon != 999);
                                if (dto.TarFrequpHz != null && dto.TarFrequpHz > 0)
                                    query = query.Where(p => p.FreqUpHz == dto.TarFrequpHz.Value);
                                var posRes = await query.Include(p => p.CheckRes).OrderByDescending(p => p.SigTime).ToListAsync();

                                foreach (var itemPos in posRes)
                                {
                                    if (itemPos.TargetInfoID > 0)
                                    {
                                        itemPos.TargetInfo = targets.FirstOrDefault(p => p.ID == itemPos.TargetInfoID);
                                        if (itemPos.TargetInfo != null && !string.IsNullOrWhiteSpace(itemPos.TargetInfo.TargeColor))
                                            itemPos.ColorKey = itemPos.TargetInfo.TargeColor;

                                    }
                                }
                                posList.AddRange(posRes);
                                break;
                            }
                            catch (Exception ex)
                            {
                                LogHelper.Error($"同步分区表结构异常,DayFile={dayFile}", ex).Wait(5000);
                                db.SyncDb();
                            }
                        }

                    }
                }
                return Success(posList);
            }
            catch (Exception ex)
            {
                string msg = $"定位结果时间范围查询异常.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<PosRes>>("定位结果时间范围查询异常");
            }
        }
        /// <summary>
        /// 根据时间范围查询定位结果(此方法内部调用)
        /// </summary>
        /// <param name="dto"><see cref="PosRequestByTimeRangeDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        [Obsolete]
        public async Task<AjaxResult<List<RePosRes>>> GetPosCgResByTimeRangeObsolete(PosRequestByTimeRangeDto dto)
        {
            List<RePosRes> posList = new List<RePosRes>();
            try
            {
                DateTime start = dto.BeginTime;
                DateTime end = dto.EndTime;
                var dir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DbPart");
                if (!Directory.Exists(dir)) return Success(posList);
                List<string> list = new List<string>();
                DateTime tempStart = new DateTime(start.Year, start.Month, start.Day);
                while (end >= tempStart)
                {
                    list.Add(end.ToString("yyyy") + "\\" + end.ToString("MMdd") + ".db");
                    end = end.AddDays(-1);
                }
                end = dto.EndTime;
                List<TargetInfo> targets;
                using (RHDWContext dbBasic = new RHDWContext())
                {
                    targets = await dbBasic.TargetInfos.ToListAsync();
                }
                foreach (var item in list)
                {
                    var dayFile = Path.Combine(dir, item);
                    using (RHDWPartContext db = RHDWPartContext.GetContext(dayFile))
                    {
                        if (db == null) continue;
                        var query = db.PosRes.Where(p => p.SigTime >= start && p.SigTime <= end && p.TaskInfoID == dto.TaskInfoID);
                        if (!dto.IncludeInvalidate)
                            query = query.Where(p => p.PosLon != 999);
                        if (dto.TarFrequpHz != null && dto.TarFrequpHz > 0)
                            query = query.Where(p => p.FreqUpHz == dto.TarFrequpHz.Value);
                        var posRes = await query.OrderByDescending(p => p.SigTime).ToListAsync();

                        foreach (var itemPos in posRes)
                        {
                            var repos = new RePosRes();
                            repos.ID = itemPos.ID;
                            repos.SigTime = itemPos.SigTime;
                            repos.PosLon = itemPos.PosLon;
                            repos.PosLat = itemPos.PosLat;
                            repos.MirrLon = itemPos.MirrLon;
                            repos.MirrLat = itemPos.MirrLat;
                            repos.TaskInfoID = itemPos.TaskInfoID;
                            repos.FreqUpHz = itemPos.FreqUpHz;
                            repos.StationResID = itemPos.StationResID;
                            repos.CxResID = itemPos.CxResID;
                            repos.CgResID = itemPos.CgResID;
                            repos.CheckResID = itemPos.CheckResID;
                            repos.PosResType = itemPos.PosResType;
                            repos.TargetState = itemPos.TargetState;

                            repos.TargetInfo = targets?.FirstOrDefault(p => p.ID == itemPos.TargetInfoID);
                            if (itemPos.TargetInfo != null && !string.IsNullOrWhiteSpace(itemPos.TargetInfo.TargeColor))
                            {
                                repos.ColorKey = itemPos.TargetInfo.TargeColor;
                            }
                            repos.BaseTargetName = itemPos.TargetInfo?.TargetName;
                            repos.CheckRes = await db.CheckRes.FirstOrDefaultAsync(p => p.ID == itemPos.CheckResID);
                            repos.BaseCheckType = itemPos.CheckRes?.PosCheckType?.GetEnumDisplayName();
                            repos.CgRes = await db.CgRes.FirstOrDefaultAsync(p => p.ID == itemPos.CgResID);
                            repos.CxRes = await db.CxRes.FirstOrDefaultAsync(p => p.ID == itemPos.CxResID);
                            repos.StationRes = await db.StationRes.FirstOrDefaultAsync(p => p.ID == itemPos.StationResID);
                            posList.Add(repos);
                        }
                    }
                }
                return Success(posList);
            }
            catch (Exception ex)
            {
                string msg = $"定位结果时间范围查询异常.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<RePosRes>>("定位结果时间范围查询异常");
            }
        }
        /// <summary>
        /// 查询最后X小时的的定位结果(此方法内部调用)
        /// </summary>
        /// <param name="dto"><see cref="PosRequestByLastRangeDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        [Obsolete]
        public async Task<AjaxResult<List<PosRes>>> GetPosResByLastHoursObsolete(PosRequestByLastRangeDto dto)
        {
            List<PosRes> posList = new List<PosRes>();
            try
            {
                var dir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DbPart");
                if (!Directory.Exists(dir)) return Success(posList);
                var yearDirs = Directory.EnumerateDirectories(dir).OrderByDescending(p => Convert.ToInt32(new DirectoryInfo(p).Name));//年目录,倒叙排列
                DateTime max = DateTime.MinValue;
                foreach (var yearDir in yearDirs)
                {
                    if (max != DateTime.MinValue) break;
                    //每一天的db文件,倒序排列
                    var dayFiles = Directory.EnumerateFiles(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, yearDir), "*.db").OrderByDescending(p => Convert.ToInt32(new DirectoryInfo(p).Name.Substring(0, 4)));
                    foreach (var dayFile in dayFiles)
                    {
                        using (RHDWPartContext db = RHDWPartContext.GetContext(dayFile))
                        {
                            if (db == null) continue;
                            var query = db.PosRes.Where(p => p.TaskInfoID == dto.TaskInfoID);
                            if (!dto.IncludeInvalidate)
                            {
                                query = query.Where(p => p.PosLon != 999);

                            }
                            if (dto.TarFrequpHz != null && dto.TarFrequpHz > 0)
                            {
                                query = query.Where(p => p.FreqUpHz == dto.TarFrequpHz);
                            }
                            bool any = await query.AnyAsync();
                            if (any)
                                max = await query.MaxAsync(p => p.SigTime);
                        }
                        if (max != DateTime.MinValue)
                        {
                            break;
                        }
                    }
                }
                if (max == DateTime.MinValue) return Success(posList);
                DateTime min = max.AddHours(-dto.Hours);
                var res = await GetPosResByTimeRangeObsolete(new PosRequestByTimeRangeDto()
                {
                    TaskInfoID = dto.TaskInfoID,
                    BeginTime = min,
                    EndTime = max,
                    IncludeInvalidate = dto.IncludeInvalidate,
                    TarFrequpHz = dto.TarFrequpHz,
                });
                return res;
            }
            catch (Exception ex)
            {
                string msg = $"定位结果查询最新数据异常-任务编号:{dto.TaskInfoID},Hours:{dto.Hours}";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<PosRes>>("定位结果查询最新数据异常");
            }
        }
        #endregion

        private PosResDto MapDto(PosRes res)
        {
            return new PosResDto()
            {
                ID = res.ID,
                FreqUpHz = res.FreqUpHz,
                SigTime = res.SigTime,
                TaskInfoID = res.TaskInfoID,
                TarName = res.TargetInfo?.TargetName,
                PosLon = res.PosLon,
                PosLat = res.PosLat,
                MirrLon = res.MirrLon,
                MirrLat = res.MirrLat,
                CheckType = res.CheckRes?.PosCheckType == null ? "" : res.CheckRes?.PosCheckType?.GetEnumDisplayName(),
                TargetState = (EnumTargetStateDto)res.TargetState,
                PosResType = (EnumPosResTypeDto)res.PosResType,
                Confidence = res.Confidence,
                CreateTime = res.CreateTime,
            };
        }

        private List<CgResDto> MapCgDto(List<CgRes> listCg)
        {
            List<CgResDto> list = new List<CgResDto>();
            foreach (CgRes cgRes in listCg)
            {
                var dto = new CgResDto()
                {
                    ID = cgRes.ID,
                    TaskID = cgRes.TaskID,
                    FreqUpHz = cgRes.TarFreqUp == null ? 0 : (long)(cgRes.TarFreqUp.Value),
                    SigTime = cgRes.SigTime,
                    Dto1 = cgRes.Dto1,
                    Dfo1 = cgRes.Dfo1,
                    Snr1 = cgRes.Snr1,
                    Dto2 = cgRes.Dto2,
                    Dfo2 = cgRes.Dfo2,
                    Snr2 = cgRes.Snr2,
                    DtoCdb = cgRes.DtoCdb,
                    DfoCdb = cgRes.DfoCdb,
                    SnrCdb = cgRes.SnrCdb,
                    YbMainDto = cgRes.YbMainDto,
                    YbMainDfo = cgRes.YbMainDfo,
                    YbMainSnr = cgRes.YbMainSnr,
                    YbAdja1Dto = cgRes.YbAdja1Dto,
                    YbAdja1Dfo = cgRes.YbAdja1Dfo,
                    YbAdja1Snr = cgRes.YbAdja1Snr,
                    YbAdja2Dfo = cgRes.YbAdja2Dfo,
                    YbAdja2Dto = cgRes.YbAdja2Dto,
                    YbAdja2Snr = cgRes.YbAdja2Snr,
                    TarFreqUp = cgRes.TarFreqUp,
                    TarFreqDown = cgRes.TarFreqDown,
                    RefFreqUp = cgRes.RefFreqUp,
                    RefFreqDown = cgRes.RefFreqDown,
                    MainCode = cgRes.MainCode,
                    Adja1Code = cgRes.Adja1Code,
                    Adja2Code = cgRes.Adja2Code,
                    MainXlTime = cgRes.MainXlTime,
                    Adja1XlTime = cgRes.Adja1XlTime,
                    Adja2XlTime = cgRes.Adja2XlTime,
                    MainX = cgRes.MainX,
                    MainY = cgRes.MainY,
                    MainZ = cgRes.MainZ,
                    MainVx = cgRes.MainVx,
                    MainVy = cgRes.MainVy,
                    MainVz = cgRes.MainVz,
                    Adja1X = cgRes.Adja1X,
                    Adja1Y = cgRes.Adja1Y,
                    Adja1Z = cgRes.Adja1Z,
                    Adja1Vx = cgRes.Adja1Vx,
                    Adja1Vy = cgRes.Adja1Vy,
                    Adja1Vz = cgRes.Adja1Vz,
                    Adja2X = cgRes.Adja2X,
                    Adja2Y = cgRes.Adja2Y,
                    Adja2Z = cgRes.Adja2Z,
                    Adja2Vx = cgRes.Adja2Vx,
                    Adja2Vy = cgRes.Adja2Vy,
                    Adja2Vz = cgRes.Adja2Vz,
                    SatTxLon = cgRes.StationRes.SatTxLon,
                    SatTxLat = cgRes.StationRes.SatTxLat,
                    CdbTxLon = cgRes.StationRes.CdbTxLon,
                    CdbTxLat = cgRes.StationRes.CdbTxLat,
                    CxLon = cgRes.StationRes.CxLon,
                    CxLat = cgRes.StationRes.CxLat,
                    RefLon = cgRes.StationRes.RefLon,
                    RefLat = cgRes.StationRes.RefLat,
                    CreateTime = cgRes.CreateTime,
                };
                list.Add(dto);
            }
            return list;

        }
    }
}