hotline/src/Hotline/DataSharing/Province/Services/ProvinceService.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.Other;
using Hotline.DataSharing.Province.XieTong.Knowledge;
using Hotline.DataSharing.Province.XieTong.Receive;
using Hotline.DataSharing.Province.XieTong.Send;
using Hotline.File;
using Hotline.Share.Dtos.DataSharing.DataExchange;
using Hotline.Share.Dtos.DataSharing.Province.Extend;
using Hotline.Share.Dtos.DataSharing.Province.XieTong.Send;
using Hotline.Share.Dtos.File;
using Hotline.Share.Dtos.Knowledge;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Enums.DataSharing;
using Hotline.Share.Enums.FlowEngine;
using Hotline.Share.Enums.Order;
using MapsterMapper;
using MediatR;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Sharing.Province.Dtos.HuiJu.Send;
using Sharing.Share.Dtos.DataSharing.DataExchange;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using XF.Domain.Dependency;
using XF.Domain.Repository;

namespace Hotline.DataSharing.Province.Services
{
    public class ProvinceService : IProvinceService, 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<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 IHttpClientFactory _httpClientFactory;
        private readonly IPusherProviderService _pusherProviderService;
        private readonly IEnterpriseService _enterpriseService;
        private readonly ILogger<ProvinceService> _logger;
        private readonly IFileRepository _fileRepository;
        private readonly IRepository<DsGetCaseResultReceive> _getCaseResultReceiveRepository;

        /// <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="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="httpClientFactory"></param>
        /// <param name="pusherProviderService"></param>
        /// <param name="enterpriseService"></param>
        public ProvinceService(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<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,
          IHttpClientFactory httpClientFactory,
          IPusherProviderService pusherProviderService,
          IEnterpriseService enterpriseService,
          ILogger<ProvinceService> logger,
          IFileRepository fileRepository,
          IRepository<DsGetCaseResultReceive> getCaseResultReceiveRepository)
        {
            _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;
            _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;
            _httpClientFactory = httpClientFactory;
            _pusherProviderService = pusherProviderService;
            _enterpriseService = enterpriseService;
            _logger = logger;
            _fileRepository = fileRepository;
            _getCaseResultReceiveRepository = getCaseResultReceiveRepository;
        }
        #endregion

        #region 协同-第一批次

        /// <summary>
        /// 退回申请    --已对接---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task GetCaseBackApply(PublishOrderSendBackDto dto, CancellationToken cancellationToken)
        {
            //处理110退回事件
            if (dto.Order.Source == ESource.Police110)
            {
                var checkData = await _policeSendChainDealDsRepository.AnyAsync(p => p.AlarmReceiptNumber == dto.Order.ExternalId && p.DisposalType == (int)EDsDisposalType.Return, cancellationToken);
                if (!checkData)
                {
                    var data = new DsPoliceSendChainDealDs()
                    {
                        OrderId = dto.Order.Id,
                        AlarmReceiptNumber = dto.Order.ExternalId,
                        ReturnName = dto.SendBack.CreatorName,
                        ReturnUnit = dto.SendBack.CreatorOrgName,
                        ReturnOpinion = dto.SendBack.Content,
                        ReturnTime = dto.SendBack.CreationTime,
                        WarehousingTime = DateTime.Now,
                        DisposalType = 2
                    };
                    var id = await _policeSendChainDealDsRepository.AddAsync(data, cancellationToken);
                    if (!string.IsNullOrEmpty(id))//如果数据新增成功直接调用业务系统退回接口，反馈退回成功
                    { }  // await _hotlineClient.OrderSendBackResultAsync(new() { Id = dto.SendBack.Id }, default);

                }
            }

            //处理省上的退回申请
            if (dto.Order.Source == ESource.ProvinceStraight)
            {
                var data = _mapper.Map<DsGetCaseBackApply>(dto);

                data.CliengGuid = Guid.NewGuid().ToString();
                //将上报信息写入本地库
                data.Id = await _getCaseBackApplyRepository.AddAsync(data, cancellationToken);

                //将待推送数据写入待推送表
                await InitPushData("GetCaseBackApply", System.Text.Json.JsonSerializer.Serialize(data), "get_case_back_apply", data.Id, 0, cancellationToken);

                //   await _pusherProviderService.GetCaseBackApplyPusher(data, cancellationToken);

                //处理附件
                await FileData(dto.SendBack.FileJson, dto.Order.ProvinceNo, data.CliengGuid, dto.Order.AreaCode, cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单督办过程  --已对接-----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SendSuperviseProcessInfo(PublishSuperviseDto dto, CancellationToken cancellationToken)
        {
            //工单是省上派下来的，才能进行督办回复
            if (dto.Order.Source == ESource.ProvinceStraight && dto.Order.IsProvince)
            {
                var data = _mapper.Map<DsSendSuperviseProcessInfo>(dto);
                //将上报信息写入本地库
                data.Id = await _sendSuperviseProcessInfoRepository.AddAsync(data, cancellationToken);
                //将待推送数据写入待推送表
                await InitPushData("SendSuperviseProcessInfo", System.Text.Json.JsonSerializer.Serialize(data), "send_supervise_process_info", data.Id, 0, cancellationToken);

                //推送数据
                // await _pusherProviderService.SendSuperviseProcessInfoPusher(data, cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单督办结果  --已对接----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SendSuperviseResultInfo(PublishSuperviseDto dto, CancellationToken cancellationToken)
        {
            //工单是省上派下来的，才能进行督办回复
            if (dto.Order.Source == ESource.ProvinceStraight && dto.Order.IsProvince)
            {
                var data = _mapper.Map<DsSendSuperviseResultInfo>(dto);
                data.CliengGuid = Guid.NewGuid().ToString();
                //将上报信息写入本地库
                data.Id = await _sendSuperviseResultInfoRepository.AddAsync(data, cancellationToken);

                //将待推送数据写入待推送表
                await InitPushData("SendSuperviseResultInfo", System.Text.Json.JsonSerializer.Serialize(data), "send_supervise_result_info", data.Id, 0, cancellationToken);
                //处理附件
                await FileData(dto.Supervise.FileJson, dto.Order.ProvinceNo, data.CliengGuid, dto.Order.AreaCode, cancellationToken);
                // await _pusherProviderService.SendSuperviseResultInfoPusher(data, cancellationToken);
            }
        }

        /// <summary>
        /// 工单发起甄别  --已对接---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task ScreenCaseInfoSend(PublishScreenDto dto, CancellationToken cancellationToken)
        {
            //如果是省上派下来的工单，才能调发起甄别的接口
            if (dto.Order.Source == ESource.ProvinceStraight && dto.Order.IsProvince)
            {
                var data = _mapper.Map<DsScreenCaseInfoSend>(dto);
                data.CliengGuid = Guid.NewGuid().ToString();
                data.ApplyType = dto.Screen.TypeDicName switch
                {
                    "违反法律法规" => "10",
                    "按正常流程处理" => "20",
                    _ => "30",
                };

                //将上报信息写入本地库
                data.Id = await _screenCaseInfoSendRepository.AddAsync(data, cancellationToken);

                //将待推送数据写入待推送表
                await InitPushData("ScreenCaseInfoSend", System.Text.Json.JsonSerializer.Serialize(data), "screen_case_info_send", data.Id, 0, cancellationToken);
                //处理附件
                await FileData(dto.Screen.FileJson, dto.Order.ProvinceNo, data.CliengGuid, dto.Order.AreaCode, cancellationToken);
                //  await _pusherProviderService.ScreenCaseInfoSendPusher(data, cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单申请延时   --已对接---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task DelayCaseInfoSend(PublishOrderDelayDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DsDelayCaseInfoSend>(dto);
            data.CliengGuid = Guid.NewGuid().ToString();
            data.ApplyType = "1";
            //将上报信息写入本地库
            data.Id = await _delayCaseInfoSendRepository.AddAsync(data);

            //将待推送数据写入待推送表
            await InitPushData("DelayCaseInfoSend", System.Text.Json.JsonSerializer.Serialize(data), "delay_case_info_send", data.Id, 0, cancellationToken);

            //信息上报
            //   await _pusherProviderService.DelayCaseInfoSendPusher(data, cancellationToken);
            //处理附件
            await FileData(dto.FileJson, data.CaseSerial, data.CliengGuid, data.AreaCode, cancellationToken);
        }

        /// <summary>
        /// 政民互动提交公开---已在接收大补数据中实现  
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task ZmhdCaseInfoPublic(ZmhdCaseInfoPublicInfo dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DsZmhdCaseInfoPublic>(dto);
            data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;
            //将上报信息写入本地库
            data.Id = await _zMHDCaseInfoPublicRepository.AddAsync(data);

            //将待推送数据写入待推送表
            await InitPushData("ZmhdCaseInfoPublic", System.Text.Json.JsonSerializer.Serialize(data), "zmhd_case_info_public", data.Id, 0, cancellationToken);

            //信息上报
            //  await _pusherProviderService.ZmhdCaseInfoPublicPusher(data, cancellationToken);
        }
        #endregion

        #region 汇聚-第二批次

        /// <summary>
        /// 热线工单流程开启 --服务工单受理----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task OrderFlowStarted(OrderDto dto, CancellationToken cancellationToken)
        {
            //如果不是省上派下来的工单，需要汇聚到省上
            if (!dto.IsProvince)
            {
                var submitCaseInfo = await InitData(dto, cancellationToken);
                //处理数据
                var dataOrder = await _dataOrderRepository.GetAsync(p => p.OrderId == submitCaseInfo.OrderID, cancellationToken);
                if (dataOrder == null)
                {
                    dataOrder = new()
                    {
                        OrderId = submitCaseInfo.OrderID,
                        OrderNo = submitCaseInfo.No,
                        ProvinceNo = submitCaseInfo.CaseSerial,
                        CaseDate = submitCaseInfo.CaseDate,
                        FirstSyncProvinceTime = DateTime.Now,
                        SyncInterval = 0,
                        IsTimelyUpload = true,
                        CaseSource = dto.SourceChannel,
                        CaseSourceCode = dto.SourceChannelCode,
                        ExpiredTime = submitCaseInfo.TfdBackTimeBf,
                        CaseType = submitCaseInfo.CaseType,
                        CaseTypeCode = dto.AcceptTypeCode,
                        AllDuration = 0,
                        IsProvince = false,
                        HandleState = "办理中",
                        Title = dto.Title,
                        FromName = dto.FromName,
                        Contact = dto.Contact,
                        Content = dto.Content,
                        HotspotId = dto.HotspotId,
                        HotspotName = dto.HotspotName,
                        HotspotSpliceName = dto.HotspotSpliceName,
                        Source = dto.Source.ToString(),
                        Password = dto.Password
                    };
                    await _dataOrderRepository.AddAsync(dataOrder, cancellationToken);
                }
                else
                {
                    //修改
                    dataOrder.NewSyncProvinceTime = DateTime.Now;
                    dataOrder.SyncInterval = new TimeSpan(DateTime.Now.Ticks - dataOrder.FirstSyncProvinceTime.Value.Ticks).TotalSeconds;
                    dataOrder.IsTimelyUpload = false;
                    await _dataOrderRepository.UpdateAsync(dataOrder, cancellationToken);
                }

                //将待推送数据写入待推送表
                await InitPushData("SubmitCaseInfo", System.Text.Json.JsonSerializer.Serialize(submitCaseInfo), "submit_case_info", submitCaseInfo.Id, 10, cancellationToken);

                //推送数据
                //   await _pusherProviderService.ProvinceOrderCreatedPusher(submitCaseInfo, cancellationToken);

                //处理附件
                await FileData(dto.FileJson, submitCaseInfo.CaseSerial, submitCaseInfo.CliengGuid, submitCaseInfo.AreaCode, cancellationToken);
            }
        }

        /// <summary>
        ///热线工单期满时间变更--推送服务工单受理---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task HotlineOrderFlowRecalled(OrderDto dto, CancellationToken cancellationToken)
        {
            //如果不是省上派下来的工单，需要汇聚到省上
            if (!dto.IsProvince)
            {
                var submitCaseInfo = await InitData(dto, cancellationToken);

                //将待推送数据写入待推送表
                await InitPushData("SubmitCaseInfo", System.Text.Json.JsonSerializer.Serialize(submitCaseInfo), "submit_case_info", submitCaseInfo.Id, 10, cancellationToken);

                //推送数据
                //await _pusherProviderService.ProvinceOrderCreatedPusher(submitCaseInfo, cancellationToken);
            }
        }

        /// <summary>
        /// 热线工单办理---服务工单处理/服务工单交办处理过程----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SubmitCaseProcess(OrderFlowDto dto, CancellationToken cancellationToken)
        {
            //判断是否是热线中心
            if (!string.IsNullOrEmpty(dto.Order.ActualHandleOrgCode))
            {
                if (dto.Order.ActualHandleOrgCode.Substring(0, 3) == "001")
                {
                    dto.Order.ActualHandleOrgName = "热线中心";
                }
            }

            //写本地办理数据-用于查询办理流程
            var orderWorkFlow = _mapper.Map<DsOrderWorkFlow>(dto.WorkflowTrace);
            orderWorkFlow.OrderId = dto.Order.Id;
            _logger.LogInformation("流程转换前数据", System.Text.Json.JsonSerializer.Serialize(dto));
            _logger.LogInformation("流程转换后数据", System.Text.Json.JsonSerializer.Serialize(orderWorkFlow));

            await _dataOrderWorkFlowRepository.AddAsync(orderWorkFlow, cancellationToken);

            //省上下来的工单走协同的接口
            if (dto.Order.Source == ESource.ProvinceStraight && dto.Order.IsProvince)
            {

                var data = _mapper.Map<DsGetCaseProcessReceive>(dto);
                data.TacheName = "70:" + data.DeptName;
                data.CliengGuid = Guid.NewGuid().ToString();
                //将上报信息写入本地库
                data.Id = await _getCaseProcessReceiveRepository.AddAsync(data, cancellationToken);
                //将待推送数据写入待推送表
                await InitPushData("GetCaseProcessReceive", System.Text.Json.JsonSerializer.Serialize(data), "get_case_process_receive", data.Id, 0, cancellationToken);

                //信息上报
                //await _pusherProviderService.GetCaseProcessReceivePusher(data, cancellationToken);

                //处理附件
                await FileData(dto.WorkflowTrace.FileJson, data.CaseSerial, data.CliengGuid, dto.Order.AreaCode, cancellationToken);
            }
            else  //如果不是省上派下来的工单
            {
                //期满时间变更，重新推送数据
                if (dto.ExpiredTimeChanged)
                {
                    var submitCaseInfo = await InitData(dto.Order, cancellationToken);
                    //将待推送数据写入待推送表
                    await InitPushData("SubmitCaseInfo", System.Text.Json.JsonSerializer.Serialize(submitCaseInfo), "submit_case_info", submitCaseInfo.Id, 10, cancellationToken);

                    //推送数据
                    //  await _pusherProviderService.ProvinceOrderCreatedPusher(submitCaseInfo, cancellationToken);
                }

                //推送办理记录
                await SubmitCaseProcessData(dto, cancellationToken);//本地工单走市州接口

            }

            //这里判断是否需要往其他平台推送数据
            await OrderDispatch(dto, cancellationToken);
        }

        /// <summary>
        /// 回访完成---服务工单回访评价/服务工单交办评价-----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SubmitVisitInfo(PublishVisitDto dto, CancellationToken cancellationToken)
        {
            await SubmitVisitInfoData(dto, cancellationToken);
        }

        /// <summary>
        /// 甄别通过---服务工单回访评价//服务工单交办评价----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SubmitOrderScreenSuccess(PublishVisitDto dto, CancellationToken cancellationToken)
        {
            await SubmitVisitInfoData(dto, cancellationToken);
        }

        /// <summary>
        ///热线工单归档---服务工单结果/服务工单交办处理结果----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task OrderFiled(OrderFlowDto dto, CancellationToken cancellationToken)
        {
            //判断是否是热线中心
            if (!string.IsNullOrEmpty(dto.Order.ActualHandleOrgCode))
            {
                if (dto.Order.ActualHandleOrgCode.Substring(0, 3) == "001")
                {
                    dto.Order.ActualHandleOrgName = "热线中心";
                }
            }
            //IsProvince 如果是false 则推送服务工单受理
            if (dto != null && dto.Order != null && !dto.Order.IsProvince)
            {
                //推送工单信息
                var submitCaseInfo = await InitData(dto.Order, cancellationToken);

                await InitPushData("SubmitCaseInfo", System.Text.Json.JsonSerializer.Serialize(submitCaseInfo), "submit_case_info", submitCaseInfo.Id, 10, cancellationToken);
                // await _pusherProviderService.ProvinceOrderCreatedPusher(submitCaseInfo, cancellationToken);
                //推送服务工单结果信息-组装110数据
                await SubmitCaseResult(dto, cancellationToken);
            }

            //修改本地工单数据
            var data = await _dataOrderRepository.GetAsync(p => p.OrderId == dto.Order.Id, cancellationToken);
            if (data != null)
            {
                data.HandleState = "办理完成";
                data.ActualHandleOrgName = dto.WorkflowTrace.HandlerOrgName;
                data.ActualHandleOrgCode = dto.WorkflowTrace.HandlerOrgAreaCode;
                data.ActualOpinion = dto.WorkflowTrace.Opinion;
                data.ActualHandleTime = dto.WorkflowTrace.HandleTime;
                await _dataOrderRepository.UpdateAsync(data, cancellationToken);
            }
        }

        /// <summary>
        /// 挂电话推送----电话记录---1
        /// </summary>
        /// <param name="dtos"></param>
        /// <returns></returns>
        public async Task SubmitCaseRecord(List<CallConnectOrderDto> dtos, CancellationToken cancellationToken)
        {
            List<DsSubmitCaseRecord> recordList = new();
            foreach (var item in dtos)
            {
                var record = _mapper.Map<DsSubmitCaseRecord>(item);
                record.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;

                if (item.Order != null && !string.IsNullOrEmpty(item.Order.ProvinceNo))
                    record.CaseSerial = item.Order.ProvinceNo;

                //将上报信息写入本地库
                record.Id = await _submitCaseRecordRepository.AddAsync(record, cancellationToken);
                if (!string.IsNullOrEmpty(record.Id))
                    await InitPushData("SubmitCaseRecord", System.Text.Json.JsonSerializer.Serialize(record), "submit_case_record", record.Id, 11, cancellationToken);
                // recordList.Add(record);
            }
            //if (recordList != null && recordList.Count > 0)
            //    //信息上报
            //    await _pusherProviderService.SubmitCaseRecordPusher(recordList, cancellationToken);
        }

        /// <summary>
        /// 关联工单了推送----电话记录---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SubmitCaseRecordOrder(CallConnectOrderDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DsSubmitCaseRecord>(dto);
            data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;
            data.CaseSerial = dto.Order.ProvinceNo;
            //将上报信息写入本地库
            data.Id = await _submitCaseRecordRepository.AddAsync(data, cancellationToken);

            await InitPushData("SubmitCaseRecord", System.Text.Json.JsonSerializer.Serialize(data), "submit_case_record", data.Id, 11, cancellationToken);
            //信息上报
            // await _pusherProviderService.SubmitCaseRecordPusher(new List<DsSubmitCaseRecord> { data }, cancellationToken);
        }

        /// <summary>
        /// 统计数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SubmitCaseTotal(CaseTotal dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DsSubmitCaseTotal>(dto);
            //将上报信息写入本地库
            var id = await _submitCaseTotalRepository.AddAsync(data);

            data.Id = id;
            await InitPushData("SubmitCaseTotal", System.Text.Json.JsonSerializer.Serialize(data), "submit_case_total", data.Id, 0, cancellationToken);
            //信息上报
            //await _pusherProviderService.SubmitCaseTotalPusher(data, cancellationToken);
        }

        #endregion

        #region 协同-第三批次
        /// <summary>
        /// 服务工单上报  --- 在派单的时候，确定需不需要往各个平台推送数据--已在工单办理推送事件中处理完成
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SendCaseInfo(OrderDto dto, CancellationToken cancellationToken)
        {
            var sendCaseInfo = _mapper.Map<DsSendCaseInfo>(dto);

            //处理性别
            switch (dto.FromGender)
            {
                case EGender.Female:
                    sendCaseInfo.AppLicantSex = "0";
                    break;
                case EGender.Male:
                    sendCaseInfo.AppLicantSex = "1";
                    break;
                case EGender.Unknown:
                    sendCaseInfo.AppLicantSex = "2";
                    break;
                default:
                    sendCaseInfo.AppLicantSex = "2";
                    break;
            }

            //处理证件类型
            sendCaseInfo.CertifiCateType = dto.LicenceTypeCode switch
            {
                "10" => "10",
                "40" => "20",
                "55" => "30",
                "57" => "40",
                _ => "50",
            };

            //处理紧急程度
            sendCaseInfo.CaseIsUrgent = dto.EmergencyLevel switch
            {
                EEmergencyLevel.QuiteEmergency => "10",
                EEmergencyLevel.Emergency => "20",
                _ => "30",
            };

            //处理诉求类型
            switch (sendCaseInfo.CaseType)
            {
                case "10":
                case "15":
                case "20":
                case "25":
                case "30":
                case "35":
                    break;
                default:
                    sendCaseInfo.CaseType = "40";
                    break;
            }

            sendCaseInfo.Id = await _sendCaseInfoRepository.AddAsync(sendCaseInfo, cancellationToken);

            //  await _mediator.Publish(new SendCaseInfoNotification(sendCaseInfo));
        }

        /// <summary>
        /// 上报补充诉求---需要再次确认
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SupplyCaseInfoSend(SupplyCaseInfoSendInfo dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DsSupplyCaseInfoSend>(dto);
            data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;
            data.CliengGuid = Guid.NewGuid().ToString();
            //将上报信息写入本地库
            data.Id = await _supplyCaseInfoSendRepository.AddAsync(data);

            await InitPushData("SupplyCaseInfoSend", System.Text.Json.JsonSerializer.Serialize(data), "supply_case_info_send", data.Id, 0, cancellationToken);

            //信息上报
            //await _pusherProviderService.SupplyCaseInfoSendPusher(data, cancellationToken);

            //处理附件
            await FileData(new List<FileJson>(), dto.CaseSerial, data.CliengGuid, dto.AreaCode, cancellationToken);
        }

        /// <summary>
        /// 撤单----1
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task RevokeOrder(PublishSpecialDto dto, CancellationToken cancellationToken)
        {
            //企业服务
            if (dto.Order.CurrentHandleOrgCode == "001180")
            {
                DsDataWorkOrderCancel dsDataWork = new()
                {
                    WorkOrderNo = dto.Order.No,
                    Reason = dto.Special.Reason
                };
                await _enterpriseService.EnterpriseCancelPusher(dsDataWork, cancellationToken);
            }

            //省12345
            if (dto.Order.CurrentHandleOrgCode == "001170")
            {
                DsRevokeCaseInfo dsRevoke = new()
                {
                    CaseSerial = dto.Order.ProvinceNo,
                    AreaCode = dto.Order.AreaCode,
                    RevokeTime = dto.Special.CreationTime,
                    RevokeName = dto.Special.CreatorName,
                    RevokeReasion = dto.Special.Reason,
                    Direction = "1",
                    CliengGuid = Guid.NewGuid().ToString()
                };

                if (string.IsNullOrEmpty(dto.Special.Cause))
                    dsRevoke.RevokeType = "other";
                else if (dto.Special.Cause.Contains("内容错误"))
                    dsRevoke.RevokeType = "2";
                else if (dto.Special.Cause == "撤销工单")
                    dsRevoke.RevokeType = "1";
                else
                    dsRevoke.RevokeType = "other";

                //将上报信息写入本地库
                dsRevoke.Id = await _revokeCaseInfoRepository.AddAsync(dsRevoke);
                await InitPushData("SendRevokeCaseInfo", System.Text.Json.JsonSerializer.Serialize(dsRevoke), "revoke_case_info", dsRevoke.Id, 0, cancellationToken);

                await FileData(dto.Special.FileJson, dsRevoke.CaseSerial, dsRevoke.CliengGuid, dsRevoke.AreaCode, cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单催单--已对接----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SendRemindCaseInfo(PublishUrgeDto dto, CancellationToken cancellationToken)
        {
            //被催办部门为省上，才能调用接口
            if (dto.Urge.OrgName == "")
            {
                var data = _mapper.Map<DsRemindCaseInfo>(dto);
                data.Direction = "1";
                data.CliengGuid = Guid.NewGuid().ToString();
                //将上报信息写入本地库
                data.Id = await _remindCaseInfoRepository.AddAsync(data);

                //信息上报
                await InitPushData("SendRemindCaseInfo", System.Text.Json.JsonSerializer.Serialize(data), "remind_case_info", data.Id, 0, cancellationToken);
                //await _pusherProviderService.SendRemindCaseInfoPusher(data, cancellationToken);

                //处理附件
                await FileData(dto.Urge.FileJson, dto.Order.ProvinceNo, data.CliengGuid, dto.Order.AreaCode, cancellationToken);
            }
        }

        #endregion

        #region 协同-第四批次

        #region 知识库--已对接附件
        /// <summary>
        /// 知识库上报----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task GetKnowledgeInfoSend(KnowledgeSendDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DsGetKnowledgeInfoSend>(dto);
            data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;
            data.CliengGuid = Guid.NewGuid().ToString();
            if (data.DisableDate == null)//如果没得有失效时间，默认在生效日期上面加10年
                data.DisableDate = data.BeginDate.Value.AddYears(10);
            //将上报信息写入本地库
            data.Id = await _getKnowledgeInfoSendRepository.AddAsync(data);

            //查询原有数据，如果有修改原始数据，没有直接新增
            var dataRaw = await _knowledgeRawDataRepository.GetAsync(p => p.UID == data.UID);
            var raw = _mapper.Map<DsKnowledgeRawData>(data);
            if (dataRaw != null)
            {
                raw.Id = dataRaw.Id;
                await _knowledgeRawDataRepository.UpdateAsync(raw);
            }
            else
                await _knowledgeRawDataRepository.AddAsync(raw);

            //信息上报
            await InitPushData("GetKnowledgeInfoSend", System.Text.Json.JsonSerializer.Serialize(data), "get_knowledge_info_send", data.Id, 0, cancellationToken);
            // await _pusherProviderService.GetKnowledgeInfoSendPusher(data, cancellationToken);
            //知识附件处理
            await FileData(dto.FileJson, dto.UID, data.CliengGuid, data.AreaCode, cancellationToken);

        }

        /// <summary>
        /// 知识库变更---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task GetKnowledgeInfoUpdate(KnowledgeSendDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DsGetKnowledgeInfoUpdate>(dto);
            data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;
            data.CliengGuid = Guid.NewGuid().ToString();
            if (data.DisableDate == null)//如果没得有失效时间，默认在生效日期上面加10年
                data.DisableDate = data.BeginDate.Value.AddYears(10);
            //将上报信息写入本地库
            data.Id = await _getKnowledgeInfoUpdateRepository.AddAsync(data);

            //查询原有数据，如果有修改原始数据，没有直接新增
            var dataRaw = await _knowledgeRawDataRepository.GetAsync(p => p.UID == data.UID);
            var raw = _mapper.Map<DsKnowledgeRawData>(data);
            if (dataRaw != null)
            {
                raw.Id = dataRaw.Id;
                await _knowledgeRawDataRepository.UpdateAsync(raw);
            }
            else
                await _knowledgeRawDataRepository.AddAsync(raw);

            //信息上报
            await InitPushData("GetKnowledgeInfoUpdate", System.Text.Json.JsonSerializer.Serialize(data), "get_knowledge_info_update", data.Id, 0, cancellationToken);
            // await _pusherProviderService.GetKnowledgeInfoUpdatePusher(data, cancellationToken);

            //知识附件处理
            await FileData(dto.FileJson, dto.UID, data.CliengGuid, data.AreaCode, cancellationToken);
        }

        /// <summary>
        /// 知识库下架---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task GetKnowledgeInfoAbandon(KnowledgeSendDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DsGetKnowledgeInfoAbandon>(dto);
            data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;
            //将上报信息写入本地库
            data.Id = await _getKnowledgeInfoAbandonRepository.AddAsync(data);

            //知识下架删除原有原始数据
            await _knowledgeRawDataRepository.RemoveAsync(p => p.UID == data.UID, false);

            //信息上报
            await InitPushData("GetKnowledgeInfoAbandon", System.Text.Json.JsonSerializer.Serialize(data), "get_knowledge_info_abandon", data.Id, 0, cancellationToken);
            //  await _pusherProviderService.GetKnowledgeInfoAbandonPusher(data, cancellationToken);
        }
        #endregion

        /// <summary>
        /// 实时服务上报
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SendRealTimeStatus(SendRealTimeStatusInfo dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DsSendRealTimeStatus>(dto);
            data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;
            //将上报信息写入本地库
            data.Id = await _sendRealTimeStatusRepository.AddAsync(data);

            //信息上报
            await InitPushData("SendRealTimeStatus", System.Text.Json.JsonSerializer.Serialize(data), "sendrealtimestatus", data.Id, 0, cancellationToken);
            // await _pusherProviderService.SendRealTimeStatusPusher(data, cancellationToken);
        }
        #endregion

        /// <summary>
        /// 接收发布数据
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task PublishOrder(PublishPublishOrderDto dto, CancellationToken cancellationToken)
        {
            if (dto.Order.IsProvince && dto.Order.Source == ESource.ProvinceStraight)
            {
                #region 服务工单交办处理结果
                //判断是否是热线中心
                if (!string.IsNullOrEmpty(dto.Order.ActualHandleOrgCode) && dto.Order.ActualHandleOrgCode.Substring(0, 3) == "001")
                    dto.Order.ActualHandleOrgName = "热线中心";

                var data = _mapper.Map<DsGetCaseResultReceive>(dto.Order);
                data.ConcactType = "40";
                data.FinishType = "1";
                data.HandleTimeLong = dto.Order.AllDuration;
                switch (dto.Order.RealCommunicationMode)
                {
                    case ERealCommunicationMode.Phone:
                        data.ConcactType = "10";
                        break;
                    case ERealCommunicationMode.Locale:
                        data.ConcactType = "20";
                        break;
                    default:
                        data.ConcactType = "40";
                        break;
                }
                data.CliengGuid = Guid.NewGuid().ToString();

                //中国政府网的数据处理
                if (dto.Order.SourceChannelCode == "ZGZFW")
                {
                    data.Notes = "无";
                    data.MsgOpenByArea = dto.ProPublishState == true ? "1" : "0";
                    data.AreaNotPublicReason = dto.NoPubReason;
                    data.FeedBackAnswerContent = dto.ArrangeOpinion;
                    data.FeedBackTel = dto.FeedBackPhone;
                    data.EventType = "";
                    data.Eventname = "";
                    data.ContactFlag = "1";
                    data.AssessFlag = "1";
                    data.AssessOpinion = "1";
                    data.AssessContent = "";
                }
                
                //将上报信息写入本地库
                data.Id = await _getCaseResultReceiveRepository.AddAsync(data, cancellationToken);

                //将待推送数据写入待推送表
                DsWaitingPushData pushData = new()
                {
                    ServiceInterface = "GetCaseResultReceive",
                    Data = System.Text.Json.JsonSerializer.Serialize(data),
                    Priority = 0,
                    PushUrl = "get_case_result_receive",
                    Method = HttpMethods.Post,
                    SyncID = data.Id
                };
                await _waitingPushDataRepository.AddAsync(pushData, cancellationToken);
                //处理附件
                await FileData(new List<FileJson>(), data.CaseSerial, data.CliengGuid, dto.Order.AreaCode, cancellationToken);
                #endregion
            }

            //政民互动提交公开
            if (dto.Order.SourceChannelCode == "ZMHD")
            {
                var data = _mapper.Map<DsZmhdCaseInfoPublic>(dto);
                //将上报信息写入本地库
                data.Id = await _zMHDCaseInfoPublicRepository.AddAsync(data);

                //将待推送数据写入待推送表
                await InitPushData("ZmhdCaseInfoPublic", System.Text.Json.JsonSerializer.Serialize(data), "zmhd_case_info_public", data.Id, 0, cancellationToken);
            }
        }

        #region 私有方法
        /// <summary>
        /// 服务工单回访评价/服务工单交办评价
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        private async Task SubmitVisitInfoData(PublishVisitDto dto, CancellationToken cancellationToken)
        {
            string visitType = "";
            switch (dto.VisitType)
            {
                case EVisitType.ArtificialVisit:
                    visitType = "DH";
                    break;
                case EVisitType.SmsVisit:
                    visitType = "DX";
                    break;
                case EVisitType.WebVisit:
                    visitType = "WZ";
                    break;
                case EVisitType.WeChatVisit:
                    visitType = "WX";
                    break;
                case EVisitType.AppVisit:
                    visitType = "AP";
                    break;
                default:
                    break;
            }

            //将未接通未做评价的默认为满意
            switch (dto.SubjectResultSatifyCode)
            {
                case "1":
                case "2":
                case "3":
                case "4":
                case "5":
                    break;
                default:
                    dto.SubjectResultSatifyCode = "3";
                    break;
            }

            //如果省上下来的工单走服务工单交办评价接口,不是省上派下来的工单,走服务工单评价接口
            if (dto.Order.IsProvince && dto.Order.Source == ESource.ProvinceStraight)
            {
                var data = _mapper.Map<DsGetVisitInfoReceive>(dto);

                data.VisitType = visitType;
                data.CliengGuid = Guid.NewGuid().ToString();
                //将上报信息写入本地库 
                data.Id = await _getVisitInfoReceiveRepository.AddAsync(data, cancellationToken);

                //服务工单交办评价请求

                await InitPushData("GetVisitInfoReceive", System.Text.Json.JsonSerializer.Serialize(data), "get_visit_info_receive", data.Id, 5, cancellationToken);
                await _pusherProviderService.GetVisitInfoReceivePusher(data, cancellationToken);

                //处理附件
                await FileData(new List<FileJson>(), data.CaseSerial, data.CliengGuid, data.AreaCode, cancellationToken);
            }
            else
            {
                var data = _mapper.Map<DsSubmitVisitInfo>(dto);
                data.VisitType = visitType;
                data.CliengGuid = Guid.NewGuid().ToString();
                //将上报信息写入本地库
                data.Id = await _submitVisitInfoRepository.AddAsync(data, cancellationToken);

                //将待推送数据写入待推送表
                await InitPushData("SubmitVisitInfo", System.Text.Json.JsonSerializer.Serialize(data), "submit_visit_info", data.Id, 0, cancellationToken);
                //处理附件
                await FileData(new List<FileJson>(), data.CaseSerial, data.CliengGuid, data.AreaCode, cancellationToken);
                //组装110数据
                if (dto.Order.Source == ESource.Police110)
                {
                    var checkData = await _policeSendChainDealDsRepository.GetAsync(p => p.AlarmReceiptNumber == dto.Order.ExternalId && p.DisposalType == (int)EDsDisposalType.Visit, cancellationToken);
                    if (checkData == null)
                    {
                        checkData = new()
                        {
                            AlarmReceiptNumber = dto?.Order?.ExternalId,
                            RevisitTime = dto.VisitTime,
                            CheckingContent = dto.VisitRemark,
                            VisitContent = dto.VisitRemark,
                            VisitResult = dto.SubjectResultSatifyCode + "",
                            DisposalType = 3
                        };
                        await _policeSendChainDealDsRepository.AddAsync(checkData, cancellationToken);
                    }
                    else
                    {
                        checkData.AlarmReceiptNumber = dto?.Order?.ExternalId;
                        checkData.RevisitTime = dto.VisitTime;
                        checkData.CheckingContent = dto.VisitRemark;
                        checkData.VisitContent = dto.VisitRemark;
                        checkData.VisitResult = dto.SubjectResultSatifyCode + "";
                        await _policeSendChainDealDsRepository.UpdateAsync(checkData, cancellationToken);
                    }

                }
            }
        }

        /// <summary>
        /// 工单创建数据处理
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task<DsSubmitCaseInfo> InitData(OrderDto dto, CancellationToken cancellationToken)
        {
            var submitCaseInfo = _mapper.Map<DsSubmitCaseInfo>(dto);

            //处理性别
            submitCaseInfo.AppLicantSex = dto.FromGender switch
            {
                EGender.Female => "0",
                EGender.Male => "1",
                EGender.Unknown => "2",
                _ => "2",
            };

            //处理证件类型
            submitCaseInfo.CertifiCateType = dto.LicenceTypeCode switch
            {
                "10" => "10",
                "40" => "20",
                "55" => "30",
                "57" => "40",
                _ => "50",
            };

            //处理紧急程度
            submitCaseInfo.CaseIsUrgent = dto.EmergencyLevel switch
            {
                EEmergencyLevel.QuiteEmergency => "10",
                EEmergencyLevel.Emergency => "20",
                _ => "30",
            };

            //处理诉求类型
            switch (submitCaseInfo.CaseType)
            {
                case "10":
                case "15":
                case "20":
                case "25":
                case "30":
                case "35":
                    break;
                default:
                    submitCaseInfo.CaseType = "40";
                    break;
            }
            var data = await _submitCaseInfoRepository.GetAsync(p => p.CaseSerial == dto.ProvinceNo, cancellationToken);
            if (data != null)
                submitCaseInfo.CliengGuid = data.CliengGuid;
            else
                submitCaseInfo.CliengGuid = Guid.NewGuid().ToString();

            submitCaseInfo.Id = await _submitCaseInfoRepository.AddAsync(submitCaseInfo, cancellationToken);

            return submitCaseInfo;
        }

        /// <summary>
        /// 服务工单处理-写入数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task SubmitCaseProcessData(OrderFlowDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DsSubmitCaseProcess>(dto);

            data.TacheName = "70:" + data.DeptName;
            data.CaseId = dto.WorkflowTrace.Id;
            data.CliengGuid = Guid.NewGuid().ToString();
            //将上报信息写入本地库
            data.Id = await _submitCaseProcessRepository.AddAsync(data, cancellationToken);

            //将待推送数据写入待推送表
            DsWaitingPushData pushData = new()
            {
                ServiceInterface = "SubmitCaseProcess",
                Data = System.Text.Json.JsonSerializer.Serialize(data),
                Priority = 0,
                PushUrl = "submit_case_process",
                Method = HttpMethods.Post,
                SyncID = data.Id
            };
            await _waitingPushDataRepository.AddAsync(pushData, cancellationToken);
            //处理附件
            await FileData(dto.WorkflowTrace.FileJson, data.CaseSerial, data.CliengGuid, dto.Order.AreaCode, cancellationToken);
        }

        /// <summary>
        /// 服务工单拓展信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task SubmitCaseExtends(OrderDto dto, CancellationToken cancellationToken)
        {
            var orderExtension = dto.OrderExtension;
            if (orderExtension is null)
                return;

            //工单类型
            string formType = orderExtension.OrderTypeCode;

            //扩展主表信息
            DsReceiveCaseExtends receiveCaseExtends = new()
            {
                CaseSerial = dto.ProvinceNo,
                FormType = formType,
                SyncState = "0",
                Direction = "1"
            };

            //将上报信息写入本地库  
            var id = await _receiveCaseExtendsRepository.AddAsync(receiveCaseExtends, cancellationToken);
            receiveCaseExtends.Id = id;
            //处理为统一的市场监管表单
            if (formType == "scjgjts" || formType == "scjgjjb")
                formType = "scjgj";

            SubmitCaseExtendsInfo submitCaseExtendsInfo = new()
            {
                CaseSerial = dto.ProvinceNo,
                FormType = formType
            };

            //处理扩展信息
            switch (formType.ToLower())
            {
                case "yl"://医疗表单
                    //转换数据
                    var dtoyl = _mapper.Map<DsFormMedical>(orderExtension);
                    dtoyl.RCEId = id;
                    //添加数据
                    await _formMedicalRepository.AddAsync(dtoyl, cancellationToken);
                    submitCaseExtendsInfo.FormMedical = _mapper.Map<FormMedicalInfo>(dtoyl);
                    break;
                case "zwfw"://四川政务服务网技术工单
                    //转换数据
                    var dtozwfw = _mapper.Map<DsFormNetWorktec>(orderExtension);
                    dtozwfw.RCEId = id;
                    //添加数据
                    await _formNetWorktecRepository.AddAsync(dtozwfw, cancellationToken);
                    submitCaseExtendsInfo.FormNetWorktec = _mapper.Map<FormNetWorktecInfo>(dtozwfw);
                    break;
                case "th"://电视购物及商铺购买退换货工单
                    //转换数据
                    var dtoth = _mapper.Map<DsFormReturnexChange>(orderExtension);
                    dtoth.RCEId = id;
                    //添加数据
                    await _formReturnexChangeRepository.AddAsync(dtoth, cancellationToken);
                    submitCaseExtendsInfo.FormReturnexChange = _mapper.Map<FormReturnexChangeInfo>(dtoth);
                    break;
                case "gsgl"://高速公路工单
                    //转换数据
                    var dtogsgl = _mapper.Map<DsFormExpressWay>(orderExtension);
                    dtogsgl.RCEId = id;
                    //添加数据
                    await _formExpressWayRepository.AddAsync(dtogsgl, cancellationToken);
                    submitCaseExtendsInfo.FormExpressWay = _mapper.Map<FormExpressWayInfo>(dtogsgl);
                    break;
                case "xjgg"://电视台虚假广告工单
                    //转换数据
                    var dtoxjgg = _mapper.Map<DsFormShamPub>(orderExtension);
                    dtoxjgg.RCEId = id;
                    //添加数据
                    await _formShamPubRepository.AddAsync(dtoxjgg, cancellationToken);
                    submitCaseExtendsInfo.FormShamPub = _mapper.Map<FormShamPubInfo>(dtoxjgg);
                    break;
                case "swfwsq"://12366热线诉求交办
                    //转换数据
                    var dtoswfwsq = _mapper.Map<DsFormTaxationComplaint>(orderExtension);
                    dtoswfwsq.RCEId = id;
                    //添加数据
                    await _formTaxationComplaintRepository.AddAsync(dtoswfwsq, cancellationToken);
                    submitCaseExtendsInfo.FormTaxationComplaint = _mapper.Map<FormTaxationComplaintInfo>(dtoswfwsq);
                    break;
                case "swfwzx"://12366热线咨询交办
                    //转换数据
                    var dtoswfwzx = _mapper.Map<DsFormTaxationConsulting>(orderExtension);
                    dtoswfwzx.RCEId = id;
                    //添加数据
                    await _formTaxationConsultingRepository.AddAsync(dtoswfwzx, cancellationToken);
                    submitCaseExtendsInfo.FormTaxationConsulting = _mapper.Map<FormTaxationConsultingInfo>(dtoswfwzx);
                    break;
                case "jtfwjd"://12328服务监督
                    //转换数据
                    var dtojtfwjd = _mapper.Map<DsFormTraffic>(orderExtension);
                    dtojtfwjd.RCEId = id;
                    //添加数据
                    await _formTrafficRepository.AddAsync(dtojtfwjd, cancellationToken);
                    submitCaseExtendsInfo.FormTraffic = _mapper.Map<FormTrafficInfo>(dtojtfwjd);
                    break;
                case "yzxf"://邮政业消费者申诉
                    //转换数据
                    var dtoyzxf = _mapper.Map<DsFormPost>(orderExtension);
                    dtoyzxf.RCEId = id;
                    //添加数据
                    await _formPostRepository.AddAsync(dtoyzxf, cancellationToken);
                    submitCaseExtendsInfo.FormPost = _mapper.Map<FormPostInfo>(dtoyzxf);
                    break;
                case "hbjb"://环保举报业务
                    //转换数据
                    var dtohbjb = _mapper.Map<DsFormEnvironMent>(orderExtension);
                    dtohbjb.RCEId = id;
                    //添加数据
                    await _formEnvironMentRepository.AddAsync(dtohbjb, cancellationToken);
                    submitCaseExtendsInfo.FormEnvironMent = _mapper.Map<FormEnvironMentInfo>(dtohbjb);
                    break;
                case "scjgj"://12315个性化表单
                    var dtoscjgj = _mapper.Map<DsFormMarket>(orderExtension);
                    //转换数据
                    switch (orderExtension.OrderTypeCode)
                    {
                        case "scjgjjb":
                            dtoscjgj.Rqsttypy = "25";
                            break;
                        case "scjgjts":
                            dtoscjgj.Rqsttypy = "20";
                            foreach (var item in orderExtension.ComplainTypes)
                                dtoscjgj.AppealContent += item.Value + ",";
                            dtoscjgj.AppealContent = dtoscjgj.AppealContent.TrimEnd(',');
                            break;
                        default:
                            break;
                    }
                    dtoscjgj.HandDepCode = dto.AcceptorOrgCode;
                    dtoscjgj.HandDep = dto.AcceptorOrgName;
                    dtoscjgj.Zxgh = dto.AcceptorStaffNo;
                    dtoscjgj.AccregperId = dto.AcceptorId;
                    dtoscjgj.AccregperName = dto.AcceptorName;
                    dtoscjgj.RegTime = Convert.ToDateTime(dto.CreationTime);
                    dtoscjgj.CmTime = dto.StartTime;
                    dtoscjgj.RCEId = id;
                    //添加数据
                    await _formMarketRepository.AddAsync(dtoscjgj, cancellationToken);
                    submitCaseExtendsInfo.FormMarket = _mapper.Map<FormMarketInfo>(dtoscjgj);
                    break;
                default:
                    break;
            }

            //组装数据
            SubmitCaseExtendsInfoId submitCaseExtendsInfoId = new()
            {
                Id = id,
                Info = submitCaseExtendsInfo
            };
            //推送数据
            await _pusherProviderService.SubmitCaseExtendsPusher(submitCaseExtendsInfoId, cancellationToken);
        }

        /// <summary>
        /// 派单是判断需要往第三方推送数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task OrderDispatch(OrderFlowDto dto, CancellationToken cancellationToken)
        {
            if (dto.WorkflowTrace.NextHandlers != null && dto.WorkflowTrace.NextHandlers.Count > 0)
            {
                foreach (var item in dto.WorkflowTrace.NextHandlers)
                {
                    if (!string.IsNullOrEmpty(item.Key))
                    {
                        //需要判断是否需要往110推送
                        if (item.Key == "001179")
                            //写入110本地数据库
                            await InitPoliceSendChainAlarmDs(dto.Order, cancellationToken);

                        //需要判断是否需要往宜宾等地市州推送数据
                        if (item.Key == "泸州12345")
                            //市州数据提交
                            await InitCityDataYB(dto.Order, cancellationToken);

                        //需要判断是否需要往企业专班提交数据
                        if (item.Key == "001180")
                            //企业专班提交数据
                            await InitEnterpriseData(dto.Order, cancellationToken);

                        //是否向省上派单
                        if (item.Key == "001170")
                            await SendCaseInfo(dto.Order, cancellationToken);
                    }
                }
            }
        }

        /// <summary>
        /// 服务工单结果
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task SubmitCaseResult(OrderFlowDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DsSubmitCaseResult>(dto);
            data.ConcactType = "40";
            data.FinishType = "1";
            data.HandleTimeLong = dto.Order.AllDuration;
            data.CliengGuid = Guid.NewGuid().ToString();
            //将上报信息写入本地库
            data.Id = await _submitCaseResultRepository.AddAsync(data, cancellationToken);

            //将待推送数据写入待推送表
            DsWaitingPushData pushData = new()
            {
                ServiceInterface = "SubmitCaseResult",
                Data = System.Text.Json.JsonSerializer.Serialize(data),
                Priority = 0,
                PushUrl = "submit_case_result",
                Method = HttpMethods.Post,
                SyncID = data.Id
            };
            await _waitingPushDataRepository.AddAsync(pushData, cancellationToken);
            //处理附件
            await FileData(new List<FileJson>(), data.CaseSerial, data.CliengGuid, dto.Order.AreaCode, cancellationToken);
            //判断如果是110过来的数据，就组装数据
            //组装110
            if (dto.Order.Source == ESource.Police110)
            {
                await InitPoliceSendChainDealDs(dto, cancellationToken);
            }
        }

        #region 组装110数据
        /// <summary>
        /// 组装110数据，12345警情工单推送到110
        /// </summary>
        /// <param name="orderDto"></param>
        /// <returns></returns>
        private async Task InitPoliceSendChainAlarmDs(OrderDto orderDto, CancellationToken cancellationToken)
        {
            DsPoliceSendChainAlarmDs policeSend = new()
            {
                SerialNumber = orderDto.ExternalId,
                AlarmReceiptNumber = orderDto.ExternalId,
                RegisterNo = orderDto.AcceptorStaffNo,
                CallPoliceNumber = orderDto.FromPhone,
                CallPoliceName = orderDto.FromName,
                PhoneNumber = orderDto.Contact,
                CallPoliceContent = orderDto.Content,
                PoliceTypeCode = "",
                PoliceTypeName = "",
                JurisdictionalUnitCode = "511500000000",
                JurisdictionalUnitName = "宜宾市公安局",
                JurisdictionalUnitNumber = "0831110",
                AlarmReceivingUnitCode = "",
                AlarmReceivingUnitName = "",
                CallPoliceTime = Convert.ToDateTime(orderDto.CreationTime),
                PushTime = DateTime.Now,
                AlarmReceptionType = "0",
                AreaCode = orderDto.AreaCode,
                CallPoliceAddress = orderDto.FullAddress,
                OrderId = orderDto.Id
            };

            if (string.IsNullOrEmpty(policeSend.AlarmReceiptNumber))
            {
                policeSend.AlarmReceiptNumber = orderDto.No;
                policeSend.SerialNumber = orderDto.No;
            }
            //查询是否有此工单，如果没有新增此工单
            var data = await _policeSendChainAlarmDsRepository.GetAsync(p => p.OrderId == orderDto.Id, cancellationToken);
            if (data == null)
                await _policeSendChainAlarmDsRepository.AddAsync(policeSend, cancellationToken);
        }

        /// <summary>
        /// 110的非警情工单获取办理信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task InitPoliceSendChainDealDs(OrderFlowDto dto, CancellationToken cancellationToken)
        {
            var data = await _policeSendChainDealDsRepository.GetAsync(p => p.OrderId == dto.Order.Id && p.DisposalType == (int)EDsDisposalType.OrderFiled, cancellationToken);
            if (data == null)
            {
                data = new()
                {
                    AlarmReceiptNumber = dto.Order.ExternalId,
                    FeedbackTime = dto.Order.ActualHandleTime,
                    DisposalSituation = dto.Order.ActualOpinion,
                    ResultDescription = dto.Order.ActualOpinion,
                    FeedbackPersonNumber = dto.Order.ActualHandlerId,
                    FeedbackPersonName = dto.Order.ActualHandlerName,
                    FeedbackUnitCode = dto.Order.ActualHandleOrgCode,
                    FeedbackUnitName = dto.Order.ActualHandleOrgName,
                    WarehousingTime = DateTime.Now,
                    DisposalType = 1,
                    OrderId = dto.Order.Id
                };
                await _policeSendChainDealDsRepository.AddAsync(data, cancellationToken);
            }
            else
            {
                data.AlarmReceiptNumber = dto.Order.ExternalId;
                data.FeedbackTime = dto.Order.ActualHandleTime;
                data.DisposalSituation = dto.Order.ActualOpinion;
                data.ResultDescription = dto.Order.ActualOpinion;
                data.FeedbackPersonNumber = dto.Order.ActualHandlerId;
                data.FeedbackPersonName = dto.Order.ActualHandlerName;
                data.FeedbackUnitCode = dto.Order.ActualHandleOrgCode;
                data.FeedbackUnitName = dto.Order.ActualHandleOrgName;
                data.WarehousingTime = DateTime.Now;
                await _policeSendChainDealDsRepository.UpdateAsync(data, cancellationToken);
            }
        }

        #endregion

        #region 宜宾泸州市州数据提交
        /// <summary>
        /// 宜宾泸州市州数据提交
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task InitCityDataYB(OrderDto dto, CancellationToken cancellationToken)
        {
            var cityDataSend = _mapper.Map<DsCityDataSend>(dto);
            cityDataSend.ServerName = string.IsNullOrEmpty(cityDataSend.ServerName) ? "市民" : cityDataSend.ServerName;

            //写入本地数据库
            cityDataSend.Id = await _cityDataSendRepository.AddAsync(cityDataSend, cancellationToken);

            #region 提交请求
            var cityHandOver = _channelConfigurationManager.GetConfigurationCityHandOver();
            cityDataSend.Source = string.IsNullOrEmpty(cityDataSend.Source) ? cityHandOver.SendCityName : cityDataSend.Source;
            string secretKey = GetMD5(cityDataSend.Source + cityHandOver.SecretKey);

            Dictionary<string, string> dicParam = new()
            {
                { "Code", secretKey },
                { "FSHCode", cityDataSend.FSHCode },
                { "ServerName", cityDataSend.ServerName},
                { "PurTypeName",cityDataSend.PurTypeName },
                { "ConTypeName", cityDataSend.ConTypeName},
                { "Title", cityDataSend.Title},
                { "LinkName", cityDataSend.LinkName},
                { "Gender",cityDataSend.Gender},
                { "Mobile", cityDataSend.Mobile},
                { "Mail",cityDataSend.Mail },
                { "Address", cityDataSend.Address },
                { "Content", cityDataSend.Content},
                { "Source", cityDataSend.Source }
            };
            // 将参数转化为HttpContent
            HttpContent content = new FormUrlEncodedContent(dicParam);
            string result = "";
            try
            {
                using (var client = _httpClientFactory.CreateClient())
                using (var response = await client.PostAsync(cityHandOver.BaseUrl + cityHandOver.UrlAddress, content))
                {
                    if (response.StatusCode == HttpStatusCode.OK)
                    {
                        result = await response.Content.ReadAsStringAsync();
                    }
                }
            }
            catch (Exception)
            { }

            #endregion

            //处理返回信息
            if (!string.IsNullOrEmpty(result))
            {
                var responseData = JsonConvert.DeserializeObject<DataExchangeResponseDto>(result);
                if (responseData != null)
                {
                    if (responseData.Code == "1")
                        cityDataSend.SyncState = "1";
                    else
                        cityDataSend.SyncState = "2";

                    cityDataSend.ReturnResult = result;
                    await _cityDataSendRepository.UpdateAsync(cityDataSend, cancellationToken);
                }
            }
        }
        #endregion

        #region 宜宾企业专班数据提交
        /// <summary>
        /// 企业专班数据提交
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task InitEnterpriseData(OrderDto dto, CancellationToken cancellationToken)
        {
            var enterpriseData = _mapper.Map<DsDataWorkOrderSend>(dto);
            var businessFile = _channelConfigurationManager.GetConfigurationBusinessFile();
            //附件处理
            List<ReplyFiles> replyFiles = new();
            if (dto.FileJson != null && dto.FileJson.Count > 0)
            {
                foreach (var item in dto.FileJson)
                {
                    var data = await _fileRepository.GetAsync(p => p.Id == item.Id);
                    if (data != null)
                    {
                        #region 根据附件Id拉取附件文件流
                        byte[] fileContentBytes = null;
                        try
                        {
                            #region 读取数据
                            string url = string.Format("{0}{1}?Source={2}&Id={3}", businessFile.BaseUrl, businessFile.DownloadUrlAddress, businessFile.Source, data.Additions);
                            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();
                                }
                            }
                            #endregion

                            #region 组装附件参数
                            //组装附件参数
                            if (fileContentBytes != null && fileContentBytes.Length > 0)
                            {
                                ReplyFiles files = new ReplyFiles
                                {
                                    Filename = data.Name,
                                    Fileformat = data.Type,
                                    FileText = Convert.ToBase64String(fileContentBytes)
                                };
                                //拉取文件流
                                replyFiles.Add(files);
                            }
                            #endregion
                        }
                        catch (Exception)
                        {

                        }
                        #endregion
                    }
                    enterpriseData.ReplyFiles = replyFiles;
                }
            }
            //添加本地数据
            enterpriseData.Id = await _dataWorkOrderSendRepository.AddAsync(enterpriseData, cancellationToken);

            //推送数据
            await _enterpriseService.EnterpriseSendPusher(enterpriseData, cancellationToken);

        }
        #endregion

        #region 往省上派单
        /// <summary>
        /// 往省上派单
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task SendCaseInfoData(OrderDto dto, CancellationToken cancellationToken)
        {
            //先上传拓展信息
            if (dto.OrderExtension != null)
                await SubmitCaseExtends(dto, cancellationToken);

            //在处理工单信息
            var sendCaseInfo = _mapper.Map<DsSendCaseInfo>(dto);

            if (dto.OrderExtension != null)
                sendCaseInfo.IsExtends = "1";
            else
                sendCaseInfo.IsExtends = "0";

            #region 处理数据
            //处理性别
            switch (dto.FromGender)
            {
                case EGender.Female:
                    sendCaseInfo.AppLicantSex = "0";
                    break;
                case EGender.Male:
                    sendCaseInfo.AppLicantSex = "1";
                    break;
                case EGender.Unknown:
                    sendCaseInfo.AppLicantSex = "2";
                    break;
                default:
                    sendCaseInfo.AppLicantSex = "2";
                    break;
            }

            //处理证件类型
            sendCaseInfo.CertifiCateType = dto.LicenceTypeCode switch
            {
                "10" => "10",
                "40" => "20",
                "55" => "30",
                "57" => "40",
                _ => "50",
            };

            //处理紧急程度
            sendCaseInfo.CaseIsUrgent = dto.EmergencyLevel switch
            {
                EEmergencyLevel.QuiteEmergency => "10",
                EEmergencyLevel.Emergency => "20",
                _ => "30",
            };

            //处理诉求类型
            switch (sendCaseInfo.CaseType)
            {
                case "10":
                case "15":
                case "20":
                case "25":
                case "30":
                case "35":
                    break;
                default:
                    sendCaseInfo.CaseType = "40";
                    break;
            }
            #endregion

            sendCaseInfo.Id = await _sendCaseInfoRepository.AddAsync(sendCaseInfo, cancellationToken);

            //推送数据
            await _pusherProviderService.SendCaseInfoDataPusher(sendCaseInfo, cancellationToken);
        }
        #endregion

        /// <summary>
        /// 附件处理
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="CaseSerial">工单编号或者督办编号</param>
        /// <param name="CliengGuid">附件</param>
        /// <param name="AreaCode">区域Code</param>
        /// <returns></returns>
        private async Task FileData(List<FileJson> dto, string CaseSerial, string CliengGuid, string AreaCode, CancellationToken cancellationToken)
        {
            if (dto != null && dto.Count > 0)
            {
                //往附件推送表中写入数据
                foreach (var item in dto)
                {
                    var data = await _fileRepository.GetAsync(p => p.Id == item.Id);
                    //将受到的数据写入本地数据库
                    DsGetCaseMaterialInfo materialInfo = new()
                    {
                        CaseSerial = CaseSerial,
                        CliengGuid = CliengGuid,
                        AreaCode = AreaCode,
                        FileName = data.Name,
                        Key = data.Key,
                        Type = data.Type,
                        Additions = data.Additions,
                        Path = data.Path,
                        Direction = "1",
                        SyncState = "0"
                    };

                    //材料类型
                    switch (data.Classify)
                    {
                        case "办理上传":
                            materialInfo.MaterialType = "10";//受理材料
                            break;
                        //case "2":
                        //    materialInfo.MaterialType = "20";//环节材料
                        //    break;
                        //case "3":
                        //    materialInfo.MaterialType = "30";//结果材料
                        //    break;
                        case "回访附件":
                            materialInfo.MaterialType = "40";//回访评价材料
                            break;
                        case "督办申请":
                        case "督办回复":
                            materialInfo.MaterialType = "50";//督办材料
                            break;
                        case "知识附件":
                            materialInfo.MaterialType = "60";//知识库材料
                            break;
                        default:
                            materialInfo.MaterialType = "20";//环节材料
                            break;
                    }

                    //将数据写入本地
                    materialInfo.Id = await _getCaseMaterialInfoRepository.AddAsync(materialInfo, cancellationToken);
                    if (!string.IsNullOrEmpty(materialInfo.Id))
                    {
                        //写入待发表
                        DsWaitingPushData pushData = new()
                        {
                            ServiceInterface = "GetCaseMaterialInfo",
                            Data = System.Text.Json.JsonSerializer.Serialize(materialInfo),
                            Priority = 0,
                            PushUrl = "get_case_material_info",
                            Method = HttpMethods.Post,
                            SyncID = materialInfo.Id
                        };
                        await _waitingPushDataRepository.AddAsync(pushData, cancellationToken);
                    }
                }
            }
        }

        #region MD5 32位加密

        /// <summary>
        /// MD5 32位加密
        /// </summary>
        /// <param name="myString"></param>
        /// <returns></returns>
        private static string GetMD5(string myString)
        {
            string cl = myString;
            string pwd = "";
            try
            {
                MD5 md5 = MD5.Create();//实例化一个md5对像
                                       // 加密后是一个字节类型的数组，这里要注意编码UTF8/Unicode等的选择　
                byte[] s = md5.ComputeHash(Encoding.UTF8.GetBytes(cl));
                // 通过使用循环，将字节类型的数组转换为字符串，此字符串是常规字符格式化所得
                for (int i = 0; i < s.Length; i++)
                {
                    // 将得到的字符串使用十六进制类型格式。格式后的字符是小写的字母，如果使用大写（X）则格式后的字符是大写字符 
                    pwd = pwd + s[i].ToString("X2");
                }
            }
            catch (Exception)
            {
            }
            return pwd;
        }

        #endregion

        /// <summary>
        /// 初始化待推送数据
        /// </summary>
        /// <param name="ServiceInterface"></param>
        /// <param name="Data"></param>
        /// <param name="PushUrl"></param>
        /// <param name="SyncID"></param>
        /// <param name="Priority"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        private async Task InitPushData(string ServiceInterface, string Data, string PushUrl, string SyncID, int Priority, CancellationToken cancellationToken)
        {
            //将待推送数据写入待推送表
            DsWaitingPushData pushData = new()
            {
                ServiceInterface = ServiceInterface,
                Data = Data,
                Priority = Priority,
                PushUrl = PushUrl,
                Method = HttpMethods.Post,
                SyncID = SyncID
            };
            await _waitingPushDataRepository.AddAsync(pushData, cancellationToken);
        }
        #endregion


    }
}