data-sharing/src/DataSharing.Host/Controllers/HotlineWebController.cs

using DataSharing.HotlineWeb;
using DataSharing.Province;
using DataSharing.RawData;
using DataSharing.SendTask;
using DataSharing.Share.Consts;
using DataSharing.Share.Dtos.HotlineWeb;
using DataSharing.Share.Dtos.WebPortal;
using DotNetCore.CAP;
using Hotline.Share.Dtos;
using MapsterMapper;
using MediatR;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using XF.Domain.Cache;
using XF.Domain.Repository;

namespace DataSharing.Host.Controllers
{
    public class HotlineWebController : BaseController
    {
        private readonly IMapper _mapper;
        private readonly IMediator _mediator;
        private readonly ICapPublisher _capPublisher;
        private readonly IRepository<DsOrder> _dsOrderRepository;
        private readonly IRepository<DsTelCall> _dsTelCallRepository;
        private readonly IRepository<DsSendTask> _taskRepository;
        private readonly IRepository<DsSendTaskInfo> _taskInfoRepository;
        private readonly IRepository<ConfigurationInformation> _configurationInformationRepository;
        private readonly ITypedCache<ConfigurationInformationDto> _configurationInformationCache;
        private readonly IRepository<DsOrderVisitSend> _dsOrderVisitSendRepository;
        private readonly IRepository<DsKnowledgeRawData> _knowledgeRawDataRepository;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="mapper"></param>
        /// <param name="mediator"></param>
        /// <param name="capPublisher"></param>
        /// <param name="dsOrderRepository"></param>
        /// <param name="dsTelCallRepository"></param>
        /// <param name="taskRepository"></param>
        /// <param name="taskInfoRepository"></param>
        /// <param name="configurationInformationRepository"></param>
        /// <param name="configurationInformationCache"></param>
        /// <param name="dsOrderVisitSendRepository"></param>
        /// <param name="knowledgeRawDataRepository"></param>
        public HotlineWebController(IMapper mapper,
            IMediator mediator,
            ICapPublisher capPublisher,
            IRepository<DsOrder> dsOrderRepository,
            IRepository<DsTelCall> dsTelCallRepository,
            IRepository<DsSendTask> taskRepository,
            IRepository<DsSendTaskInfo> taskInfoRepository,
            IRepository<ConfigurationInformation> configurationInformationRepository,
            ITypedCache<ConfigurationInformationDto> configurationInformationCache,
            IRepository<DsOrderVisitSend> dsOrderVisitSendRepository,
            IRepository<DsKnowledgeRawData> knowledgeRawDataRepository
            )
        {
            _mapper = mapper;
            _mediator = mediator;
            _capPublisher = capPublisher;
            _dsOrderRepository = dsOrderRepository;
            _dsTelCallRepository = dsTelCallRepository;
            _taskRepository = taskRepository;
            _taskInfoRepository = taskInfoRepository;
            _configurationInformationRepository = configurationInformationRepository;
            _configurationInformationCache = configurationInformationCache;
            _dsOrderVisitSendRepository = dsOrderVisitSendRepository;
            _knowledgeRawDataRepository = knowledgeRawDataRepository;
        }

        /// <summary>
        /// 查询推送任务
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpGet("getdssendtask")]
        [AllowAnonymous]
        public async Task<PagedDto<DsSendTaskDto>> GetDsSendTask([FromQuery] QuerySendTaskDto dto)
        {
            //数据查询
            RefAsync<int> total = 0;
            var items = await _taskRepository.Queryable()
                .WhereIF(dto.StartTime.HasValue, p => p.CreationTime >= dto.StartTime)
                .WhereIF(dto.EndTime.HasValue, p => p.CreationTime <= dto.EndTime)
                .WhereIF(!string.IsNullOrEmpty(dto.Id), p => p.Id == dto.Id)
                .WhereIF(dto.IsSuccess.HasValue, p => p.IsSuccess == dto.IsSuccess)
                .OrderByDescending(p => p.CreationTime)
                .ToPageListAsync(dto.PageIndex, dto.PageSize, total, HttpContext.RequestAborted);

            return new PagedDto<DsSendTaskDto>(total, _mapper.Map<List<DsSendTaskDto>>(items));
        }

        /// <summary>
        /// 查询任务推送明细
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpGet("getdssendtaskinfo")]
        [AllowAnonymous]
        public async Task<PagedDto<DsSendTaskInfo>> GetDsSendTaskInfo([FromQuery] QuerySendTaskDto dto)
        {
            //数据查询
            RefAsync<int> total = 0;
            var items = await _taskInfoRepository.Queryable()
                .WhereIF(dto.StartTime.HasValue, p => p.CreationTime >= dto.StartTime)
                .WhereIF(dto.EndTime.HasValue, p => p.CreationTime <= dto.EndTime)
                .WhereIF(!string.IsNullOrEmpty(dto.Id), p => p.TaskId == dto.Id)
                .WhereIF(dto.IsSuccess.HasValue, p => p.IsSuccess == dto.IsSuccess)
                .ToPageListAsync(dto.PageIndex, dto.PageSize, total, HttpContext.RequestAborted);
            return new PagedDto<DsSendTaskInfo>(total, items);
        }

        /// <summary>
        /// 根据ID从新推送
        /// </summary>
        /// <param name="id">推送任务Id</param>
        /// <returns></returns>
        [HttpGet("fromnewtasksend")]
        [AllowAnonymous]
        public async Task FromNewTaskSend(string id)
        {
            var dto = await _taskRepository.GetAsync(p => p.Id == id, HttpContext.RequestAborted);
            if (dto != null)
            {
                dto.IsSuccess = false;
                dto.SendTimes = 1;
                await _taskRepository.UpdateAsync(dto, HttpContext.RequestAborted);
            }
            // await _pusherProviderService.SendProvinceDataPusher(dto, HttpContext.RequestAborted);
        }

        /// <summary>
        /// 修改状态为已推送，防止错误数据一直请求
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("updatetasksendstate")]
        [AllowAnonymous]
        public async Task UpdateTaskSendState(string id)
        {
            var dto = await _taskRepository.GetAsync(p => p.Id == id, HttpContext.RequestAborted);
            if (dto != null)
            {
                dto.SendTimes = 7;
                await _taskRepository.UpdateAsync(dto, HttpContext.RequestAborted);
            }
        }

        /// <summary>
        /// 查询工单及时上传列表
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpGet("getorderlist")]
        [AllowAnonymous]
        public async Task<PagedDto<DsOrder>> GetOrderlist([FromQuery] QuerySendTaskDto dto)
        {
            if (!dto.StartTime.HasValue)
                dto.StartTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd 00:00:00"));
            if (!dto.EndTime.HasValue)
                dto.EndTime = dto.StartTime.Value.AddDays(1).AddSeconds(-1);
            else
                dto.EndTime = dto.EndTime.Value.AddDays(1).AddSeconds(-1);

            //数据查询
            RefAsync<int> total = 0;
            var items = await _dsOrderRepository.Queryable()
                .Where(p => p.CreationTime >= dto.StartTime && p.CreationTime <= dto.EndTime)
                .Where(p => p.FirstSendProvinceTime != null)
                .Where(p => p.StartTime != null)
                .Select(p => new
                {
                    p.OrderId,
                    p.OrderNo,
                    p.ProvinceNo,
                    p.WorkflowId,
                    p.ExternalId,
                    p.Password,
                    p.Title,
                    p.FromName,
                    p.Contact,
                    p.Content,
                    p.CaseDate,
                    p.StartTime,
                    p.CallId,
                    p.FirstSendProvinceTime,
                    p.LastSendProvinceTime,
                    p.CaseSource,
                    p.CaseSourceCode,
                    p.HotspotId,
                    p.HotspotName,
                    p.HotspotSpliceName,
                    p.ExpiredTime,
                    p.CaseType,
                    p.CaseTypeCode
                })
                .MergeTable()
                .Select(p => new
                {
                    p.OrderId,
                    p.OrderNo,
                    p.ProvinceNo,
                    p.WorkflowId,
                    p.ExternalId,
                    p.Password,
                    p.Title,
                    p.FromName,
                    p.Contact,
                    p.Content,
                    p.CaseDate,
                    p.StartTime,
                    p.CallId,
                    p.FirstSendProvinceTime,
                    p.LastSendProvinceTime,
                    p.CaseSource,
                    p.CaseSourceCode,
                    p.HotspotId,
                    p.HotspotName,
                    p.HotspotSpliceName,
                    p.ExpiredTime,
                    p.CaseType,
                    p.CaseTypeCode
                })
                .WhereIF(dto.IsSuccess.HasValue && dto.IsSuccess == true, p => SqlFunc.DateDiff(DateType.Second, p.StartTime.Value, p.FirstSendProvinceTime.Value) <= 180)//及时上传
                .WhereIF(dto.IsSuccess.HasValue && dto.IsSuccess == false, p => SqlFunc.DateDiff(DateType.Second, p.StartTime.Value, p.FirstSendProvinceTime.Value) > 180)//不及时上传
                .ToPageListAsync(dto.PageIndex, dto.PageSize, total, HttpContext.RequestAborted);
            return new PagedDto<DsOrder>(total, _mapper.Map<IReadOnlyList<DsOrder>>(items));
        }

        /// <summary>
        /// 查询通话记录及时上传列表
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpGet("getcalllist")]
        [AllowAnonymous]
        public async Task<PagedDto<DsTelCall>> GetCalllist([FromQuery] QuerySendTaskDto dto)
        {
            if (!dto.StartTime.HasValue)
                dto.StartTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd 00:00:00"));
            if (!dto.EndTime.HasValue)
                dto.EndTime = dto.StartTime.Value.AddDays(1).AddSeconds(-1);
            else
                dto.EndTime = dto.EndTime.Value.AddDays(1).AddSeconds(-1);

            RefAsync<int> total = 0;
            var items = await _dsTelCallRepository.Queryable()
                .Where(p => p.CreationTime >= dto.StartTime && p.CreationTime <= dto.EndTime)
                .Where(p => p.FirstSendProvinceTime != null)
                .Where(p => p.OverTime != null)
                .Select(p => new
                {
                    p.CallId,
                    p.CPN,
                    p.CDPN,
                    p.CallDirection,
                    p.TelNo,
                    p.UserName,
                    p.BeginIvrTime,
                    p.EndIvrTime,
                    p.BeginQueueTime,
                    p.EndQueueTime,
                    p.BeginRingTime,
                    p.EndRingTimg,
                    p.AnsweredTime,
                    p.OverTime,
                    p.Duration,
                    p.RingTimes,
                    p.QueueTims,
                    p.OnState,
                    p.RecordingFileUrl,
                    p.ProvinceNo,
                    p.FirstSendProvinceTime,
                    p.LastSendProvinceTime,
                    p.TaskId

                })
                .MergeTable()
                .Select(p => new
                {
                    p.CallId,
                    p.CPN,
                    p.CDPN,
                    p.CallDirection,
                    p.TelNo,
                    p.UserName,
                    p.BeginIvrTime,
                    p.EndIvrTime,
                    p.BeginQueueTime,
                    p.EndQueueTime,
                    p.BeginRingTime,
                    p.EndRingTimg,
                    p.AnsweredTime,
                    p.OverTime,
                    p.Duration,
                    p.RingTimes,
                    p.QueueTims,
                    p.OnState,
                    p.RecordingFileUrl,
                    p.ProvinceNo,
                    p.FirstSendProvinceTime,
                    p.LastSendProvinceTime,
                    p.TaskId

                })
                .WhereIF(dto.IsSuccess.HasValue && dto.IsSuccess == true, p => SqlFunc.DateDiff(DateType.Second, p.OverTime.Value, p.FirstSendProvinceTime.Value) <= 180)//及时
                .WhereIF(dto.IsSuccess.HasValue && dto.IsSuccess == false, p => SqlFunc.DateDiff(DateType.Second, p.OverTime.Value, p.FirstSendProvinceTime.Value) > 180)//不及时
                .ToPageListAsync(dto.PageIndex, dto.PageSize, total, HttpContext.RequestAborted);
            return new PagedDto<DsTelCall>(total, _mapper.Map<IReadOnlyList<DsTelCall>>(items));

        }

        /// <summary>
        /// 查询没匹配到通话记录的电话来源工单
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpGet("getordermatchingcall")]
        [AllowAnonymous]
        public async Task<PagedDto<DsOrder>> GetOrderMatchingCall([FromQuery] QuerySendTaskDto dto)
        {
            if (!dto.StartTime.HasValue)
                dto.StartTime = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd 00:00:00"));
            if (!dto.EndTime.HasValue)
                dto.EndTime = dto.StartTime.Value.AddDays(1).AddSeconds(-1);
            else
                dto.EndTime = dto.EndTime.Value.AddDays(1).AddSeconds(-1);

            RefAsync<int> total = 0;

            var items = await _dsOrderRepository.Queryable()
                .LeftJoin<DsTelCall>((p, o) => p.CallId == o.CallId)
                .Where((p, o) => p.FirstSendProvinceTime >= dto.StartTime && p.FirstSendProvinceTime <= dto.EndTime && p.CaseSourceCode == "RGDH")
                .Where((p, o) => p.FirstSendProvinceTime.HasValue)
                .Where((p, o) => o.CallId == null)
               .ToPageListAsync(dto.PageIndex, dto.PageSize, total, HttpContext.RequestAborted);

            return new PagedDto<DsOrder>(total, _mapper.Map<IReadOnlyList<DsOrder>>(items));
        }

        /// <summary>
        /// 及时率查询
        /// </summary>
        /// <param name="StartDate"></param>
        /// <param name="EndDate"></param>
        /// <returns></returns>
        [HttpGet("calculateuploadrate")]
        [AllowAnonymous]
        public async Task<CalculateUploadRateDto> CalculateUploadRate(DateTime StartDate, DateTime EndDate)
        {
            EndDate = EndDate.AddDays(1).AddSeconds(-1);

            CalculateUploadRateDto calculateUploadRateDto = new();

            //工单
            var orderRate = await _dsOrderRepository.Queryable()
                   .LeftJoin<DsTelCall>((p, o) => p.CallId == o.CallId)
                    .Where((p, o) => p.CreationTime >= StartDate && p.CreationTime <= EndDate && p.FirstSendProvinceTime >= StartDate && p.FirstSendProvinceTime <= EndDate)
                    .Where((p, o) => p.FirstSendProvinceTime.HasValue)
                    .Where((p, o) => p.StartTime.HasValue)
                    .Select((p, o) => new
                    {
                        p.OrderId,
                        p.StartTime,
                        p.FirstSendProvinceTime,
                        p.CaseSourceCode,
                        o.CallId,
                        p.HandleState,
                        p.ExpiredTime,
                        p.ActualHandleTime
                    }).MergeTable()
                    .Select(p => new CalculateUploadRateDto
                    {
                        OrderCountNum = SqlFunc.AggregateSum(SqlFunc.IIF(p.OrderId != null, 1, 0)),//总工单数
                        OrderTimely = SqlFunc.AggregateSum(SqlFunc.IIF(SqlFunc.DateDiff(DateType.Second, p.StartTime.Value, p.FirstSendProvinceTime.Value) <= 180, 1, 0)),//及时
                        OrderNotTimely = SqlFunc.AggregateSum(SqlFunc.IIF(SqlFunc.DateDiff(DateType.Second, p.StartTime.Value, p.FirstSendProvinceTime.Value) > 180, 1, 0)),//为及时

                        RGDHOrderCount = SqlFunc.AggregateSum(SqlFunc.IIF(p.CaseSourceCode == "RGDH", 1, 0)),
                        ContainTel = SqlFunc.AggregateSum(SqlFunc.IIF(p.CaseSourceCode == "RGDH" && p.CallId != null, 1, 0)),//匹配数
                        NotContainTel = SqlFunc.AggregateSum(SqlFunc.IIF(p.CaseSourceCode == "RGDH" && p.CallId == null, 1, 0)),//未匹配数

                        HandleEndOrderNum = SqlFunc.AggregateSum(SqlFunc.IIF(p.HandleState == "办理完成", 1, 0)),//办结件数
                        HandleEndOrderOnTime = SqlFunc.AggregateSum(SqlFunc.IIF(p.HandleState == "办理完成" && p.ExpiredTime < p.ActualHandleTime, 1, 0)),//按时办结件数
                    })
                    .ToListAsync();

            ///电话
            var callRate = await _dsTelCallRepository.Queryable()
              .Where(p => p.OverTime >= StartDate && p.OverTime <= EndDate && p.FirstSendProvinceTime >= StartDate && p.FirstSendProvinceTime <= EndDate)
              .Where(p => p.FirstSendProvinceTime.HasValue)
              .Where(p => p.OverTime.HasValue)
              .Select(p => new
              {
                  p.CallId,
                  p.OverTime,
                  p.FirstSendProvinceTime,
                  p.OnState
              })
              .MergeTable()
               .Select(p => new CalculateUploadRateDto
               {
                   TelCountNum = SqlFunc.AggregateSum(SqlFunc.IIF(p.CallId != null, 1, 0)),//总电话数
                   TelTimely = SqlFunc.AggregateSum(SqlFunc.IIF(SqlFunc.DateDiff(DateType.Second, p.OverTime.Value, p.FirstSendProvinceTime.Value) <= 180, 1, 0)),//及时
                   TelNotTimely = SqlFunc.AggregateSum(SqlFunc.IIF(SqlFunc.DateDiff(DateType.Second, p.OverTime.Value, p.FirstSendProvinceTime.Value) > 180, 1, 0)),//为及时
                   TelConnectCountNum = SqlFunc.AggregateSum(SqlFunc.IIF(p.OnState == "1", 1, 0)),//接通数量
                   TelNotConnectCountNum = SqlFunc.AggregateSum(SqlFunc.IIF(p.OnState != "1", 1, 0)),//未接通数量

               })
               .ToListAsync();

            //回访
            var visitList = await _dsOrderVisitSendRepository.Queryable()
                .Where(p => p.VisitTime >= StartDate && p.VisitTime <= EndDate && p.IsProvince == false && p.FirstSendProvinceTime >= StartDate && p.FirstSendProvinceTime <= EndDate)
                .Select(p => new
                {
                    p.SubjectResultSatifyCode,
                    p.VisitTime,
                    p.IsProvince,
                    p.Source,
                    p.ProvinceNo
                })
                .MergeTable()
                .Select(p => new CalculateUploadRateDto
                {
                    VisitCountNum = SqlFunc.AggregateSum(SqlFunc.IIF(p.SubjectResultSatifyCode != null, 1, 0)),//回访总量
                    SatisfactionCountNum = SqlFunc.AggregateSum(SqlFunc.IIF(p.SubjectResultSatifyCode != null && p.SubjectResultSatifyCode != "2", 1, 0)),//满意数量
                    NotSatisfiedCountNum = SqlFunc.AggregateSum(SqlFunc.IIF(p.SubjectResultSatifyCode != null && p.SubjectResultSatifyCode == "2", 1, 0)),//不满意数量
                })
                .ToListAsync();

            //查询知识总量
            calculateUploadRateDto.KnowledgeCount = await _knowledgeRawDataRepository.Queryable()
                       .Where(p => p.CreationTime >= StartDate && p.CreationTime <= EndDate)
                       .CountAsync();

            //修改知识库量-以第一次上传成功的记录为准
            calculateUploadRateDto.UpdateKnowledgeCount = await _taskRepository.Queryable()
                .Where(p => p.FirstTime >= StartDate && p.FirstTime <= EndDate && p.TaskType == "GetKnowledgeInfoUpdate")
                .Select(p => new
                {
                    p.Id,
                    RowID = SqlFunc.RowNumber($"{p.CreationTime} asc ")
                })
                .MergeTable()
                .Where(p => p.RowID == 1)
                .CountAsync();

            //工单
            if (orderRate != null && orderRate.Count > 0)
            {
                var orderRateData = orderRate[0];
                calculateUploadRateDto.OrderCountNum = orderRateData.OrderCountNum;
                calculateUploadRateDto.OrderTimely = orderRateData.OrderTimely;
                calculateUploadRateDto.OrderNotTimely = orderRateData.OrderNotTimely;
                calculateUploadRateDto.RGDHOrderCount = orderRateData.RGDHOrderCount;
                calculateUploadRateDto.ContainTel = orderRateData.ContainTel;
                calculateUploadRateDto.NotContainTel = orderRateData.NotContainTel;
                calculateUploadRateDto.HandleEndOrderNum = orderRateData.HandleEndOrderNum;
                calculateUploadRateDto.HandleEndOrderOnTime = orderRateData.HandleEndOrderOnTime;
            }

            //电话
            if (callRate != null && callRate.Count > 0)
            {
                var callRateData = callRate[0];
                calculateUploadRateDto.TelCountNum = callRateData.TelCountNum;
                calculateUploadRateDto.TelTimely = callRateData.TelTimely;
                calculateUploadRateDto.TelNotTimely = callRateData.TelNotTimely;
                calculateUploadRateDto.TelConnectCountNum = callRateData.TelConnectCountNum;
                calculateUploadRateDto.TelNotConnectCountNum = callRateData.TelNotConnectCountNum;
            }

            //回访
            if (visitList != null && visitList.Count > 0)
            {
                var visitRateData = visitList[0];
                calculateUploadRateDto.VisitCountNum = visitRateData.VisitCountNum;
                calculateUploadRateDto.SatisfactionCountNum = visitRateData.SatisfactionCountNum;
                calculateUploadRateDto.NotSatisfiedCountNum = visitRateData.NotSatisfiedCountNum;
            }
            return calculateUploadRateDto;
        }

        #region 系统配置

        /// <summary>
        /// 上传数据系统配置-查询详情
        /// </summary>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpGet("info-configurationinformation")]
        public async Task<ConfigurationInformation> GetStandard()
        {
            var sandard = await _configurationInformationRepository.Queryable().FirstAsync();
            if (sandard == null)
            {
                ConfigurationInformation configuration = new()
                {
                    CrntSeatNum = 0,
                    CrntTelNum = 0,
                    SeatNum = 0,
                    SeatHwyNum = 0,
                    MissedCallCount = 0
                };
                var Id = await _configurationInformationRepository.AddAsync(configuration, HttpContext.RequestAborted);
                return await _configurationInformationRepository.GetAsync(Id, HttpContext.RequestAborted);
            }
            return sandard;
        }

        /// <summary>
        /// 上传数据系统配置-修改
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpPut("update-configurationinformation")]
        public async Task UpdateStandard([FromBody] ConfigurationInformationDto dto)
        {
            var standard = await _configurationInformationRepository.GetAsync(dto.Id);
            if (standard != null)
            {
                _mapper.Map(dto, standard);
                await _configurationInformationRepository.UpdateAsync(standard, HttpContext.RequestAborted);
                await _configurationInformationCache.GetOrSetAsync(ConstantSettings.ConfigurationInformationCacheKey, dto, cancellationToken: HttpContext.RequestAborted);
            }
        }
        #endregion
    }
}