DW5S/DW5S.Controller/ResultController.cs

using DW5S.DTO;
using DW5S.Entity;
using DW5S.Repostory;
using DW5S.WebApi;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Serilog;
using System.Linq;

namespace DW5S.Controllers
{
    /// <summary>
    /// 结果查询相关接口
    /// </summary>
    public class ResultController : BaseController
    {
        ILogger logger { get; set; }

        IUnitOfWork unitOfWork { get; set; }
        /// <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 repsPosRes = unitOfWork.OfLong<PosRes>();
                var query = repsPosRes.AsQueryable().Where(p => p.SigTime >= start && p.SigTime <= end && p.TaskID == 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}";
                logger.Error(msg);
                return Error<List<CgResDto>>("参估结果时间范围查询超时");
            }
            catch (Exception ex)
            {
                string msg = $"参估结果时间范围查询异常.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                logger.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 repsPosRes = unitOfWork.OfLong<PosRes>();
                var listFrequp = await repsPosRes.AsQueryable().Where(p => p.TaskID == 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 }).ToList();
                var res2 = (await unitOfWork.Of<TaskSig>().FindAsync(p => p.TaskInfoID == dto.TaskInfoID))
                    .Select(p => new TaskFreqResDto() { FreqUpHz = p.FreqUpHz });

                res.AddRange(res2);
                res= res.DistinctBy(p=>p.FreqUpHz).OrderBy(p => p.FreqUpHz).ToList();
                return Success(res);
            }
            catch (Exception ex)
            {
                string msg = $"定位结果查询异常-任务编号:{dto.TaskInfoID}";
                logger.Error(msg, ex);
                return Error<List<TaskFreqResDto>>("定位结果查询异常");
            }
        }

        /// <summary>
        /// 获取所有执行中的任务
        /// </summary>
        [HttpPost]
        public async Task<AjaxResult<List<TaskQueryResDto>>> GetRunningTasks()
        {
            try
            {
                var repsTask = unitOfWork.Of<TaskInfo>();

                var tasks = await repsTask.AsQueryable().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 = $"查询执行中的任务异常";
                logger.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;

                List<TargetInfo> targets;
                var repsTarget = unitOfWork.Of<TargetInfo>();
                targets = repsTarget.GetAllAsync().Result.ToList();


                var repsPosRes = unitOfWork.OfLong<PosRes>();
                var query = repsPosRes.AsQueryable().Where(p => p.SigTime >= start && p.SigTime <= end && p.TaskID == 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);
                    }
                }
                posList.AddRange(posRes);

                return Success(posList);
            }
            catch (Exception ex)
            {
                string msg = $"定位结果时间范围查询异常.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                logger.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<RePosResDto>>> GetPosCgResByTimeRangeObsolete(PosRequestByTimeRangeDto dto)
        {
            List<RePosResDto> posList = new List<RePosResDto>();
            try
            {
                DateTime start = dto.BeginTime;
                DateTime end = dto.EndTime;

                List<TargetInfo> targets;
                var repsTarget = unitOfWork.Of<TargetInfo>();
                targets = repsTarget.GetAllAsync().Result.ToList();


                var repsPosRes = unitOfWork.OfLong<PosRes>();

                var query = repsPosRes.AsQueryable().Where(p => p.SigTime >= start && p.SigTime <= end && p.TaskID == 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 RePosResDto();
                    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.TaskID;
                    repos.FreqUpHz = itemPos.FrequpHz;
                    repos.StationResID = itemPos.StationResID;
                    repos.CxResID = itemPos.CxResID;
                    repos.CgResID = itemPos.CgResID;
                    repos.CheckResID = itemPos.CheckResID;
                    repos.PosResType = (EnumPosTypeDto)itemPos.PosResType;
                    //repos.TargetState = itemPos.TargetState;
                    var target = targets?.FirstOrDefault(p => p.Id == itemPos.TargetInfoID);
                    if (target != null)
                    {
                        repos.TargetInfo = target.To<TargetInfoDto>();
                    }
                    if (itemPos.TargetInfo != null && !string.IsNullOrWhiteSpace(itemPos.TargetInfo.TargeColor))
                    {
                        repos.ColorKey = itemPos.TargetInfo.TargeColor;
                    }
                    repos.BaseTargetName = itemPos.TargetInfo?.TargetName;
                    var repsCheckRes = unitOfWork.OfLong<CheckRes>();
                    var checkRes = await repsCheckRes.FirstOrDefaultAsync(p => p.Id == itemPos.CheckResID);
                    if (checkRes != null)
                    {
                        repos.CheckRes = checkRes.To<CheckResDto>();
                    }
                    repos.BaseCheckType = itemPos.CheckRes?.PosCheckType?.GetEnumDisplayName();

                    var repsCgRes = unitOfWork.OfLong<CgRes>();
                    var cgRes = await repsCgRes.FirstOrDefaultAsync(p => p.Id == itemPos.CgResID);
                    if (cgRes != null)
                    {
                        repos.CgRes = cgRes.To<CgResDto>();
                    }

                    var repsCxRes = unitOfWork.OfLong<CxRes>();
                    var cxRes = await repsCxRes.FirstOrDefaultAsync(p => p.Id == itemPos.CxResID);
                    if (cxRes != null)
                    {
                        repos.CxRes = cxRes.To<CxResDto>();
                    }

                    var repsstationRes = unitOfWork.OfLong<StationRes>();
                    var stationRes = await repsstationRes.FirstOrDefaultAsync(p => p.Id == itemPos.StationResID);
                    if (stationRes != null)
                    {
                        repos.StationRes = cxRes.To<StationResDto>();
                    }
                    posList.Add(repos);
                }
                return Success(posList);
            }
            catch (Exception ex)
            {
                string msg = $"定位结果时间范围查询异常.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                logger.Error(msg, ex);
                return Error<List<RePosResDto>>("定位结果时间范围查询异常");
            }
        }
        /// <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
            {

                DateTime max = DateTime.MinValue;

                var repsPosRes = unitOfWork.OfLong<PosRes>();

              
                    var query = repsPosRes.AsQueryable().Where(p => p.TaskID == 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) 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}";
                logger.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.TaskID,
                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.FrequpHz,
                    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,
                    Adja1X = cgRes.Adja1X,
                    Adja1Y = cgRes.Adja1Y,
                    //Adja1Z = cgRes.Adja1Z,
                    //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;

        }
    }
}