hotline/src/Hotline/DataSharing/Province/Services/PusherProviderService.cs

using Hotline.DataSharing.DaoShu110;
using Hotline.DataSharing.DataExchange;
using Hotline.DataSharing.Enterprise;
using Hotline.DataSharing.Order;
using Hotline.DataSharing.Province.Extend;
using Hotline.DataSharing.Province.HuiJu.Send;
using Hotline.DataSharing.Province.Notifications;
using Hotline.DataSharing.Province.Other;
using Hotline.DataSharing.Province.XieTong.Knowledge;
using Hotline.DataSharing.Province.XieTong.Receive;
using Hotline.DataSharing.Province.XieTong.Send;
using Hotline.Share.Dtos.DataSharing.Province;
using Hotline.Share.Dtos.DataSharing.Province.XieTong.Knowledge;
using Hotline.Share.Dtos.DataSharing.Province.XieTong.Receive;
using Hotline.Share.Dtos.DataSharing.Province.XieTong.Send;
using Hotline.Share.Dtos.FlowEngine.Workflow;
using Hotline.Users;
using MapsterMapper;
using MediatR;
using Newtonsoft.Json;
using Sharing.Province.Dtos.HuiJu.Send;
using System.Collections.Generic;
using System.Net;
using System.Threading;
using XF.Domain.Dependency;
using XF.Domain.Repository;

namespace Hotline.DataSharing.Province.Services
{
    public class PusherProviderService : IPusherProviderService, IScopeDependency
    {
        #region 注入
        private readonly IRepository<DsSubmitCaseInfo> _submitCaseInfoRepository;
        private readonly IMapper _mapper;
        private readonly IMediator _mediator;
        private readonly IRepository<DsPoliceSendChainAlarmDs> _policeSendChainAlarmDsRepository;
        private readonly IRepository<DsSubmitVisitInfo> _submitVisitInfoRepository;
        private readonly IRepository<DsWaitingPushData> _waitingPushDataRepository;
        private readonly IRepository<DsSubmitCaseProcess> _submitCaseProcessRepository;
        private readonly IRepository<DsPoliceSendChainDealDs> _policeSendChainDealDsRepository;
        private readonly IRepository<DsSubmitCaseResult> _submitCaseResultRepository;
        private readonly IRepository<DsReceiveCaseExtends> _receiveCaseExtendsRepository;
        private readonly IRepository<DsFormEnvironMent> _formEnvironMentRepository;
        private readonly IRepository<DsFormTraffic> _formTrafficRepository;
        private readonly IRepository<DsFormExpressWay> _formExpressWayRepository;
        private readonly IRepository<DsFormMedical> _formMedicalRepository;
        private readonly IRepository<DsFormNetWorktec> _formNetWorktecRepository;
        private readonly IRepository<DsFormPost> _formPostRepository;
        private readonly IRepository<DsFormReturnexChange> _formReturnexChangeRepository;
        private readonly IRepository<DsFormShamPub> _formShamPubRepository;
        private readonly IRepository<DsFormTaxationComplaint> _formTaxationComplaintRepository;
        private readonly IRepository<DsFormTaxationConsulting> _formTaxationConsultingRepository;
        private readonly IRepository<DsFormMarket> _formMarketRepository;
        private readonly IRepository<DsDataWorkOrderSend> _dataWorkOrderSendRepository;
        private readonly IRepository<DsCityDataSend> _cityDataSendRepository;
        private readonly IRepository<DsSendCaseInfo> _sendCaseInfoRepository;
        private readonly IRepository<DsGetCaseMaterialInfo> _getCaseMaterialInfoRepository;
        private readonly IRepository<DsGetCaseResultReceive> _getCaseResultReceiveRepository;
        private readonly IRepository<DsGetCaseProcessReceive> _getCaseProcessReceiveRepository;
        private readonly IRepository<DsGetVisitInfoReceive> _getVisitInfoReceiveRepository;
        private readonly IRepository<DsGetCaseBackApply> _getCaseBackApplyRepository;
        private readonly IRepository<DsDelayCaseInfoSend> _delayCaseInfoSendRepository;
        private readonly IRepository<DsSendSuperviseProcessInfo> _sendSuperviseProcessInfoRepository;
        private readonly IRepository<DsSendSuperviseResultInfo> _sendSuperviseResultInfoRepository;
        private readonly IRepository<DsSubmitCaseRecord> _submitCaseRecordRepository;
        private readonly IRepository<DsSubmitCaseTotal> _submitCaseTotalRepository;
        private readonly IRepository<DsSupplyCaseInfoSend> _supplyCaseInfoSendRepository;
        private readonly IRepository<DsRevokeCaseInfo> _revokeCaseInfoRepository;
        private readonly IRepository<DsRemindCaseInfo> _remindCaseInfoRepository;
        private readonly IRepository<DsGetKnowledgeInfoSend> _getKnowledgeInfoSendRepository;
        private readonly IRepository<DsGetKnowledgeInfoUpdate> _getKnowledgeInfoUpdateRepository;
        private readonly IRepository<DsGetKnowledgeInfoAbandon> _getKnowledgeInfoAbandonRepository;
        private readonly IRepository<DsSendRealTimeStatus> _sendRealTimeStatusRepository;
        private readonly IRepository<DsScreenCaseInfoSend> _screenCaseInfoSendRepository;
        private readonly IRepository<DsZmhdCaseInfoPublic> _zMHDCaseInfoPublicRepository;
        private readonly IRepository<DsKnowledgeRawData> _knowledgeRawDataRepository;
        private readonly IChannelConfigurationManager _channelConfigurationManager;
        private readonly IRepository<DsOrder> _dataOrderRepository;
        private readonly IRepository<DsOrderWorkFlow> _dataOrderWorkFlowRepository;
        private readonly PusherProvider _pusherProvider;
        private readonly IHttpClientFactory _httpClientFactory;
        private readonly IRepository<DsGetCaseDistrecordSend> _getCaseDistrecordSendRepository;
        private readonly XieTongClient _xieTongClient;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="submitCaseInfoRepository"></param>
        /// <param name="mapper"></param>
        /// <param name="mediator"></param>
        /// <param name="policeSendChainAlarmDsRepository"></param>
        /// <param name="submitVisitInfoRepository"></param>
        /// <param name="waitingPushDataRepository"></param>
        /// <param name="submitCaseProcessRepository"></param>
        /// <param name="policeSendChainDealDsRepository"></param>
        /// <param name="submitCaseResultRepository"></param>
        /// <param name="receiveCaseExtendsRepository"></param>
        /// <param name="formEnvironMentRepository"></param>
        /// <param name="formTrafficRepository"></param>
        /// <param name="formExpressWayRepository"></param>
        /// <param name="formMedicalRepository"></param>
        /// <param name="formNetWorktecRepository"></param>
        /// <param name="formPostRepository"></param>
        /// <param name="formReturnexChangeRepository"></param>
        /// <param name="formShamPubRepository"></param>
        /// <param name="formTaxationComplaintRepository"></param>
        /// <param name="formTaxationConsultingRepository"></param>
        /// <param name="formMarketRepository"></param>
        /// <param name="dataWorkOrderSendRepository"></param>
        /// <param name="cityDataSendRepository"></param>
        /// <param name="sendCaseInfoRepository"></param>
        /// <param name="getCaseMaterialInfoRepository"></param>
        /// <param name="getCaseResultReceiveRepository"></param>
        /// <param name="getCaseProcessReceiveRepository"></param>
        /// <param name="getVisitInfoReceiveRepository"></param>
        /// <param name="getCaseBackApplyRepository"></param>
        /// <param name="delayCaseInfoSendRepository"></param>
        /// <param name="sendSuperviseProcessInfoRepository"></param>
        /// <param name="sendSuperviseResultInfoRepository"></param>
        /// <param name="submitCaseRecordRepository"></param>
        /// <param name="submitCaseTotalRepository"></param>
        /// <param name="supplyCaseInfoSendRepository"></param>
        /// <param name="revokeCaseInfoRepository"></param>
        /// <param name="remindCaseInfoRepository"></param>
        /// <param name="getKnowledgeInfoSendRepository"></param>
        /// <param name="getKnowledgeInfoUpdateRepository"></param>
        /// <param name="getKnowledgeInfoAbandonRepository"></param>
        /// <param name="sendRealTimeStatusRepository"></param>
        /// <param name="screenCaseInfoSendRepository"></param>
        /// <param name="zMHDCaseInfoPublicRepository"></param>
        /// <param name="knowledgeRawDataRepository"></param>
        /// <param name="channelConfigurationManager"></param>
        /// <param name="dataOrderRepository"></param>
        /// <param name="dataOrderWorkFlowRepository"></param>
        /// <param name="pusherProvider"></param>
        /// <param name="httpClientFactory"></param>
        /// <param name="getCaseDistrecordSendRepository"></param>
        /// <param name="xieTongClient"></param>
        public PusherProviderService(IRepository<DsSubmitCaseInfo> submitCaseInfoRepository,
          IMapper mapper,
          IMediator mediator,
          IRepository<DsPoliceSendChainAlarmDs> policeSendChainAlarmDsRepository,
          IRepository<DsSubmitVisitInfo> submitVisitInfoRepository,
          IRepository<DsWaitingPushData> waitingPushDataRepository,
          IRepository<DsSubmitCaseProcess> submitCaseProcessRepository,
          IRepository<DsPoliceSendChainDealDs> policeSendChainDealDsRepository,
          IRepository<DsSubmitCaseResult> submitCaseResultRepository,
          IRepository<DsReceiveCaseExtends> receiveCaseExtendsRepository,
          IRepository<DsFormEnvironMent> formEnvironMentRepository,
          IRepository<DsFormTraffic> formTrafficRepository,
          IRepository<DsFormExpressWay> formExpressWayRepository,
          IRepository<DsFormMedical> formMedicalRepository,
          IRepository<DsFormNetWorktec> formNetWorktecRepository,
          IRepository<DsFormPost> formPostRepository,
          IRepository<DsFormReturnexChange> formReturnexChangeRepository,
          IRepository<DsFormShamPub> formShamPubRepository,
          IRepository<DsFormTaxationComplaint> formTaxationComplaintRepository,
          IRepository<DsFormTaxationConsulting> formTaxationConsultingRepository,
          IRepository<DsFormMarket> formMarketRepository,
          IRepository<DsDataWorkOrderSend> dataWorkOrderSendRepository,
          IRepository<DsCityDataSend> cityDataSendRepository,
          IRepository<DsSendCaseInfo> sendCaseInfoRepository,
          IRepository<DsGetCaseMaterialInfo> getCaseMaterialInfoRepository,
           IRepository<DsGetCaseResultReceive> getCaseResultReceiveRepository,
          IRepository<DsGetCaseProcessReceive> getCaseProcessReceiveRepository,
          IRepository<DsGetVisitInfoReceive> getVisitInfoReceiveRepository,
          IRepository<DsGetCaseBackApply> getCaseBackApplyRepository,
          IRepository<DsDelayCaseInfoSend> delayCaseInfoSendRepository,
          IRepository<DsSendSuperviseProcessInfo> sendSuperviseProcessInfoRepository,
          IRepository<DsSendSuperviseResultInfo> sendSuperviseResultInfoRepository,
          IRepository<DsSubmitCaseRecord> submitCaseRecordRepository,
          IRepository<DsSubmitCaseTotal> submitCaseTotalRepository,
          IRepository<DsSupplyCaseInfoSend> supplyCaseInfoSendRepository,
          IRepository<DsRevokeCaseInfo> revokeCaseInfoRepository,
          IRepository<DsRemindCaseInfo> remindCaseInfoRepository,
          IRepository<DsGetKnowledgeInfoSend> getKnowledgeInfoSendRepository,
          IRepository<DsGetKnowledgeInfoUpdate> getKnowledgeInfoUpdateRepository,
          IRepository<DsGetKnowledgeInfoAbandon> getKnowledgeInfoAbandonRepository,
          IRepository<DsSendRealTimeStatus> sendRealTimeStatusRepository,
          IRepository<DsScreenCaseInfoSend> screenCaseInfoSendRepository,
          IRepository<DsZmhdCaseInfoPublic> zMHDCaseInfoPublicRepository,
          IRepository<DsKnowledgeRawData> knowledgeRawDataRepository,
          IChannelConfigurationManager channelConfigurationManager,
          IRepository<DsOrder> dataOrderRepository,
          IRepository<DsOrderWorkFlow> dataOrderWorkFlowRepository,
          PusherProvider pusherProvider,
          IHttpClientFactory httpClientFactory,
          IRepository<DsGetCaseDistrecordSend> getCaseDistrecordSendRepository,
          XieTongClient xieTongClient)
        {
            _submitCaseInfoRepository = submitCaseInfoRepository;
            _mapper = mapper;
            _mediator = mediator;
            _policeSendChainAlarmDsRepository = policeSendChainAlarmDsRepository;
            _submitVisitInfoRepository = submitVisitInfoRepository;
            _waitingPushDataRepository = waitingPushDataRepository;
            _submitCaseProcessRepository = submitCaseProcessRepository;
            _policeSendChainDealDsRepository = policeSendChainDealDsRepository;
            _submitCaseResultRepository = submitCaseResultRepository;
            _receiveCaseExtendsRepository = receiveCaseExtendsRepository;
            _formEnvironMentRepository = formEnvironMentRepository;
            _formTrafficRepository = formTrafficRepository;
            _formExpressWayRepository = formExpressWayRepository;
            _formMedicalRepository = formMedicalRepository;
            _formNetWorktecRepository = formNetWorktecRepository;
            _formPostRepository = formPostRepository;
            _formReturnexChangeRepository = formReturnexChangeRepository;
            _formShamPubRepository = formShamPubRepository;
            _formTaxationComplaintRepository = formTaxationComplaintRepository;
            _formTaxationConsultingRepository = formTaxationConsultingRepository;
            _formMarketRepository = formMarketRepository;
            _dataWorkOrderSendRepository = dataWorkOrderSendRepository;
            _cityDataSendRepository = cityDataSendRepository;
            _sendCaseInfoRepository = sendCaseInfoRepository;
            _getCaseMaterialInfoRepository = getCaseMaterialInfoRepository;
            _getCaseResultReceiveRepository = getCaseResultReceiveRepository;
            _getCaseProcessReceiveRepository = getCaseProcessReceiveRepository;
            _getVisitInfoReceiveRepository = getVisitInfoReceiveRepository;
            _getCaseBackApplyRepository = getCaseBackApplyRepository;
            _delayCaseInfoSendRepository = delayCaseInfoSendRepository;
            _sendSuperviseProcessInfoRepository = sendSuperviseProcessInfoRepository;
            _sendSuperviseResultInfoRepository = sendSuperviseResultInfoRepository;
            _submitCaseRecordRepository = submitCaseRecordRepository;
            _submitCaseTotalRepository = submitCaseTotalRepository;
            _supplyCaseInfoSendRepository = supplyCaseInfoSendRepository;
            _revokeCaseInfoRepository = revokeCaseInfoRepository;
            _remindCaseInfoRepository = remindCaseInfoRepository;
            _getKnowledgeInfoSendRepository = getKnowledgeInfoSendRepository;
            _getKnowledgeInfoUpdateRepository = getKnowledgeInfoUpdateRepository;
            _getKnowledgeInfoAbandonRepository = getKnowledgeInfoAbandonRepository;
            _sendRealTimeStatusRepository = sendRealTimeStatusRepository;
            _screenCaseInfoSendRepository = screenCaseInfoSendRepository;
            _zMHDCaseInfoPublicRepository = zMHDCaseInfoPublicRepository;
            _knowledgeRawDataRepository = knowledgeRawDataRepository;
            _channelConfigurationManager = channelConfigurationManager;
            _dataOrderRepository = dataOrderRepository;
            _dataOrderWorkFlowRepository = dataOrderWorkFlowRepository;
            _pusherProvider = pusherProvider;
            _httpClientFactory = httpClientFactory;
            _getCaseDistrecordSendRepository = getCaseDistrecordSendRepository;
            _xieTongClient = xieTongClient;
        }
        #endregion

        /// <summary>
        /// 向省上推送工单数据请求
        /// </summary>
        /// <param name="submitCaseInfo"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task ProvinceOrderCreatedPusher(List<DsSubmitCaseInfo> submitCaseInfo, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<List<CaseInfo>>(submitCaseInfo);
            var request = new SubmitCaseInfoRequest();

            request.ForeachClass(dataReceive);

            var data = new SubmitCaseInfoData
            {
                CaseInfos = dataReceive
            };

            request.SetData(data);

            var response = await pusher.PushOrderCreatedAsync(request, cancellationToken);
            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response != null)
                {
                    List<ErrorInfo> list = new();
                    if (response.custom != null && response.custom.errorObjs != null && response.custom.errorObjs.Count > 0)
                    {
                        list = response.custom.errorObjs;
                    }
                    foreach (var item in submitCaseInfo)
                    {
                        if (list != null && list.Count > 0)
                        {
                            if (list.Find(p => p.caseid == item.CaseSerial) != null)
                                item.SyncState = "2";
                            else
                                item.SyncState = "1";
                        }
                        else
                            item.SyncState = "1";

                        await _submitCaseInfoRepository.UpdateAsync(item, cancellationToken);

                        //处理同步记录
                        await UpdateWaitingPushData(item.Id, item.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);

                    }
                }
            }
        }

        /// <summary>
        /// 服务工单交办评价请求
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task GetVisitInfoReceivePusher(DsGetVisitInfoReceive data, CancellationToken cancellationToken)
        {
            //信息上报
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<GetVisitInfoReceiveInfo>(data);

            var request = new GetVisitInfoReceiveRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushGetVisitInfoReceiveAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    data.SyncState = "1";
                else
                    data.SyncState = "2";

                data.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _getVisitInfoReceiveRepository.UpdateAsync(data, cancellationToken);

                //处理同步记录
                await UpdateWaitingPushData(data.Id, data.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);

            }
        }

        /// <summary>
        /// 上传通话记录
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SubmitCaseRecordPusher(List<DsSubmitCaseRecord> dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<List<CaseRecord>>(dto);
            var request = new SubmitCaseRecordRequest();

            foreach (var item in dataReceive)
                request.ForeachClass(item);

            request.SetData(new SubmitCaseRecordData
            {
                CaseRecords = dataReceive
            });

            var response = await pusher.PushSubmitCaseRecordAsync(request, cancellationToken);
            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response != null)
                {
                    List<ErrorInfo> list = new();
                    if (response.custom != null && response.custom.errorObjs != null && response.custom.errorObjs.Count > 0)
                    {
                        list = response.custom.errorObjs;
                    }
                    foreach (var item in dto)
                    {
                        if (list != null && list.Count > 0)
                        {
                            if (list.Find(p => p.caseid == item.CaseSerial) != null)
                                item.SyncState = "2";
                            else
                                item.SyncState = "1";
                        }
                        else
                            item.SyncState = "1";

                        await _submitCaseRecordRepository.UpdateAsync(item, cancellationToken);

                        //处理同步记录
                        await UpdateWaitingPushData(item.Id, item.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);

                    }
                }
            }
            ////如果推送成功修改数据状态
            //if (response != null)
            //{
            //    //if (response.Code == "1")
            //    //    notification.DataOrder.SyncState = "1";
            //    //else
            //    //    notification.DataOrder.SyncState = "2";

            //    //notification.DataOrder.ReturnResult =  System.Text.Json.JsonSerializer.Serialize(response);
            //    //await _submitCaseRecordRepository.UpdateAsync(notification.DataOrder);
            //}
        }

        /// <summary>
        /// 服务工单拓展信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SubmitCaseExtendsPusher(SubmitCaseExtendsInfoId dto, CancellationToken cancellationToken)
        {
            if (dto != null && dto.Info != null)
            {
                var data = dto.Info;
                var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

                var request = new SubmitCaseExtendsRequest();
                //扩展信息时间处理
                switch (data.FormType.ToLower())
                {
                    case "yl"://医疗表单
                        request.ForeachClass(data.FormMedical);
                        break;
                    case "zwfw"://四川政务服务网技术工单
                        request.ForeachClass(data.FormNetWorktec);
                        break;
                    case "th"://电视购物及商铺购买退换货工单
                        request.ForeachClass(data.FormReturnexChange);
                        break;
                    case "gsgl"://高速公路工单
                        request.ForeachClass(data.FormExpressWay);
                        break;
                    case "xjgg"://电视台虚假广告工单
                        request.ForeachClass(data.FormShamPub);
                        break;
                    case "swfwsq"://12366热线诉求交办
                        request.ForeachClass(data.FormTaxationComplaint);
                        break;
                    case "swfwzx"://12366热线咨询交办
                        request.ForeachClass(data.FormTaxationConsulting);
                        break;
                    case "jtfwjd"://12328服务监督
                        request.ForeachClass(data.FormTraffic);
                        break;
                    case "yzxf"://邮政业消费者申诉
                        request.ForeachClass(data.FormPost);
                        break;
                    case "hbjb"://环保举报业务
                        request.ForeachClass(data.FormEnvironMent);
                        break;
                    case "scjgj"://12315个性化表单
                        request.ForeachClass(data.FormMarket);
                        break;
                    default:
                        break;
                }

                request.SetData(data);

                var response = await pusher.PushSubmitCaseExtendsAsync(request, cancellationToken);

                //如果推送成功修改数据状态
                if (response != null)
                {
                    var caseInfo = await _receiveCaseExtendsRepository.GetAsync(p => p.Id == dto.Id, cancellationToken);
                    if (caseInfo != null)
                    {
                        if (response.Code == "1")
                            caseInfo.SyncState = "1";
                        else
                            caseInfo.SyncState = "2";

                        caseInfo.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                        await _receiveCaseExtendsRepository.UpdateAsync(caseInfo, cancellationToken);
                        //处理同步记录
                        await UpdateWaitingPushData(caseInfo.Id, caseInfo.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);

                    }
                }
            }
        }

        /// <summary>
        /// 往省上派单
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SendCaseInfoDataPusher(DsSendCaseInfo dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<SendCaseInfoInfo>(dto);

            var request = new SendCaseInfoRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushSendCaseInfoAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _sendCaseInfoRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);

            }
        }

        /// <summary>
        /// 服务工单交办处理过程
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task GetCaseProcessReceivePusher(DsGetCaseProcessReceive dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<GetCaseProcessReceiveInfo>(dto);

            var request = new GetCaseProcessReceiveRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushGetCaseProcessReceiveAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _getCaseProcessReceiveRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单交办处理结果
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task GetCaseResultReceivePusher(DsGetCaseResultReceive dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);
            var dataReceive = _mapper.Map<GetCaseResultReceiveInfo>(dto);
            var request = new GetCaseResultReceiveRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushGetCaseResultReceiveAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = Newtonsoft.Json.JsonConvert.SerializeObject(response);
                await _getCaseResultReceiveRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 退回申请请求
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task GetCaseBackApplyPusher(DsGetCaseBackApply dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<GetCaseBackApplyInfo>(dto);

            var request = new GetCaseBackApplyRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushGetCaseBackApplyAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _getCaseBackApplyRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单督办过程
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SendSuperviseProcessInfoPusher(DsSendSuperviseProcessInfo dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<SendSuperviseProcessInfoInfo>(dto);

            var request = new SendSuperviseProcessInfoRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushSendSuperviseProcessInfoAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _sendSuperviseProcessInfoRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单督办结果
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SendSuperviseResultInfoPusher(DsSendSuperviseResultInfo dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<SendSuperviseResultInfoInfo>(dto);

            var request = new SendSuperviseResultInfoRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushSendSuperviseResultInfoAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _sendSuperviseResultInfoRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 工单发起甄别
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task ScreenCaseInfoSendPusher(DsScreenCaseInfoSend dto, CancellationToken cancellationToken)
        {
            //推送数据
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<ScreenCaseInfoSendInfo>(dto);

            var request = new ScreenCaseInfoSendRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushScreenCaseInfoSendAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _screenCaseInfoSendRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单催单
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SendRemindCaseInfoPusher(DsRemindCaseInfo dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<RemindCaseInfoInfo>(dto);

            var request = new SendRemindCaseInfoRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushSendRemindCaseInfoAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _remindCaseInfoRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 知识库上报
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task GetKnowledgeInfoSendPusher(DsGetKnowledgeInfoSend dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<KnowledgeInfoSendInfo>(dto);

            var request = new GetKnowledgeInfoSendRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushGetKnowledgeInfoSendAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _getKnowledgeInfoSendRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 知识库变更
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task GetKnowledgeInfoUpdatePusher(DsGetKnowledgeInfoUpdate dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<GetKnowledgeInfoUpdateInfo>(dto);

            var request = new GetKnowledgeInfoUpdateRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushGetKnowledgeInfoUpdateAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _getKnowledgeInfoUpdateRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 知识库下架
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task GetKnowledgeInfoAbandonPusher(DsGetKnowledgeInfoAbandon dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<GetKnowledgeInfoAbandonInfo>(dto);

            var request = new GetKnowledgeInfoAbandonRequest();

            request.ForeachClass(dataReceive);

            request.SetData(dataReceive);

            var response = await pusher.PushGetKnowledgeInfoAbandonAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _getKnowledgeInfoAbandonRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 实时服务上报
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SendRealTimeStatusPusher(DsSendRealTimeStatus dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<SendRealTimeStatusInfo>(dto);

            var request = new SendRealTimeStatusRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushSendRealTimeStatusAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _sendRealTimeStatusRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单申请延时
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task DelayCaseInfoSendPusher(DsDelayCaseInfoSend dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<DelayCaseInfoSendInfo>(dto);

            var request = new DelayCaseInfoSendRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushDelayCaseInfoSendAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _delayCaseInfoSendRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 政民互动提交公开
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task ZmhdCaseInfoPublicPusher(DsZmhdCaseInfoPublic dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<ZmhdCaseInfoPublicInfo>(dto);

            var request = new ZmhdCaseInfoPublicRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushZMHDCaseInfoPublicAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _zMHDCaseInfoPublicRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 统计数据
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SubmitCaseTotalPusher(DsSubmitCaseTotal dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<CaseTotal>(dto);

            var request = new SubmitCaseTotalRequest();

            request.ForeachClass(dataReceive);

            var data = new SubmitCaseTotalData
            {
                CaseTotals = new List<CaseTotal>
                {
                    dataReceive
                }
            };
            request.SetData(data);

            var response = await pusher.PushSubmitCaseTotalAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _submitCaseTotalRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 上报补充诉求
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SupplyCaseInfoSendPusher(DsSupplyCaseInfoSend dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<SupplyCaseInfoSendInfo>(dto);

            var request = new SupplyCaseInfoSendRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushSupplyCaseInfoSendAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _supplyCaseInfoSendRepository.UpdateAsync(dto, cancellationToken);
                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单撤单
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SendRevokeCaseInfoPusher(DsRevokeCaseInfo dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<RevokeCaseInfoInfo>(dto);

            var request = new SendRevokeCaseInfoRequest();
            request.ForeachClass(dataReceive);
            request.SetData(dataReceive);

            var response = await pusher.PushRevokeCaseInfoAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response.Code == "1")
                    dto.SyncState = "1";
                else
                    dto.SyncState = "2";

                dto.ReturnResult = System.Text.Json.JsonSerializer.Serialize(response);
                await _revokeCaseInfoRepository.UpdateAsync(dto, cancellationToken);

                //处理同步记录
                await UpdateWaitingPushData(dto.Id, dto.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单处理过程
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SubmitCaseProcessPusher(List<DsSubmitCaseProcess> dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<List<CaseProcess>>(dto);

            var request = new SubmitCaseProcessRequest();

            foreach (var item in dataReceive)
            {
                request.ForeachClass(item);
            }
            var data = new SubmitCaseProcessData
            {
                CaseProcesss = dataReceive
            };
            request.SetData(data);

            var response = await pusher.PushSubmitCaseProcessAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                if (response != null)
                {
                    List<ErrorInfo> list = new();
                    if (response.custom != null && response.custom.errorObjs != null && response.custom.errorObjs.Count > 0)
                    {
                        list = response.custom.errorObjs;
                    }
                    foreach (var item in dto)
                    {
                        if (list != null && list.Count > 0)
                        {
                            if (list.Find(p => p.caseid == item.CaseId) != null)
                                item.SyncState = "2";
                            else
                                item.SyncState = "1";
                        }
                        else
                            item.SyncState = "1";

                        await _submitCaseProcessRepository.UpdateAsync(item, cancellationToken);

                        //处理同步记录
                        await UpdateWaitingPushData(item.Id, item.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
                    }
                }
            }
        }

        /// <summary>
        /// 服务工单处理结果
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SubmitCaseResultPusher(List<DsSubmitCaseResult> dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<List<CaseResult>>(dto);

            var request = new SubmitCaseResultRequest();

            foreach (var item in dataReceive)
            {
                request.ForeachClass(dataReceive);
                var dataOrder = await _dataOrderRepository.GetAsync(p => p.ProvinceNo == item.CaseSerial, cancellationToken);
                if (dataOrder != null)
                {
                    if (dataOrder.FirstSyncResultTime == null || dataOrder.FirstSyncResultTime is null)
                    {
                        dataOrder.FirstSyncResultTime = DateTime.Now;
                    }
                    dataOrder.NewSyncResultTime = DateTime.Now;
                    dataOrder.NewSyncResultReplyTime = item.FinishTime;
                    dataOrder.AllDuration = item.HandleTimeLong * 60;

                    await _dataOrderRepository.UpdateAsync(dataOrder, cancellationToken);
                }
            }
            var data = new SubmitCaseResultData
            {
                CaseResults = dataReceive
            };
            request.SetData(data);

            var response = await pusher.PushSubmitCaseResultAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                List<ErrorInfo> list = new();
                if (response.custom != null && response.custom.errorObjs != null && response.custom.errorObjs.Count > 0)
                {
                    list = response.custom.errorObjs;
                }
                foreach (var item in dto)
                {
                    if (list != null && list.Count > 0)
                    {
                        if (list.Find(p => p.caseserial == item.CaseSerial) != null)
                            item.SyncState = "2";
                        else
                            item.SyncState = "1";
                    }
                    else
                        item.SyncState = "1";

                    await _submitCaseResultRepository.UpdateAsync(item, cancellationToken);

                    //处理同步记录
                    await UpdateWaitingPushData(item.Id, item.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
                }
            }
        }

        /// <summary>
        /// 服务工单回访评价
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task SubmitVisitInfoPusher(List<DsSubmitVisitInfo> dto, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var dataReceive = _mapper.Map<List<VisitInfo>>(dto);

            var request = new SubmitVisitInfoRequest();
            foreach (var item in dataReceive)
            {
                request.ForeachClass(item);
                var dataOrder = await _dataOrderRepository.GetAsync(p => p.ProvinceNo == item.CaseSerial, cancellationToken);
                if (dataOrder != null)
                {
                    if (dataOrder.FirstSyncVisitTime == null || dataOrder.FirstSyncVisitTime is null)
                    {
                        dataOrder.FirstSyncVisitTime = DateTime.Now;
                    }
                    dataOrder.NewSyncVisitTime = item.VisitTime;
                    dataOrder.NewSyncVisitReplyTime = DateTime.Now;
                    dataOrder.FirstSatisfaction = item.FirstSatisfaction;
                    dataOrder.NewSatisfaction = item.SubjectResultSatify;
                    await _dataOrderRepository.UpdateAsync(dataOrder);
                }
            }
            var data = new SubmitVisitInfoData
            {
                VisitInfos = dataReceive
            };
            request.SetData(data);

            var response = await pusher.PushSubmitVisitInfoAsync(request, cancellationToken);

            //如果推送成功修改数据状态
            if (response != null)
            {
                List<ErrorInfo> list = new();
                if (response.custom != null && response.custom.errorObjs != null && response.custom.errorObjs.Count > 0)
                {
                    list = response.custom.errorObjs;
                }
                foreach (var item in dto)
                {
                    if (list != null && list.Count > 0)
                    {
                        if (list.Find(p => p.caseserial == item.CaseSerial) != null)
                            item.SyncState = "2";
                        else
                            item.SyncState = "1";
                    }
                    else
                        item.SyncState = "1";

                    await _submitVisitInfoRepository.UpdateAsync(item, cancellationToken);

                    //处理同步记录
                    await UpdateWaitingPushData(item.Id, item.SyncState, System.Text.Json.JsonSerializer.Serialize(response), cancellationToken: cancellationToken);
                }
            }
        }

        /// <summary>
        ///附件上传处理
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task GetCaseMaterialInfoPusher(List<DsGetCaseMaterialInfo> dto, CancellationToken cancellationToken)
        {
            //处理数据
            foreach (var item in dto)
            {
                var dataReceive = _mapper.Map<GetCaseMaterialInfoModel>(item);

                //附件上传
                var result = await SendFileData(dataReceive, item.FileName, item.Additions, cancellationToken);
                if (result != null && result.ReturnInfo != null)
                {
                    //结果处理
                    if (result.ReturnInfo.Code == "1")
                        //更新推送表状态
                        item.SyncState = "1";
                    else
                        item.SyncState = "2";
                }
                else
                    item.SyncState = "2";
                await _getCaseMaterialInfoRepository.UpdateAsync(item, cancellationToken);

                //处理同步记录
                await UpdateWaitingPushData(item.Id, item.SyncState, System.Text.Json.JsonSerializer.Serialize(result), cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 拉取12315工单办理信息
        /// </summary>
        /// <param name="CaseSerial"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task GetCaseDistrecordSendPusher(string CaseSerial, CancellationToken cancellationToken)
        {
            var pusher = _pusherProvider.CreatePusher(_channelConfigurationManager);

            var request = new GetCaseDistrecordSendRequest();

            request.SetData(new GetCaseDistrecordSendInfo()
            {
                CaseSerial = CaseSerial
            });

            var response = await pusher.PushGetCaseDistrecordSendAsync(request, cancellationToken);

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

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

            //这里处理业务
            if (response.custom.STEP_List != null && response.custom.STEP_List.Count > 0)
            {
                //查询工单数据
                var dataOrder = await _dataOrderRepository.GetAsync(p => p.ProvinceNo == CaseSerial, cancellationToken);
                //这里调用业务接口，推送办理数据
                List<WorkflowTraceDto> Traces = new List<WorkflowTraceDto>();
                //遍历返回的数据
                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
                        });
                    }
                }

                //往业务系统推送数据
                if (dataOrder != null && Traces != null && Traces.Count > 0)
                    await _mediator.Send(new AddOrderTracesAsyncNotify { OrderId = dataOrder.OrderId, Traces = Traces }, cancellationToken);
            }
        }

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

                    //组装请求参数
                    var model = new GetCaseMaterialInfoRequest
                    {
                        paras = dto,
                        token = new ClientInfo(configProvince.ClientId, configProvince.ClientSecret)
                    };

                    Dictionary<string, object> dicParam = new()
                    {
                        { "params",  System.Text.Json.JsonSerializer.Serialize(model) } // 第一个接口参数，json格式字符串
                    };

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

                    string strUrl = configProvince.HuiJu + "get_case_material_info";
                    // 上传附件
                    string strResult = CFormUpload.MultipartFormDataPost(strUrl, null, dicParam, strToken);
                    return JsonConvert.DeserializeObject<ProvinceResponse>(strResult);
                }
                return new ProvinceResponse();
            }
            catch (Exception)
            {
                return new ProvinceResponse();
            }
        }

        /// <summary>
        /// 更新待同步记录数据
        /// </summary>
        /// <param name="dataId"></param>
        /// <param name="SyncState"></param>
        /// <param name="result"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        private async Task UpdateWaitingPushData(string dataId, string SyncState, string result, CancellationToken cancellationToken)
        {
            //处理同步记录
            var waitingPushData = await _waitingPushDataRepository.GetAsync(p => p.SyncID == dataId);
            if (waitingPushData != null)
            {
                //第一次同步时间
                if (waitingPushData.FirstSyncProvinceTime is null)
                    waitingPushData.FirstSyncProvinceTime = DateTime.Now;
                else
                    waitingPushData.SyncCount++;

                //同步成功时间
                if (SyncState == "1")
                {
                    waitingPushData.SuccessSyncTime = DateTime.Now;
                }
                //最新同步时间
                waitingPushData.NewSyncProvinceTime = DateTime.Now;
                waitingPushData.SyncState = SyncState;
                waitingPushData.ReturnResult = result;
                await _waitingPushDataRepository.UpdateAsync(waitingPushData, cancellationToken: cancellationToken);
            }
        }
    }
}