data-sharing/src/DataSharing/Province/PusherProviderService.cs

using DataSharing.RawData;
using DataSharing.SendTask;
using DataSharing.Share.Dtos.Province;
using DataSharing.Share.Dtos.Province.HuiJu;
using DataSharing.Share.Dtos.Province.XieTong;
using DataSharing.Share.Dtos.Province.XieTong.Receive;
using DataSharing.Share.Enums;
using DotNetCore.CAP;
using MapsterMapper;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System.Net;
using XF.Domain.Dependency;
using XF.Domain.Repository;

namespace DataSharing.Province
{
    public class PusherProviderService : IPusherProviderService, IScopeDependency
    {
        #region 注入
        private readonly IMapper _mapper;
        private readonly ILogger<PusherProviderService> _logger;
        private readonly IChannelConfigurationManager _channelConfigurationManager;
        private readonly IHttpClientFactory _httpClientFactory;
        private readonly XieTongClient _xieTongClient;
        private readonly HuiJuClient _huiJuClient;
        private readonly IRepository<DsSendTask> _dsSendTaskRepository;
        private readonly IRepository<DsSendCaseInfo> _sendCaseInfoRepository;
        private readonly IRepository<DsGetCaseDistrecordSend> _getCaseDistrecordSendRepository;
        private readonly ICapPublisher _capPublisher;
        private readonly IRepository<DsSendTaskInfo> _dsSendTaskInfoRepository;
        private readonly IRepository<DsOrder> _dataOrderRepository;
        private readonly IRepository<DsTelCall> _dsTelCallRepository;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="mapper"></param>
        /// <param name="logger"></param>
        /// <param name="channelConfigurationManager"></param>
        /// <param name="httpClientFactory"></param>
        /// <param name="xieTongClient"></param>
        /// <param name="huiJuClient"></param>
        /// <param name="dsSendTaskRepository"></param>
        /// <param name="sendCaseInfoRepository"></param>
        /// <param name="getCaseDistrecordSendRepository"></param>
        /// <param name="capPublisher"></param>
        /// <param name="dsSendTaskInfoRepository"></param>
        /// <param name="dataOrderRepository"></param>
        public PusherProviderService(IMapper mapper, ILogger<PusherProviderService> logger,
            IChannelConfigurationManager channelConfigurationManager,
            IHttpClientFactory httpClientFactory,
            XieTongClient xieTongClient,
            HuiJuClient huiJuClient,
            IRepository<DsSendTask> dsSendTaskRepository,
            IRepository<DsSendCaseInfo> sendCaseInfoRepository,
            IRepository<DsGetCaseDistrecordSend> getCaseDistrecordSendRepository,
            ICapPublisher capPublisher,
            IRepository<DsSendTaskInfo> dsSendTaskInfoRepository,
            IRepository<DsOrder> dataOrderRepository,
            IRepository<DsTelCall> dsTelCallRepository)
        {
            _mapper = mapper;
            _logger = logger;
            _channelConfigurationManager = channelConfigurationManager;
            _httpClientFactory = httpClientFactory;
            _xieTongClient = xieTongClient;
            _huiJuClient = huiJuClient;
            _dsSendTaskRepository = dsSendTaskRepository;
            _sendCaseInfoRepository = sendCaseInfoRepository;
            _getCaseDistrecordSendRepository = getCaseDistrecordSendRepository;
            _capPublisher = capPublisher;
            _dsSendTaskInfoRepository = dsSendTaskInfoRepository;
            _dataOrderRepository = dataOrderRepository;
            _dsTelCallRepository = dsTelCallRepository;
        }
        #endregion

        /// <summary>
        /// 省平台推送数据
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SendProvinceDataPusher(DsSendTask dto, CancellationToken cancellationToken)
        {
            if (dto is null)
                return;

            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            if (configProvince.SendTaskStartTime != null && configProvince.SendTaskStartTime > dto.GenerationTime)
            {
                dto.IsSuccess = true;
                await _dsSendTaskRepository.UpdateAsync(dto, cancellationToken);
            }
            var name = GetName(dto.Path);

            _logger.LogWarning("省请求参数：" + "--------------" + dto.Request);
            ProvinceResponse result = new();
            if (dto.PathType == EPathType.HuiJu) //汇聚推送
                result = await _huiJuClient.RequestAsync<ProvinceResponse>(configProvince.HuiJu + dto.Path, dto.HttpMethod, dto.Request, cancellationToken);

            else if (dto.PathType == EPathType.XieTong)//协同推送
                result = await _xieTongClient.RequestAsync<ProvinceResponse>(configProvince.XieTong + dto.Path, dto.HttpMethod, dto.Request, cancellationToken);

            else if (dto.PathType == EPathType.File)  //附件
            {
                if (dto != null && dto.FileJson != null && dto.FileJson.Count > 0)
                {
                    var itemFile = dto.FileJson[0];
                    result = await SendFileData(dto.Request, itemFile.FileId, itemFile.FileId, cancellationToken);
                }
            }

            _logger.LogWarning("省接口返回：" + name + "--------------" + Newtonsoft.Json.JsonConvert.SerializeObject(result));

            if (result is not null)
            {
                #region 处理推送任务表，推送明细表
                //写入明细表
                DsSendTaskInfo dsSendTaskInfo = new() { TaskId = dto.Id, Result = result };

                //看看需不需要处理一些信息
                dto.LastTime = DateTime.Now;
                dto.SendTimes = dto.SendTimes + 1;

                if (dto.FirstTime is null)
                    dto.FirstTime = DateTime.Now;

                if (result.ReturnInfo is not null && result.ReturnInfo.Code == "1")
                {
                    dto.IsSuccess = true;
                    dsSendTaskInfo.IsSuccess = true;
                }
                await _dsSendTaskInfoRepository.AddAsync(dsSendTaskInfo, cancellationToken);
                await _dsSendTaskRepository.UpdateAsync(dto, cancellationToken);
                #endregion

                #region 处理工单的推送时间，用于后面计算及时率
                if (dto.TaskType == "SubmitCaseInfo")
                {
                    var dataOrder = System.Text.Json.JsonSerializer.Deserialize<ProvinceListRequest<SubmitCaseInfo>>(dto.Request);
                    if (dataOrder != null && dataOrder.Data != null)
                    {
                        var orderItems = dataOrder.Data.Items;
                        foreach (var item in orderItems)
                        {
                            var dsOrder = await _dataOrderRepository.GetAsync(p => p.ProvinceNo == item.CaseSerial, cancellationToken);
                            if (dsOrder != null)
                            {
                                if (dsOrder.FirstSendProvinceTime is null)
                                    dsOrder.FirstSendProvinceTime = DateTime.Now;

                                dsOrder.LastSendProvinceTime = DateTime.Now;
                                await _dataOrderRepository.UpdateAsync(dsOrder);
                            }
                        }
                    }
                }
                #endregion

                #region 处理通话记录推送时间
                if (dto.TaskType == "SubmitCaseRecord")
                {
                    var telCall = await _dsTelCallRepository.GetAsync(p => p.TaskId == dto.Id, cancellationToken);
                    if (telCall != null)
                    {
                        if (telCall.FirstSendProvinceTime is null)
                            telCall.FirstSendProvinceTime = DateTime.Now;

                        telCall.LastSendProvinceTime = DateTime.Now;
                        await _dsTelCallRepository.UpdateAsync(telCall, cancellationToken);
                    }
                }
                #endregion
            }
        }


        /// <summary>
        /// 拉取12315工单办理信息
        /// </summary>
        /// <param name="CaseSerial"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task GetCaseDistrecordSendPusher(CancellationToken cancellationToken)
        {
            var listSendCaseInfo = await _sendCaseInfoRepository
                    .Queryable()
                    .Where(p => p.IsEnd == false)
                    .OrderBy(p => p.CreationTime)
                    .ToListAsync();
            //处理数据
            if (listSendCaseInfo != null && listSendCaseInfo.Count > 0)
            {
                foreach (var itemData in listSendCaseInfo)
                {
                    GetCaseDistrecordSendInfo distrecordSendInfo = new() { CaseSerial = itemData.CaseSerial };

                    #region 处理请求参数
                    var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                    var request = new ProvinceRequest<GetCaseDistrecordSendInfo>(configProvince.ClientId, configProvince.ClientSecret);
                    request.SetData(distrecordSendInfo);
                    var jsonData = request.ToString();

                    var baseAddress = configProvince.XieTong;
                    if (!baseAddress.EndsWith('/'))
                        baseAddress += "/";

                    var url = baseAddress + "rest/market/get_case_distrecord_send";
                    #endregion

                    var response = await _xieTongClient.RequestAsync<ProvinceDistrecordResponse>(url, "Post", jsonData, cancellationToken);

                    if (response is null || response.status is null || response.custom is null)
                        continue;

                    if (response.status.code != "1")
                        continue;

                    //这里处理业务
                    if (response.custom.STEP_List != null && response.custom.STEP_List.Count > 0)
                    {
                        //这里调用业务接口，推送办理数据
                        List<SharingWorkflowTraceDto> Traces = new();
                        //遍历返回的数据
                        foreach (var item in response.custom.STEP_List)
                        {
                            //检测当前数据是否存在，如果存在不处理，不存在新增到数据库并推送到业务系统
                            if (!await _getCaseDistrecordSendRepository.AnyAsync(p => p.CaseSerial == response.custom.CASE_SERIAL && p.RowGuid == item.RowGuid, cancellationToken))
                            {
                                var tempData = _mapper.Map<DsGetCaseDistrecordSend>(item);
                                await _getCaseDistrecordSendRepository.AddAsync(tempData);

                                Traces.Add(new()
                                {
                                    HandlerName = item.OperatorName,
                                    HandlerOrgName = item.OperatorouName,
                                    HandleTime = item.HandleTime,
                                    Opinion = item.HandleOpinion
                                });
                            }
                        }
                        SharingAddOrderTracesDto addOrderTracesDto = new()
                        {
                            OrderId = itemData.OrderID,
                            Traces = Traces
                        };
                        //往业务系统推送数据
                        await _capPublisher.PublishAsync(DataSharing.Share.Mq.EventNames.SharingOrderAddTraces, addOrderTracesDto, cancellationToken: cancellationToken);
                    }
                }
            }
        }

        /// <summary>
        /// 附件读取以及附件上传 
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="fileName"></param>
        /// <param name="fileId"></param>
        /// <returns></returns>
        private async Task<ProvinceResponse> SendFileData(string request, string fileName, string fileId, CancellationToken cancellationToken)
        {
            //获取配置信息
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var businessFile = _channelConfigurationManager.GetConfigurationBusinessFile();
            byte[] fileContentBytes = null;
            try
            {
                var baseAddress = businessFile.BaseUrl;
                if (!baseAddress.EndsWith('/'))
                    baseAddress += "/";
                string url = string.Format("{0}{1}?Source={2}&Id={3}", baseAddress, businessFile.DownloadUrlAddress, "hotline", fileId);
                using (var client = _httpClientFactory.CreateClient())
                using (var response = await client.GetAsync(url))
                {

                    if (response.StatusCode == HttpStatusCode.OK)
                    {
                        fileName = response.Content.Headers.ContentDisposition.FileNameStar;
                        using var memoryStream = new MemoryStream();
                        await response.Content.CopyToAsync(memoryStream);
                        memoryStream.Seek(0, SeekOrigin.Begin);

                        fileContentBytes = memoryStream.ToArray();
                    }
                }
                if (fileContentBytes != null)
                {
                    //获取附件上传Token
                    string strToken = await _xieTongClient.GetTokenAsync(cancellationToken);
                    Dictionary<string, object> dicParam = new()
                    {
                        { "params",  request } // 第一个接口参数，json格式字符串
                    };

                    // 构造字典文件数据
                    // 接口参数名称为files
                    CFormUpload.FileParameter fileParameter = new CFormUpload.FileParameter("files", fileContentBytes, fileName, null);
                    dicParam.Add(fileName, fileParameter);

                    var baseAddressHuiJu = configProvince.HuiJu;
                    if (!baseAddressHuiJu.EndsWith('/'))
                        baseAddressHuiJu += "/";

                    string strUrl = baseAddressHuiJu + "get_case_material_info";
                    // 上传附件
                    string strResult = CFormUpload.MultipartFormDataPost(strUrl, null, dicParam, strToken);

                    _logger.LogWarning("省接口上传附件返回：--------------" + strResult);

                    if (!string.IsNullOrEmpty(strResult))
                        return JsonConvert.DeserializeObject<ProvinceResponse>(strResult);
                }
                return new ProvinceResponse();
            }
            catch (Exception ex)
            {
                return new ProvinceResponse();
            }
        }

        /// <summary>
        /// 获取接口名称
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        private string GetName(string path)
        {
            string name = "";
            switch (path)
            {
                case "get_case_back_apply":
                    name = "业务协同-退回申请接口";
                    break;
                case "send_supervise_process_info":
                    name = "业务协同-服务工单督办过程接口";
                    break;
                case "send_supervise_result_info":
                    name = "业务协同-服务工单督办结果接口";
                    break;
                case "screen_case_info_send":
                    name = "业务协同-工单发起甄别接口";
                    break;
                case "delay_case_info_send":
                    name = "业务协同-服务工单申请延时接口";
                    break;
                case "submit_case_info":
                    name = "业务汇聚-服务工单受理接口";
                    break;
                case "submit_case_record":
                    name = "业务汇聚-电话记录";
                    break;
                case "get_case_process_receive":
                    name = "业务协同-服务工单交办处理过程接口";
                    break;
                case "submit_case_process":
                    name = "业务汇聚-服务工单处理过程接口";
                    break;
                case "submit_case_total":
                    name = "业务汇聚-统计数据接口";
                    break;
                case "supply_case_info_send":
                    name = "业务协同-上报补充诉求接口";
                    break;
                case "revoke_case_info":
                    name = "业务协同-服务工单撤单接口";
                    break;
                case "remind_case_info":
                    name = "业务协同-服务工单催单接口";
                    break;
                case "get_case_result_receive":
                    name = "业务协同-服务工单交办处理结果接口";
                    break;
                case "zmhd_case_info_public":
                    name = "业务协同-政民互动提交公开";
                    break;
                case "get_knowledge_info_send":
                    name = "业务协同-知识库上报接口";
                    break;
                case "get_knowledge_info_update":
                    name = "业务协同-知识库变更接口";
                    break;
                case "get_knowledge_info_abandon":
                    name = "业务协同-知识库下架接口";
                    break;
                case "sendrealtimestatus":
                    name = "实时服务上报接口";
                    break;
                case "get_visit_info_receive":
                    name = "业务协同-服务工单交办评价接口";
                    break;
                case "submit_visit_info":
                    name = "业务汇聚-服务工单回访评价接口";
                    break;
                case "submit_case_result":
                    name = "业务汇聚-服务工单处理结果接口";
                    break;
                case "submit_case_extends":
                    name = "业务汇聚-服务工单拓展信息接口";
                    break;
                case "send_case_info":
                    name = "业务协同-服务工单上报";
                    break;
                case "get_case_material_info":
                    name = "业务汇聚-材料接口";
                    break;
                default:
                    break;
            }

            return name;
        }
    }
}