DW5S/DW5S.Controller/ResultController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using DW5S.DTO;
using DW5S.Repostory;
using System.IO;
using DW5S.Entity;
using DW5S.WebApi;
using Microsoft.AspNetCore.Mvc;
using Serilog;
using Microsoft.EntityFrameworkCore;

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)
        {
            try
            {
                var query = unitOfWork.Of<PosRes>().AsQueryable();
                query = query.Where(p => p.SigTime >= dto.BeginTime && p.SigTime <= dto.EndTime && 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();
                List<CgResDto> cgList = new List<CgResDto>();
                var listDto = MapCgDto(cgRes);
                cgList.AddRange(listDto);
                return Success(cgList);
            }
            catch (Exception ex)
            {
                string msg = $"参估结果时间范围查询异常.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                logger.Error(ex, msg);
                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)
        {
            try
            {
                var query = unitOfWork.Of<PosRes>().AsQueryable();
                var listFrequp = await query.Where(p => p.TaskInfoID == dto.TaskInfoID).Select(p => p.FreqUpHz).Distinct().ToListAsync();
                var res = listFrequp.Select(p => new TaskFreqResDto() { FreqUpHz = p }).OrderBy(o => o.FreqUpHz).ToList();
                return Success(res);
            }
            catch (Exception ex)
            {
                string msg = $"任务频点查询异常-任务编号:{dto.TaskInfoID}";
                logger.Error(ex, msg);
                return Error<List<TaskFreqResDto>>("任务频点查询异常");
            }
        }

        /// <summary>
        /// 获取所有执行中的任务
        /// </summary>
        [HttpPost]
        public async Task<AjaxResult<List<TaskQueryResDto>>> GetRunningTasks()
        {
            try
            {
                var res = await unitOfWork.Of<TaskInfo>().FindAsync(p => p.TaskState == EnumTaskState.Running);
                var resDto = res.Select(t => new TaskQueryResDto()
                {
                    TaskID = t.Id,
                    PosType = (EnumPosTypeDto)(int)t.PosType,
                    TaskType = (EnumTaskTypeDto)(int)t.TaskType,
                }).ToList();
                return Success(resDto);
            }
            catch (Exception ex)
            {
                string msg = $"查询执行中的任务异常";
                logger.Error(ex, msg);
                return Error<List<TaskQueryResDto>>(msg);
            }
        }

        #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)
        {
            try
            {
                var targets = await unitOfWork.Of<TargetInfo>().GetAllAsync();
                var query = unitOfWork.Of<PosRes>().AsQueryable();
                query = query.Where(p => p.SigTime >= dto.BeginTime && p.SigTime <= dto.EndTime && 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();
                if (targets.Any())
                {
                    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;

                        }
                    }
                }
                return Success(posRes);
            }
            catch (Exception ex)
            {
                string msg = $"定位结果时间范围查询异常.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                logger.Error(ex, msg);
                return Error<List<PosRes>>("定位结果时间范围查询异常");
            }
        }

        /// <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)
        {
            try
            {
                var targets = await unitOfWork.Of<TargetInfo>().GetAllAsync();
                var query = unitOfWork.Of<PosRes>().AsQueryable();
                query = query.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);
                }
                var max = await query.MaxAsync(p => (DateTime?)p.SigTime);
                if (max == null) return Success(new List<PosRes>());
                DateTime min = max.Value.AddHours(-dto.Hours);
                var res = await GetPosResByTimeRangeObsolete(new PosRequestByTimeRangeDto()
                {
                    TaskInfoID = dto.TaskInfoID,
                    BeginTime = min,
                    EndTime = max.Value,
                    IncludeInvalidate = dto.IncludeInvalidate,
                    TarFrequpHz = dto.TarFrequpHz,
                });
                return res;

            }
            catch (Exception ex)
            {
                string msg = $"定位结果查询最新数据异常-任务编号:{dto.TaskInfoID},Hours:{dto.Hours}";
                logger.Error(ex, msg);
                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;

        }
    }
}