using DataSharing.Application.Validators;
using DataSharing.DaoShu110;
using DataSharing.Province;
using DataSharing.RawData;
using DataSharing.SendTask;
using DataSharing.Share.Dtos;
using DataSharing.Share.Dtos.Enterprise;
using DataSharing.Share.Dtos.Province;
using DataSharing.Share.Dtos.Province.Extend;
using DataSharing.Share.Dtos.Province.HuiJu;
using DataSharing.Share.Dtos.Province.XieTong.Knowledge;
using DataSharing.Share.Dtos.Province.XieTong.Receive;
using DataSharing.Share.Dtos.Province.XieTong.Send;
using DataSharing.Share.Enums;
using DataSharing.WebPortal;
using DotNetCore.CAP;
using FluentValidation;
using Hotline.Share.Dtos.Knowledge;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Dtos.TrCallCenter;
using Hotline.Share.Enums.CallCenter;
using Hotline.Share.Enums.FlowEngine;
using Hotline.Share.Enums.Order;
using MapsterMapper;
using Microsoft.Extensions.Logging;
using System.Security.Cryptography;
using System.Text;
using XF.Domain.Cache;
using XF.Domain.Dependency;
using XF.Domain.Exceptions;
using XF.Domain.Repository;
using static System.Runtime.InteropServices.JavaScript.JSType;

namespace DataSharing.Application.Receivers
{
    public class ProvinceReceiver : ICapSubscribe, IScopeDependency
    {
        #region 注入
        private readonly IMapper _mapper;
        private readonly ILogger<ProvinceReceiver> _logger;
        private readonly IRepository<DsPoliceSendChainAlarmDs> _policeSendChainAlarmDsRepository;
        private readonly IRepository<DsPoliceSendChainDealDs> _policeSendChainDealDsRepository;
        private readonly IRepository<DsSendTask> _dsSendTaskRepository;
        private readonly IRepository<DsOrder> _dsOrderRepository;
        private readonly IRepository<DsOrderWorkFlow> _dataOrderWorkFlowRepository;
        private readonly IRepository<DsKnowledgeRawData> _knowledgeRawDataRepository;
        private readonly IChannelConfigurationManager _channelConfigurationManager;
        private readonly IRepository<DsSendCaseInfo> _sendCaseInfoRepository;
        private readonly ITypedCache<MissedCallModelDto> _missedCallModelCache;
        private readonly string MissedCallKey = "missedCallKey_";
        private readonly IRepository<DsOrderVisit> _dsOrderVisitRepository;
        private readonly IRepository<DsGetCaseBackApply> _getCaseBackApplyRepository;
        private readonly ICapPublisher _capPublisher;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="mapper"></param>
        /// <param name="logger"></param>
        /// <param name="policeSendChainAlarmDsRepository"></param>
        /// <param name="policeSendChainDealDsRepository"></param>
        /// <param name="dsSendTaskRepository"></param>
        /// <param name="dsOrderRepository"></param>
        /// <param name="dataOrderWorkFlowRepository"></param>
        /// <param name="knowledgeRawDataRepository"></param>
        /// <param name="channelConfigurationManager"></param>
        /// <param name="sendCaseInfoRepository"></param>
        /// <param name="missedCallModelCache"></param>
        /// <param name="dsOrderVisitRepository"></param>
        /// <param name="getCaseBackApplyRepository"></param>
        /// <param name="capPublisher"></param>
        public ProvinceReceiver(IMapper mapper, ILogger<ProvinceReceiver> logger,
             IRepository<DsPoliceSendChainAlarmDs> policeSendChainAlarmDsRepository,
             IRepository<DsPoliceSendChainDealDs> policeSendChainDealDsRepository,
             IRepository<DsSendTask> dsSendTaskRepository,
             IRepository<DsOrder> dsOrderRepository,
             IRepository<DsOrderWorkFlow> dataOrderWorkFlowRepository,
             IRepository<DsKnowledgeRawData> knowledgeRawDataRepository,
             IChannelConfigurationManager channelConfigurationManager,
             IRepository<DsSendCaseInfo> sendCaseInfoRepository,
             ITypedCache<MissedCallModelDto> missedCallModelCache,
             IRepository<DsOrderVisit> dsOrderVisitRepository,
             IRepository<DsGetCaseBackApply> getCaseBackApplyRepository,
             ICapPublisher capPublisher)
        {
            _mapper = mapper;
            _logger = logger;
            _policeSendChainAlarmDsRepository = policeSendChainAlarmDsRepository;
            _policeSendChainDealDsRepository = policeSendChainDealDsRepository;
            _dsSendTaskRepository = dsSendTaskRepository;
            _dsOrderRepository = dsOrderRepository;
            _dataOrderWorkFlowRepository = dataOrderWorkFlowRepository;
            _knowledgeRawDataRepository = knowledgeRawDataRepository;
            _channelConfigurationManager = channelConfigurationManager;
            _sendCaseInfoRepository = sendCaseInfoRepository;
            _missedCallModelCache = missedCallModelCache;
            _dsOrderVisitRepository = dsOrderVisitRepository;
            _getCaseBackApplyRepository = getCaseBackApplyRepository;
            _capPublisher = capPublisher;
        }
        #endregion

        #region 协同-第一批次

        /// <summary>
        /// 退回申请    --已对接---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderFlowPrevious)]
        public async Task GetCaseBackApplyAsync(PublishOrderSendBackDto dtos, CancellationToken cancellationToken)
        {
            if (dtos != null && dtos.SendDatas != null)
            {
                foreach (var dto in dtos.SendDatas)
                {
                    //处理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))//如果数据新增成功直接调用业务系统退回接口，反馈退回成功
                            {
                                var dataBack = new OrderSendBackResultDto()
                                {
                                    Id = dto.SendBack.Id,
                                    Reason = "",
                                    Result = 1
                                };
                                //向业务系统推送消息
                                await _capPublisher.PublishAsync(DataSharing.Share.Mq.EventNames.SharingOrderReturnFeedback, dataBack, cancellationToken: cancellationToken);

                            }  // await _hotlineClient.OrderSendBackResultAsync(new() { Id = dto.SendBack.Id }, default);

                        }
                    }

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

                        var tempData = _mapper.Map<DsGetCaseBackApply>(data);
                        tempData.OrderSendBackId = dto.SendBack.Id;

                        var backId = await _getCaseBackApplyRepository.AddAsync(tempData, cancellationToken);
                        if (!string.IsNullOrEmpty(backId))
                        {
                            #region 处理请求参数
                            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                            var request = new ProvinceRequest<GetCaseBackApplyInfo>(configProvince.ClientId, configProvince.ClientSecret);
                            request.SetData(data);
                            var jsonData = request.ToString();
                            var url = configProvince.XieTong + "get_case_back_apply";
                            #endregion

                            //将待推送数据写入待推送表
                            await InitPushDataAsync("GetCaseBackApply", "get_case_back_apply", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);

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

        /// <summary>
        /// 服务工单督办过程  --已对接-----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderSuperviseCourse)]
        public async Task SendSuperviseProcessInfoAsync(PublishSuperviseDto dto, CancellationToken cancellationToken)
        {
            //工单是省上派下来的，才能进行督办回复
            if (dto.Order.Source == ESource.ProvinceStraight && dto.Order.IsProvince)
            {
                var data = _mapper.Map<SendSuperviseProcessInfo>(dto);

                #region 处理请求参数
                var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                var request = new ProvinceRequest<SendSuperviseProcessInfo>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(data);
                var jsonData = request.ToString();
                var url = configProvince.XieTong + "send_supervise_process_info";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("SendSuperviseProcessInfo", "send_supervise_process_info", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单督办结果  --已对接----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderSuperviseResult)]
        public async Task SendSuperviseResultInfoAsync(PublishSuperviseDto dto, CancellationToken cancellationToken)
        {
            //工单是省上派下来的，才能进行督办回复
            if (dto.Order.Source == ESource.ProvinceStraight && dto.Order.IsProvince)
            {
                var data = _mapper.Map<SendSuperviseResultInfo>(dto);
                data.CliengGuid = dto.Supervise.Id;

                #region 处理请求参数
                var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                var request = new ProvinceRequest<SendSuperviseResultInfo>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(data);
                var jsonData = request.ToString();
                var url = configProvince.XieTong + "send_supervise_result_info";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("SendSuperviseResultInfo", "send_supervise_result_info", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);
                //处理附件
                await FileDataAsync(dto.Supervise.FileJson, dto.Order.ProvinceNo, data.CliengGuid, EMaterialType.Supervise, dto.Order.AreaCode, cancellationToken);

            }
        }

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

                #region 处理请求参数
                var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                var request = new ProvinceRequest<ScreenCaseInfoSendInfo>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(data);
                var jsonData = request.ToString();
                var url = configProvince.XieTong + "screen_case_info_send";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("ScreenCaseInfoSend", "screen_case_info_send", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);
                //处理附件
                await FileDataAsync(dto.Screen.FileJson, dto.Order.ProvinceNo, data.CliengGuid, EMaterialType.Process, dto.Order.AreaCode, cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单申请延时   --已对接---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderApplyDelay)]
        public async Task DelayCaseInfoSendAsync(PublishOrderDelayDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<DelayCaseInfoSendInfo>(dto);
            data.CliengGuid = dto.Id;
            data.ApplyType = "1";

            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceRequest<DelayCaseInfoSendInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(data);
            var jsonData = request.ToString();
            var url = configProvince.XieTong + "delay_case_info_send";
            #endregion

            //将待推送数据写入待推送表
            await InitPushDataAsync("DelayCaseInfoSend", "delay_case_info_send", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);

            //处理附件
            await FileDataAsync(dto.FileJson, data.CaseSerial, data.CliengGuid, EMaterialType.Process, data.AreaCode, cancellationToken);
        }

        #endregion

        #region 汇聚-第二批次

        /// <summary>
        /// 热线工单流程开启 --服务工单受理----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderFlowStarted)]
        public async Task OrderFlowStartedAsync(PublishCallRecrodDto pushdto, CancellationToken cancellationToken)
        {
            var dto = pushdto.Order;

            var configProvince = _channelConfigurationManager.GetConfigurationProvince();

            //如果不是省上派下来的工单，需要汇聚到省上
            if (dto is not null && !dto.IsProvince)
            {
                var data = await InitDataAsync(dto, cancellationToken);
                var validator = new SubmitCaseInfoValidator();
                var validResult = await validator.ValidateAsync(data, cancellationToken);
                if (!validResult.IsValid)
                    throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));

                #region 处理请求参数
                var request = new ProvinceListRequest<SubmitCaseInfo>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(new List<SubmitCaseInfo>() { data });
                var jsonData = request.ToString();
                var url = configProvince.HuiJu + "submit_case_info";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("SubmitCaseInfo", "submit_case_info", jsonData, pathType: EPathType.HuiJu, taskPriority: 10, cancellationToken: cancellationToken);
                //处理附件
                await FileDataAsync(dto.FileJson, dto.ProvinceNo, data.CliengGuid, EMaterialType.Acceptance, data.AreaCode, cancellationToken);
            }

            //再次推送通话记录
            if (pushdto.TrCallRecordDto is not null)
            {
                var dataCall = _mapper.Map<SubmitCaseRecordInfo>(pushdto.TrCallRecordDto);
                dataCall.AreaCode = dto.AreaCode;
                dataCall.CaseSerial = dto.ProvinceNo;

                //处理通话记录时间
                SetCallTime(dataCall);

                var validator = new SubmitCaseRecordInfoValidator();
                var validResult = await validator.ValidateAsync(dataCall, cancellationToken);
                if (!validResult.IsValid)
                    throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));
                #region 处理请求参数
                var requestCall = new ProvinceListRequest<SubmitCaseRecordInfo>(configProvince.ClientId, configProvince.ClientSecret);
                requestCall.SetData(new List<SubmitCaseRecordInfo>() { dataCall });
                var jsonDataCall = requestCall.ToString();
                var urlCall = configProvince.HuiJu + "submit_case_record";
                //将待推送数据写入待推送表
                await InitPushDataAsync("SubmitCaseRecord", "submit_case_record", jsonDataCall, pathType: EPathType.HuiJu, taskPriority: 20, cancellationToken: cancellationToken);
                #endregion
            }

            //推送当前办理信息
            await SubmitCaseProcessFlowAsync(new OrderFlowDto { Order = pushdto.Order, WorkflowTrace = pushdto.WorkflowTrace, ExpiredTimeChanged = false }, cancellationToken);

            //本地保存工单基础数据
            if (!await _dsOrderRepository.AnyAsync(p => p.OrderId == dto.Id, cancellationToken))
            {
                DsOrder dataOrder = new()
                {
                    OrderId = dto.Id,
                    OrderNo = dto.No,
                    ProvinceNo = dto.ProvinceNo,
                    WorkflowId = dto.WorkflowId,
                    Password = dto.Password,
                    Title = dto.Title,
                    FromName = dto.FromName,
                    Contact = dto.Contact,
                    Content = dto.Content,
                    CaseDate = Convert.ToDateTime(dto.CreationTime),
                    Source = dto.Source.ToString(),
                    CaseSource = dto.SourceChannel,
                    CaseSourceCode = dto.SourceChannelCode,
                    HotspotId = dto.HotspotId,
                    HotspotName = dto.HotspotName,
                    HotspotSpliceName = dto.HotspotSpliceName,
                    ExpiredTime = dto.ExpiredTime,
                    CaseType = dto.AcceptType,
                    CaseTypeCode = dto.AcceptTypeCode,
                    AllDuration = 0,
                    IsProvince = dto.IsProvince,
                    HandleState = "办理中",
                    FileJson = _mapper.Map<List<FileJson>>(dto.FileJson)
                };

                await _dsOrderRepository.AddAsync(dataOrder, cancellationToken);
            }
        }

        /// <summary>
        ///热线工单期满时间变更--推送服务工单受理---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderExpiredTimeUpdate)]
        public async Task HotlineOrderFlowRecalledAsync(OrderDto dto, CancellationToken cancellationToken)
        {
            //如果不是省上派下来的工单，需要汇聚到省上
            if (!dto.IsProvince)
            {
                var data = await InitDataAsync(dto, cancellationToken);
                var validator = new SubmitCaseInfoValidator();
                var validResult = await validator.ValidateAsync(data, cancellationToken);
                if (!validResult.IsValid)
                    throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));
                #region 处理请求参数
                var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                var request = new ProvinceListRequest<SubmitCaseInfo>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(new List<SubmitCaseInfo>() { data });
                var jsonData = request.ToString();
                var url = configProvince.HuiJu + "submit_case_info";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("SubmitCaseInfo", "submit_case_info", jsonData, pathType: EPathType.HuiJu, taskPriority: 10, cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 热线工单办理---服务工单处理/服务工单交办处理过程----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderFlowHandled)]
        public async Task SubmitCaseProcessAsync(OrderFlowDto dto, CancellationToken cancellationToken)
        {
            await SubmitCaseProcessFlowAsync(dto, cancellationToken);
            //期满时间变更或者办理节点为话务部，重新推送数据
            if (dto.ExpiredTimeChanged || dto.Order.ActualHandleStepName == "话务部")
            {
                var submitCaseInfo = await InitDataAsync(dto.Order, cancellationToken);
                var validator = new SubmitCaseInfoValidator();
                var validResult = await validator.ValidateAsync(submitCaseInfo, cancellationToken);
                if (!validResult.IsValid)
                    throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));
                #region 处理请求参数
                var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                var requestSubmitCaseInfo = new ProvinceListRequest<SubmitCaseInfo>(configProvince.ClientId, configProvince.ClientSecret);
                requestSubmitCaseInfo.SetData(new List<SubmitCaseInfo>() { submitCaseInfo });
                var jsonDataSubmitCaseInfo = requestSubmitCaseInfo.ToString();
                var urlSubmitCaseInfo = configProvince.HuiJu + "submit_case_info";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("SubmitCaseInfo", "submit_case_info", jsonDataSubmitCaseInfo, pathType: EPathType.HuiJu, taskPriority: 10, cancellationToken: cancellationToken);
                //如果话务部派出去，再次上传附件
                if (dto.Order.ActualHandleStepName == "话务部")
                {
                    //处理附件
                    await FileDataAsync(dto.Order.FileJson, dto.Order.ProvinceNo, submitCaseInfo.CliengGuid, EMaterialType.Acceptance, submitCaseInfo.AreaCode, cancellationToken);
                }
            }
        }

        /// <summary>
        /// 回访完成---服务工单回访评价/服务工单交办评价-----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderVisited)]
        public async Task SubmitVisitInfoAsync(PublishVisitDto dto, CancellationToken cancellationToken)
        {
            await SubmitVisitInfoDataAsync(dto, cancellationToken);
        }

        /// <summary>
        /// 甄别通过---服务工单回访评价//服务工单交办评价----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderScreenApplyed)]
        public async Task SubmitOrderScreenSuccessAsync(PublishVisitDto dto, CancellationToken cancellationToken)
        {
            await SubmitVisitInfoDataAsync(dto, cancellationToken);
        }

        /// <summary>
        ///热线工单归档---服务工单结果/服务工单交办处理结果----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderFiled)]
        public async Task OrderFiledAsync(OrderFlowDto dto, CancellationToken cancellationToken)
        {
            //推送办理记录
            dto.ExpiredTimeChanged = false;
            await SubmitCaseProcessFlowAsync(dto, cancellationToken);

            //判断是否是热线中心
            if (!string.IsNullOrEmpty(dto.Order.ActualHandleOrgCode) && dto.Order.ActualHandleOrgCode == "001")
                dto.Order.ActualHandleOrgName = "热线中心";

            //IsProvince 如果是false 则推送服务工单受理
            if (dto != null && dto.Order != null && !dto.Order.IsProvince)
            {
                var data = await InitDataAsync(dto.Order, cancellationToken);
                var validator = new SubmitCaseInfoValidator();
                var validResult = await validator.ValidateAsync(data, cancellationToken);
                if (!validResult.IsValid)
                    throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));
                #region 处理请求参数
                var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                var request = new ProvinceListRequest<SubmitCaseInfo>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(new List<SubmitCaseInfo>() { data });
                var jsonData = request.ToString();
                var url = configProvince.HuiJu + "submit_case_info";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("SubmitCaseInfo", "submit_case_info", jsonData, pathType: EPathType.HuiJu, taskPriority: 10, cancellationToken: cancellationToken);

                //推送服务工单结果信息-组装110数据
                await SubmitCaseResultAsync(dto, cancellationToken);
            }

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

        /// <summary>
        /// 挂电话推送----电话记录---1List<CallConnectOrderDto> dtos
        /// </summary>
        /// <param name="dtos"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineCallBye)]
        public async Task SubmitCaseRecordAsync(PublishCallRecrodDto dto, CancellationToken cancellationToken)
        {
            //验证是否需要推送未接数据
            if (dto != null && dto.TrCallRecordDto != null && dto.TrCallRecordDto.OnState == EOnState.NoOn)
            {
                if (!await IsPublishMissedCall(dto.TrCallRecordDto, cancellationToken))
                    return;
            }

            var data = _mapper.Map<SubmitCaseRecordInfo>(dto.TrCallRecordDto);
            if (dto.Order != null)
            {
                data.AreaCode = dto.Order.AreaCode;
                if (!string.IsNullOrEmpty(dto.Order.ProvinceNo))
                    data.CaseSerial = dto.Order.ProvinceNo;
            }
            else
                data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;

            //处理通话记录时间
            SetCallTime(data);
            var validator = new SubmitCaseRecordInfoValidator();
            var validResult = await validator.ValidateAsync(data, cancellationToken);
            if (!validResult.IsValid)
                throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));
            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceListRequest<SubmitCaseRecordInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(new List<SubmitCaseRecordInfo>() { data });
            var jsonData = request.ToString();
            var url = configProvince.HuiJu + "submit_case_record";
            #endregion

            //将待推送数据写入待推送表
            await InitPushDataAsync("SubmitCaseRecord", "submit_case_record", jsonData, pathType: EPathType.HuiJu, taskPriority: 20, cancellationToken: cancellationToken);

        }

        /// <summary>
        /// 关联工单了推送----电话记录---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineCallConnectWithOrder)]
        public async Task SubmitCaseRecordOrderAsync(PublishCallRecrodDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<SubmitCaseRecordInfo>(dto.TrCallRecordDto);
            if (dto.Order != null)
            {
                data.AreaCode = dto.Order.AreaCode;
                if (!string.IsNullOrEmpty(dto.Order.ProvinceNo))
                    data.CaseSerial = dto.Order.ProvinceNo;
            }
            else
                data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;

            //处理通话记录时间
            SetCallTime(data);
            var validator = new SubmitCaseRecordInfoValidator();
            var validResult = await validator.ValidateAsync(data, cancellationToken);
            if (!validResult.IsValid)
                throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));
            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceListRequest<SubmitCaseRecordInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(new List<SubmitCaseRecordInfo>() { data });
            var jsonData = request.ToString();
            var url = configProvince.HuiJu + "submit_case_record";
            #endregion

            //将待推送数据写入待推送表
            await InitPushDataAsync("SubmitCaseRecord", "submit_case_record", jsonData, pathType: EPathType.HuiJu, taskPriority: 20, cancellationToken: cancellationToken);
        }

        /// <summary>
        /// 统计数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SubmitCaseTotalAsync(SubmitCaseTotalInfo dto, CancellationToken cancellationToken)
        {
            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceListRequest<SubmitCaseTotalInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(new List<SubmitCaseTotalInfo>() { dto });
            var jsonData = request.ToString();
            var url = configProvince.HuiJu + "submit_case_total";
            #endregion

            //将待推送数据写入待推送表
            await InitPushDataAsync("SubmitCaseTotal", "submit_case_total", jsonData, pathType: EPathType.HuiJu, cancellationToken: cancellationToken);
        }

        #endregion

        #region 协同-第三批次

        /// <summary>
        /// 上报补充诉求---需要再次确认
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SupplyCaseInfoSendAsync(SupplyCaseInfoSendInfo dto, CancellationToken cancellationToken)
        {
            dto.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;
            dto.CliengGuid = Guid.NewGuid().ToString();

            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceRequest<SupplyCaseInfoSendInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(dto);
            var jsonData = request.ToString();
            var url = configProvince.XieTong + "supply_case_info_send";
            #endregion

            //将待推送数据写入待推送表
            await InitPushDataAsync("SupplyCaseInfoSend", "supply_case_info_send", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);

            //处理附件
            await FileDataAsync(null, dto.CaseSerial, dto.CliengGuid, EMaterialType.Process, dto.AreaCode, cancellationToken);
        }

        /// <summary>
        /// 撤单----1
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderFlowRecalled)]
        public async Task RevokeOrderAsync(PublishSpecialDto dto, CancellationToken cancellationToken)
        {
            //企业服务
            if (dto.Special.OrgId == "001180")
            {
                CancelWorkOrder dsDataWork = new()
                {
                    WorkOrderNo = dto.Order.No,
                    Reason = dto.Special.Reason
                };

                var configEnterprise = _channelConfigurationManager.GetConfigurationEnterprise();
                //将待推送数据写入待推送表configEnterprise.AddressUrl +
                await InitPushDataAsync("EnterpriseCancelWorkOrder", "platform/12345/cancelWorkOrder", System.Text.Json.JsonSerializer.Serialize(dsDataWork), platformSource: EPlatformSource.Enterprise, cancellationToken: cancellationToken);
            }

            //省12345
            if (dto.Special.OrgId == "001170" || dto.Special.OrgId == "001177")
            {
                RevokeCaseInfoModel dsRevoke = new()
                {
                    CaseSerial = dto.Order.ProvinceNo,
                    AreaCode = dto.Order.AreaCode,
                    RevokeTime = dto.Special.CreationTime,
                    RevokeName = dto.Special.CreatorName,
                    RevokeReasion = dto.Special.Reason,
                    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";

                #region 处理请求参数
                var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                var request = new ProvinceRequest<RevokeCaseInfoModel>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(dsRevoke);
                var jsonData = request.ToString();
                var url = configProvince.XieTong + "revoke_case_info";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("SendRevokeCaseInfo", "revoke_case_info", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);

                await FileDataAsync(dto.Special.FileJson, dto.Order.ProvinceNo, dsRevoke.CliengGuid, EMaterialType.Process, dto.Order.AreaCode, cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单催单--已对接----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderUrgeInform)]
        public async Task SendRemindCaseInfoAsync(PublishUrgeDto dto, CancellationToken cancellationToken)
        {
            //被催办部门为省上，才能调用接口
            if (dto.Urge.OrgId == "001170" || dto.Urge.OrgId == "001177")
            {
                var data = _mapper.Map<RemindCaseInfoModel>(dto);
                data.CliengGuid = dto.Urge.Id;

                #region 处理请求参数
                var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                var request = new ProvinceRequest<RemindCaseInfoModel>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(data);
                var jsonData = request.ToString();
                var url = configProvince.XieTong + "remind_case_info";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("SendRemindCaseInfo", "remind_case_info", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);

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

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

                var data = _mapper.Map<GetCaseResultReceiveInfo>(dto.Order);
                data.ConcactType = "40";
                data.FinishType = "1";
                data.HandleTimeLong = (decimal)dto.Order.AllDuration;
                data.ConcactType = dto.Order.RealCommunicationMode switch
                {
                    ERealCommunicationMode.Phone => "10",
                    ERealCommunicationMode.Locale => "20",
                    _ => "40",
                };
                data.CliengGuid = Guid.NewGuid().ToString();

                //中国政府网的数据处理
                if (dto.Order.ProvinceNo.Contains("ZGZFW"))
                {
                    data.Notes = dto.Remark;
                    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 = dto.IsContact == true ? "1" : "0";
                    data.AssessFlag = dto.IsVisited == true ? "1" : "0";
                    data.AssessContent = dto.EvaluateContent;
                    if (dto.NetizenEvaluate != null)
                    {
                        data.AssessOpinion = dto.NetizenEvaluate.Value;
                    }
                }

                #region 处理请求参数
                var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                var request = new ProvinceRequest<GetCaseResultReceiveInfo>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(data);
                var jsonData = request.ToString();
                var url = configProvince.XieTong + "get_case_result_receive";
                #endregion

                await InitPushDataAsync("GetCaseResultReceive", "get_case_result_receive", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);

                //处理附件
                await FileDataAsync(null, dto.Order.ProvinceNo, data.CliengGuid, EMaterialType.Result, dto.Order.AreaCode, cancellationToken);
                #endregion
            }

            //政民互动提交公开
            if (dto.Order.SourceChannelCode == "SZMHD" && dto.ProPublishState == true)
            {
                var data = _mapper.Map<ZmhdCaseInfoPublicInfo>(dto);

                #region 处理请求参数
                var configProvince = _channelConfigurationManager.GetConfigurationProvince();
                var request = new ProvinceRequest<ZmhdCaseInfoPublicInfo>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(data);
                var jsonData = request.ToString();
                var url = configProvince.XieTong + "zmhd_case_info_public";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("ZmhdCaseInfoPublic", "zmhd_case_info_public", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);
            }

        }

        /// <summary>
        /// 接收发布的时候生成的待回访部门数据
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineOrderVisitedWeb)]
        public async Task PublishVisitAllAsync(PublishVisitAllDto dto, CancellationToken cancellationToken)
        {
            if (dto != null)
            {
                List<DsOrderVisit> orderVisits = new List<DsOrderVisit>();
                //1、待回访和已回访要将接收的数据写入库
                //2、其他状态的时候需要将工单的回访状态改成不能回访

                //处理待回访和已回访的数据
                if (dto.VisitState == EVisitState.WaitForVisit || dto.VisitState == EVisitState.Visited)
                {
                    if (dto.OrderVisitDetails != null && dto.OrderVisitDetails.Count > 0)
                    {
                        //组装回访数据
                        foreach (var item in dto.OrderVisitDetails)
                        {
                            DsOrderVisit dsOrderVisit = new()
                            {
                                OrderId = dto.Order.Id,
                                VisitDetailId = item.Id,
                                VisitId = item.VisitId,
                                VoiceEvaluate = item.VoiceEvaluate.ToString(),
                                SeatEvaluate = item.SeatEvaluate.ToString(),
                                OrgProcessingResults = _mapper.Map<Kv>(item.OrgProcessingResults),
                                OrgNoSatisfiedReason = _mapper.Map<List<Kv>>(item.OrgNoSatisfiedReason),
                                OrgHandledAttitude = _mapper.Map<Kv>(item.OrgHandledAttitude),
                                VisitContent = item.VisitContent,
                                VisitOrgName = item.VisitOrgName,
                                VisitOrgCode = item.VisitOrgCode,
                                VisitTarget = item.VisitTarget.ToString(),
                                VisitType = dto.VisitType.ToString(),
                                VisitTime = dto.VisitTime,
                                IsEffective = true
                            };
                            orderVisits.Add(dsOrderVisit);
                        }

                        //// 方式一：  保留数据
                        //var tempList = await _dsOrderVisitRepository.Queryable().Where(p => p.OrderId == dto.Order.Id && p.IsEffective == true).ToListAsync();
                        //foreach (var item in tempList)
                        //{
                        //    item.IsEffective = false;
                        //    await _dsOrderVisitRepository.UpdateAsync(item, cancellationToken);
                        //}
                        //方式二：直接删除原始数据
                        await _dsOrderVisitRepository.RemoveAsync(p => p.OrderId == dto.Order.Id);

                        //写入新数据
                        await _dsOrderVisitRepository.AddRangeAsync(orderVisits, cancellationToken);
                    }
                }

                //处理是否可以评价，如果是
                var orderData = await _dsOrderRepository.GetAsync(p => p.OrderId == dto.Order.Id);
                if (orderData is not null)
                {
                    var tempState = orderData.VisitTypeState;
                    switch (dto.VisitState)
                    {
                        case EVisitState.WaitForVisit:
                            orderData.VisitTypeState = EVisitTypeState.Visit;
                            break;
                        case EVisitState.Visited:
                            orderData.VisitTypeState = EVisitTypeState.Reviewed;
                            break;
                        case EVisitState.Visiting:
                        case EVisitState.NoSatisfiedWaitForVisit:
                        case EVisitState.None:
                            orderData.VisitTypeState = EVisitTypeState.UnVisit;
                            break;
                        default:
                            break;
                    }
                    if (tempState != orderData.VisitTypeState)
                        await _dsOrderRepository.UpdateAsync(orderData, cancellationToken);
                }

            }
        }
        #endregion

        #region 协同-第四批次

        #region 知识库--已对接附件
        /// <summary>
        /// 知识库上报----1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineKnowledgeAdd)]
        public async Task GetKnowledgeInfoSendAsync(KnowledgeSendDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<KnowledgeInfoSendInfo>(dto);
            data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;
            data.CliengGuid = Guid.NewGuid().ToString();
            if (data.DisableDate == null)//如果没得有失效时间，默认在生效日期上面加10年
                data.DisableDate = data.BeginDate.Value.AddYears(10);

            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceRequest<KnowledgeInfoSendInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(data);
            var jsonData = request.ToString();
            var url = configProvince.HuiJu + "get_knowledge_info_send";
            #endregion

            //将待推送数据写入待推送表
            await InitPushDataAsync("GetKnowledgeInfoSend", "get_knowledge_info_send", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);

            #region 处理知识库原始数据
            //查询原有数据，如果有修改原始数据，没有直接新增
            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, cancellationToken: cancellationToken);
            }
            else
                await _knowledgeRawDataRepository.AddAsync(raw, cancellationToken: cancellationToken);
            #endregion

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

        }

        /// <summary>
        /// 知识库变更---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineKnowledgeUpdate)]
        public async Task GetKnowledgeInfoUpdateAsync(KnowledgeSendDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<GetKnowledgeInfoUpdateInfo>(dto);
            data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;
            data.CliengGuid = Guid.NewGuid().ToString();
            if (data.DisableDate == null)//如果没得有失效时间，默认在生效日期上面加10年
                data.DisableDate = data.BeginDate.Value.AddYears(10);

            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceRequest<GetKnowledgeInfoUpdateInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(data);
            var jsonData = request.ToString();
            var url = configProvince.HuiJu + "get_knowledge_info_update";
            #endregion

            //将待推送数据写入待推送表
            await InitPushDataAsync("GetKnowledgeInfoUpdate", "get_knowledge_info_update", jsonData, pathType: EPathType.HuiJu, cancellationToken: cancellationToken);

            #region 处理知识库原始数据
            //查询原有数据，如果有修改原始数据，没有直接新增
            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, cancellationToken: cancellationToken);
            }
            else
                await _knowledgeRawDataRepository.AddAsync(raw, cancellationToken: cancellationToken);
            #endregion

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

        /// <summary>
        /// 知识库下架---1
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.HotlineKnowledgeRemove)]
        public async Task GetKnowledgeInfoAbandonAsync(KnowledgeSendDto dto, CancellationToken cancellationToken)
        {
            var data = _mapper.Map<GetKnowledgeInfoAbandonInfo>(dto);
            data.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;

            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceRequest<GetKnowledgeInfoAbandonInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(data);
            var jsonData = request.ToString();
            var url = configProvince.HuiJu + "get_knowledge_info_abandon";
            #endregion

            //将待推送数据写入待推送表
            await InitPushDataAsync("GetKnowledgeInfoAbandon", "get_knowledge_info_abandon", jsonData, pathType: EPathType.HuiJu, cancellationToken: cancellationToken);

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

        }
        #endregion

        /// <summary>
        /// 实时服务上报
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task SendRealTimeStatusAsync(SendRealTimeStatusInfo dto, CancellationToken cancellationToken)
        {
            dto.AreaCode = _channelConfigurationManager.GetConfigurationCityCode().AreaCode;

            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceRequest<SendRealTimeStatusInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(dto);
            var jsonData = request.ToString();
            var url = configProvince.HuiJu + "sendrealtimestatus";
            #endregion

            await InitPushDataAsync("SendRealTimeStatus", "sendrealtimestatus", jsonData, pathType: EPathType.HuiJu, cancellationToken: cancellationToken);
        }
        #endregion

        #region 私有方法

        #region 省数据处理

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

            #region 写本地办理数据-用于查询办理流程
            //写本地办理数据-用于查询办理流程
            var orderWorkFlow = _mapper.Map<DsOrderWorkFlow>(dto.WorkflowTrace);
            orderWorkFlow.OrderId = dto.Order.Id;

            await _dataOrderWorkFlowRepository.AddAsync(orderWorkFlow, cancellationToken);
            #endregion

            var configProvince = _channelConfigurationManager.GetConfigurationProvince();

            //省上下来的工单走协同的接口
            if (dto.Order.Source == ESource.ProvinceStraight && dto.Order.IsProvince)
            {
                var data = _mapper.Map<GetCaseProcessReceiveInfo>(dto);
                data.TacheName = "70:" + data.DeptName;
                var validator = new GetCaseProcessReceiveInfoValidator();
                var validResult = await validator.ValidateAsync(data, cancellationToken);
                if (!validResult.IsValid)
                    throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));
                #region 处理请求参数
                var request = new ProvinceRequest<GetCaseProcessReceiveInfo>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(data);
                var jsonData = request.ToString();
                var url = configProvince.XieTong + "get_case_process_receive";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("GetCaseProcessReceive", "get_case_process_receive", jsonData, pathType: EPathType.XieTong, cancellationToken: cancellationToken);

                //处理附件
                await FileDataAsync(dto.WorkflowTrace.FileJson, dto.Order.ProvinceNo, data.CliengGuid, EMaterialType.Process, dto.Order.AreaCode, cancellationToken);
            }
            else  //如果不是省上派下来的工单
            {
                //本地工单走市州接口
                var data = _mapper.Map<SubmitCaseProcessInfo>(dto);
                data.TacheName = "70:" + data.DeptName;

                var validator = new SubmitCaseProcessInfoValidator();
                var validResult = await validator.ValidateAsync(data, cancellationToken);
                if (!validResult.IsValid)
                    throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));

                #region 处理请求参数
                var requestSubmitCaseProcessInfo = new ProvinceListRequest<SubmitCaseProcessInfo>(configProvince.ClientId, configProvince.ClientSecret);
                requestSubmitCaseProcessInfo.SetData(new List<SubmitCaseProcessInfo>() { data });
                var jsonDataSubmitCaseProcessInfo = requestSubmitCaseProcessInfo.ToString();
                var urlSubmitCaseProcessInfo = configProvince.HuiJu + "submit_case_process";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("SubmitCaseProcess", "submit_case_process", jsonDataSubmitCaseProcessInfo, pathType: EPathType.HuiJu, cancellationToken: cancellationToken);

                //处理附件
                await FileDataAsync(dto.WorkflowTrace.FileJson, dto.Order.ProvinceNo, data.CliengGuid, EMaterialType.Process, dto.Order.AreaCode, cancellationToken);
            }

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

        /// <summary>
        /// 派单是判断需要往第三方推送数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task OrderDispatchAsync(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 InitPoliceSendChainAlarmDsAsync(dto.Order, cancellationToken);

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

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

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

        /// <summary>
        /// 服务工单回访评价/服务工单交办评价
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        private async Task SubmitVisitInfoDataAsync(PublishVisitDto dto, CancellationToken cancellationToken)
        {
            #region 修改工单基础数据为已评价
            ////修改工单基础数据为已评价
            //var dataOrder = await _dsOrderRepository.GetAsync(p => p.OrderId == dto.Order.Id, cancellationToken);
            //if (dataOrder != null)
            //{
            //    dataOrder.VisitTypeState = EVisitTypeState.Reviewed;
            //    await _dsOrderRepository.UpdateAsync(dataOrder, cancellationToken);
            //}
            #endregion

            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;
            }

            var configProvince = _channelConfigurationManager.GetConfigurationProvince();

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

                data.VisitType = visitType;
                data.CliengGuid = Guid.NewGuid().ToString();
                var validator = new GetVisitInfoReceiveInfoValidator();
                var validResult = await validator.ValidateAsync(data, cancellationToken);
                if (!validResult.IsValid)
                    throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));
                #region 处理请求参数
                var request = new ProvinceRequest<GetVisitInfoReceiveInfo>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(data);
                var jsonData = request.ToString();
                var url = configProvince.XieTong + "get_visit_info_receive";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("GetVisitInfoReceive", "get_visit_info_receive", jsonData, pathType: EPathType.XieTong, taskPriority: 5, cancellationToken: cancellationToken);
                //处理附件
                await FileDataAsync(null, data.CaseSerial, data.CliengGuid, EMaterialType.Visit, data.AreaCode, cancellationToken);
            }
            else
            {
                var data = _mapper.Map<SubmitVisitInfo>(dto);
                data.VisitType = visitType;
                data.CliengGuid = Guid.NewGuid().ToString();

                var validator = new SubmitVisitInfoValidator();
                var validResult = await validator.ValidateAsync(data, cancellationToken);
                if (!validResult.IsValid)
                    throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));
                #region 处理请求参数
                var request = new ProvinceListRequest<SubmitVisitInfo>(configProvince.ClientId, configProvince.ClientSecret);
                request.SetData(new List<SubmitVisitInfo>() { data });
                var jsonData = request.ToString();
                var url = configProvince.HuiJu + "submit_visit_info";
                #endregion

                //将待推送数据写入待推送表
                await InitPushDataAsync("SubmitVisitInfo", "submit_visit_info", jsonData, pathType: EPathType.HuiJu, taskPriority: 5, cancellationToken: cancellationToken);

                //处理附件
                await FileDataAsync(null, data.CaseSerial, data.CliengGuid, EMaterialType.Visit, 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 SubmitCaseResultAsync(OrderFlowDto dto, CancellationToken cancellationToken)
        {

            var data = _mapper.Map<SubmitCaseResultInfo>(dto);
            data.ConcactType = "40";
            data.FinishType = "1";
            data.HandleTimeLong = (int)dto.Order.AllDuration;
            data.CliengGuid = Guid.NewGuid().ToString();

            //宜宾工单不超期，如果在推送省上数据时，实际办理时间大于过期时间，则将办理时间改成过期时间减2个小时
            if (dto.Order.ExpiredTime < dto.Order.ActualHandleTime)
            {
                var finishTime = dto.Order.ExpiredTime.Value.AddHours(-2);
                data.FinishTime = finishTime;
                data.FdBackTime = finishTime;
            }
            var validator = new SubmitCaseResultInfoValidator();
            var validResult = await validator.ValidateAsync(data, cancellationToken);
            if (!validResult.IsValid)
                throw new UserFriendlyException(string.Join(',', validResult.Errors.Select(d => d.ErrorMessage)));

            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceListRequest<SubmitCaseResultInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(new List<SubmitCaseResultInfo>() { data });
            var jsonData = request.ToString();
            var url = configProvince.HuiJu + "submit_case_result";
            #endregion

            //将待推送数据写入待推送表
            await InitPushDataAsync("SubmitCaseResult", "submit_case_result", jsonData, pathType: EPathType.HuiJu, cancellationToken: cancellationToken);

            //处理附件
            if (dto.WorkflowTrace != null && dto.WorkflowTrace.FileJson != null && dto.WorkflowTrace.FileJson.Count > 0)
                await FileDataAsync(dto.WorkflowTrace.FileJson, data.CaseSerial, data.CliengGuid, EMaterialType.Result, dto.Order.AreaCode, cancellationToken);
            //判断如果是110过来的数据，就组装数据
            //组装110
            if (dto.Order.Source == ESource.Police110)
            {
                await InitPoliceSendChainDealDsAsync(dto, cancellationToken);
            }
        }

        /// <summary>
        /// 工单创建数据处理
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task<SubmitCaseInfo> InitDataAsync(OrderDto dto, CancellationToken cancellationToken)
        {
            var submitCaseInfo = _mapper.Map<SubmitCaseInfo>(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;
            }
            submitCaseInfo.CaseValid = "1";
            submitCaseInfo.CaseIsPublic = string.IsNullOrEmpty(submitCaseInfo.CaseIsPublic) == true ? "0" : submitCaseInfo.CaseIsPublic;
            submitCaseInfo.ThemeSerial = "05";

            if (dto.SourceChannelCode == "SZMHD" && dto.IsProvince == false && dto.Source == ESource.ProvinceStraight)
                submitCaseInfo.TrowGuid = "【政民互动直派】";

            switch (dto.SourceChannelCode.ToUpper())
            {
                case "RGDH":
                case "WX":
                case "WB":
                case "AP":
                case "WZ":
                case "YJ":
                case "SCZWFWW":
                case "XCX":
                    break;
                default:
                    submitCaseInfo.CaseSource = "QT";
                    break;
            }

            return submitCaseInfo;
        }

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

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

            //处理为统一的市场监管表单
            if (formType == "scjgjts" || formType == "scjgjjb")
                formType = "scjgj";

            DataSharing.Share.Dtos.Province.HuiJu.SubmitCaseExtendsInfo submitCaseExtendsInfo = new()
            {
                CaseSerial = dto.ProvinceNo,
                FormType = formType
            };

            //处理扩展信息
            switch (formType.ToLower())
            {
                case "yl"://医疗表单
                    //转换数据
                    submitCaseExtendsInfo.FormMedical = _mapper.Map<FormMedicalInfo>(orderExtension);
                    break;
                case "zwfw"://四川政务服务网技术工单
                    submitCaseExtendsInfo.FormNetWorktec = _mapper.Map<FormNetWorktecInfo>(orderExtension);
                    break;
                case "th"://电视购物及商铺购买退换货工单
                    submitCaseExtendsInfo.FormReturnexChange = _mapper.Map<FormReturnexChangeInfo>(orderExtension);
                    break;
                case "gsgl"://高速公路工单
                    submitCaseExtendsInfo.FormExpressWay = _mapper.Map<FormExpressWayInfo>(orderExtension);
                    break;
                case "xjgg"://电视台虚假广告工单
                    submitCaseExtendsInfo.FormShamPub = _mapper.Map<FormShamPubInfo>(orderExtension);
                    break;
                case "swfwsq"://12366热线诉求交办
                    submitCaseExtendsInfo.FormTaxationComplaint = _mapper.Map<FormTaxationComplaintInfo>(orderExtension);
                    break;
                case "swfwzx"://12366热线咨询交办
                    submitCaseExtendsInfo.FormTaxationConsulting = _mapper.Map<FormTaxationConsultingInfo>(orderExtension);
                    break;
                case "jtfwjd"://12328服务监督
                    submitCaseExtendsInfo.FormTraffic = _mapper.Map<FormTrafficInfo>(orderExtension);
                    break;
                case "yzxf"://邮政业消费者申诉
                    submitCaseExtendsInfo.FormPost = _mapper.Map<FormPostInfo>(orderExtension);
                    break;
                case "hbjb"://环保举报业务
                    submitCaseExtendsInfo.FormEnvironMent = _mapper.Map<FormEnvironMentInfo>(orderExtension);
                    break;
                case "scjgj"://12315个性化表单
                    var formMarket = _mapper.Map<FormMarketInfo>(orderExtension);
                    //转换数据
                    switch (orderExtension.OrderTypeCode)
                    {
                        case "scjgjjb":
                            formMarket.Rqsttypy = "25";
                            break;
                        case "scjgjts":
                            formMarket.Rqsttypy = "20";
                            foreach (var item in orderExtension.ComplainTypes)
                                formMarket.AppealContent += item.Value + ",";
                            formMarket.AppealContent = formMarket.AppealContent.TrimEnd(',');
                            break;
                        default:
                            break;
                    }
                    formMarket.HandDepCode = dto.AcceptorOrgCode;
                    formMarket.HandDep = dto.AcceptorOrgName;
                    formMarket.Zxgh = dto.AcceptorStaffNo;
                    formMarket.AccregperId = dto.AcceptorId;
                    formMarket.AccregperName = dto.AcceptorName;
                    formMarket.RegTime = Convert.ToDateTime(dto.CreationTime);
                    formMarket.CmTime = dto.StartTime;
                    submitCaseExtendsInfo.FormMarket = formMarket;
                    break;
                default:
                    break;
            }

            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceRequest<DataSharing.Share.Dtos.Province.HuiJu.SubmitCaseExtendsInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(submitCaseExtendsInfo);
            var jsonData = request.ToString();
            var url = configProvince.HuiJu + "submit_case_extends";
            #endregion

            //将待推送数据写入待推送表
            await InitPushDataAsync("SubmitCaseExtends", "submit_case_extends", jsonData, pathType: EPathType.HuiJu, cancellationToken: cancellationToken);
        }

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

            //在处理工单信息
            var sendCaseInfo = _mapper.Map<SendCaseInfo>(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
            switch (dto.SourceChannelCode.ToUpper())
            {
                case "RGDH":
                case "WX":
                case "WB":
                case "AP":
                case "WZ":
                case "YJ":
                case "SCZWFWW":
                case "XCX":
                    break;
                default:
                    sendCaseInfo.CaseSource = "QT";
                    break;
            }
            sendCaseInfo.CaseSource = sendCaseInfo.CaseSource;

            var sendCaseInfoData = _mapper.Map<DsSendCaseInfo>(sendCaseInfo);
            sendCaseInfoData.OrderID = dto.Id;
            sendCaseInfoData.No = dto.No;
            await _sendCaseInfoRepository.AddAsync(sendCaseInfoData, cancellationToken);

            #region 处理请求参数
            var configProvince = _channelConfigurationManager.GetConfigurationProvince();
            var request = new ProvinceRequest<SendCaseInfo>(configProvince.ClientId, configProvince.ClientSecret);
            request.SetData(sendCaseInfo);
            var jsonData = request.ToString();
            var url = configProvince.HuiJu + "send_case_info";
            #endregion
            //将待推送数据写入待推送表
            await InitPushDataAsync("SendCaseInfo", "send_case_info", jsonData, pathType: EPathType.HuiJu, cancellationToken: cancellationToken);

            //处理附件
            //await FileDataAsync(dto.FileJson, dto.ProvinceNo, sendCaseInfoData.CliengGuid, EMaterialType.Acceptance, sendCaseInfoData.AreaCode, cancellationToken);

        }

        /// <summary>
        /// 附件处理
        /// </summary>
        /// <param name="fileJson">附件</param>
        /// <param name="caseSerial">工单编号</param>
        /// <param name="cliengGuid">附件ID</param>
        /// <param name="materialType">附件类型   10：受理材料，20：环节材料，30：结果材料，40：回访评价材料，50：督办材料，60：知识库材料</param>
        /// <param name="areaCode">区域ID</param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        private async Task FileDataAsync(List<Hotline.Share.Dtos.File.FileJson> fileJson, string caseSerial, string cliengGuid, EMaterialType materialType, string areaCode, CancellationToken cancellationToken)
        {
            if (fileJson != null && fileJson.Count > 0)
            {
                //将受到的数据写入本地数据库
                GetCaseMaterialInfoModel materialInfo = new()
                {
                    CaseSerial = caseSerial,
                    CliengGuid = cliengGuid,
                    AreaCode = areaCode,
                    MaterialType = materialType switch
                    {
                        EMaterialType.Acceptance => "10",
                        EMaterialType.Process => "20",
                        EMaterialType.Result => "30",
                        EMaterialType.Visit => "40",
                        EMaterialType.Supervise => "50",
                        EMaterialType.Knowledge => "60",
                        _ => "20",
                    }
                };
                foreach (var item in fileJson)
                {
                    List<FileJson> fileJsons = new() { _mapper.Map<FileJson>(item) };
                    //待推送数据写入待推送表
                    await InitPushDataAsync("GetCaseMaterialInfo", "get_case_material_info", System.Text.Json.JsonSerializer.Serialize(materialInfo), pathType: EPathType.File, fileJson: fileJsons, cancellationToken: cancellationToken);
                }
            }
        }

        /// <summary>
        /// 处理通话记录队列时间
        /// </summary>
        /// <param name="recordInfo"></param>
        /// <returns></returns>
        private void SetCallTime(SubmitCaseRecordInfo recordInfo)
        {
            // 电话进入顺序 进IVR时间→进队列时间→振铃时间→开始时间→结束时间

            //进入IVR时间为空
            if (recordInfo.InIvr == null)
            {
                if (recordInfo.InQueue == null)
                {
                    recordInfo.InQueue = recordInfo.CallStart.Value.AddSeconds(-2);
                }
                recordInfo.InIvr = recordInfo.InQueue.Value.AddSeconds(-2);
            }

            //进入队列时间为空
            if (recordInfo.InQueue == null)
            {
                if (recordInfo.InIvr == null)
                {
                    recordInfo.InQueue = recordInfo.CallStart.Value.AddSeconds(-2);
                    recordInfo.InIvr = recordInfo.InQueue.Value.AddSeconds(-2);
                }
                else
                    recordInfo.InQueue = recordInfo.InIvr.Value.AddSeconds(2);
            }

            //振铃时间为空
            if (recordInfo.CallTime == null && recordInfo.CallStart != null)
                recordInfo.CallTime = recordInfo.CallStart.Value.AddSeconds(-2);

        }

        /// <summary>
        /// 检查是否需要推送未接通话记录
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        private async Task<bool> IsPublishMissedCall(TrCallDto dto, CancellationToken cancellationToken)
        {
            var key = MissedCallKey + DateTime.Now.ToString("yyyyMMdd");
            var provinceConfiguration = _channelConfigurationManager.GetConfigurationProvince();
            var missedCallCount = provinceConfiguration.MissedCallCount;

            var dataCache = await _missedCallModelCache.GetAsync(key, cancellationToken);
            if (dataCache != null)
            {
                //如果存在值，检查是否已经达到推送最大值
                if (!dataCache.IsMax && dataCache.DateTimeList.Count > 0)
                {
                    //没有达到最大值
                    //检查第一条数据是否匹配当前推送时间
                    var list = dataCache.DateTimeList;
                    if (list[0] < dto.AnsweredTime)
                    {
                        //处理数据
                        list.RemoveAt(0);

                        dataCache.DateTimeList = list;
                        //是否推送完成
                        if (list == null || list.Count == 0)
                            dataCache.IsMax = true;

                        //从新写入数据
                        await _missedCallModelCache.SetAsync(key, dataCache, TimeSpan.FromDays(1), cancellationToken);

                        return true;
                    }
                }
            }
            else
            {
                #region 生成时间
                //生成时间
                List<DateTime> timeLists = new();
                Random random = new((int)(DateTime.Now.Ticks));
                for (int i = 0; i < missedCallCount; i++)
                {
                    int hour = random.Next(2, 23);
                    int minute = random.Next(0, 60);
                    int second = random.Next(0, 60);
                    string tempStr = string.Format("{0} {1}:{2}:{3}", DateTime.Now.ToString("yyyy-MM-dd"), hour, minute, second);
                    DateTime rTime = Convert.ToDateTime(tempStr);
                    timeLists.Add(rTime);
                }
                timeLists.Sort();
                #endregion

                if (timeLists[0] < dto.AnsweredTime)
                    //处理数据
                    timeLists.RemoveAt(0);

                MissedCallModelDto missedCall = new()
                {
                    DateTimeList = timeLists
                };
                if (timeLists == null || timeLists.Count == 0)
                    missedCall.IsMax = true;

                await _missedCallModelCache.SetAsync(key, missedCall, TimeSpan.FromDays(1), cancellationToken);
                return true;
            }
            return false;
        }
        #endregion

        #region 组装110数据
        /// <summary>
        /// 组装110数据，12345警情工单推送到110
        /// </summary>
        /// <param name="orderDto"></param>
        /// <returns></returns>
        private async Task InitPoliceSendChainAlarmDsAsync(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.AreaCode + orderDto.No + "12345";
                policeSend.SerialNumber = orderDto.AreaCode + orderDto.No + "12345";
            }

            //修改外部唯一ID
            var orderData = await _dsOrderRepository.GetAsync(p => p.OrderId == orderDto.Id, cancellationToken);
            if (orderData != null)
            {
                orderData.ExternalId = policeSend.AlarmReceiptNumber;
                await _dsOrderRepository.UpdateAsync(orderData, cancellationToken);
            }


            //查询是否有此工单，如果没有新增此工单
            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 InitPoliceSendChainDealDsAsync(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 InitCityDataYBAsync(OrderDto dto, CancellationToken cancellationToken)
        {
            var cityHandOver = _channelConfigurationManager.GetConfigurationCityHandOver();
            string source = cityHandOver.SendCityName;
            string secretKey = GetMD5(source + cityHandOver.SecretKey);

            string fromGender = dto.FromGender switch
            {
                EGender.Female => "2",
                EGender.Male => "1",
                _ => "0",
            };
            Dictionary<string, string> dicParam = new()
            {
                { "Code", secretKey },
                { "FSHCode", dto.No },
                { "ServerName", dto.IdentityType == EIdentityType.Enterprise ? "1" : "0"},
                { "PurTypeName",dto.AcceptType },
                { "ConTypeName", dto.HotspotSpliceName},
                { "Title", dto.Title},
                { "LinkName", dto.FromName},
                { "Gender",fromGender},
                { "Mobile", dto.Contact},
                { "Mail","" },
                { "Address", dto.Address },
                { "Content", dto.Content},
                { "Source",source }
            };

            //写入待推送数据
            await InitPushDataAsync("InitCityDataYB", "CityHandOver.asmx/FlowWrite", System.Text.Json.JsonSerializer.Serialize(dicParam), platformSource: EPlatformSource.CityDataExchange, cancellationToken: cancellationToken);

        }
        #endregion

        #region 宜宾企业专班数据提交
        /// <summary>
        /// 企业专班数据提交
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        private async Task InitEnterpriseDataAsync(OrderDto dto, CancellationToken cancellationToken)
        {
            var enterpriseData = _mapper.Map<PushWorkOrder>(dto);
            var fileJson = _mapper.Map<List<FileJson>>(dto.FileJson);
            var configEnterprise = _channelConfigurationManager.GetConfigurationEnterprise();
            //将待推送数据写入待推送表
            await InitPushDataAsync("EnterprisePushWorkOrder", "platform/12345/pushWorkOrder", System.Text.Json.JsonSerializer.Serialize(enterpriseData), platformSource: EPlatformSource.Enterprise, fileJson: fileJson, cancellationToken: cancellationToken);

        }
        #endregion

        #region 初始化待推送数据
        /// 初始化待推送数据
        /// </summary>
        /// <param name="taskType">任务类型</param>
        /// <param name="path">请求地址</param>
        /// <param name="request">请求参数</param>
        /// <param name="pathType"></param>
        /// <param name="cancellationToken"></param>
        /// <param name="httpMethod">请求方式</param>
        /// <param name="platformSource">推送平台</param>
        /// <param name="taskPriority">任务优先级(0:最低级别)</param>
        /// <param name="fileJson">附件</param>
        /// <returns></returns>
        private async Task InitPushDataAsync(string taskType, string path, string request,
            string httpMethod = "Post",
            EPlatformSource platformSource = EPlatformSource.Province,
            EPathType pathType = EPathType.Other,
            int taskPriority = 0,
            List<FileJson>? fileJson = null,
            CancellationToken cancellationToken = default)
        {
            //组装参数
            DsSendTask dsSendTask = new()
            {
                TaskPriority = taskPriority,
                TaskType = taskType,
                HttpMethod = httpMethod,
                Path = path,
                PlatformSource = platformSource,
                FileJson = fileJson,
                Request = request,
                PathType = pathType
            };
            await _dsSendTaskRepository.AddAsync(dsSendTask, cancellationToken);
        }
        #endregion

        #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 = MD5.Create();
                // 加密后是一个字节类型的数组，这里要注意编码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

        #endregion
    }
}