hotline/src/Hotline.Application/Subscribers/DatasharingSubscriber.cs

using DotNetCore.CAP;
using Hotline.Application.FlowEngine;
using Hotline.Application.Quality;
using Hotline.Authentications;
using Hotline.File;
using Hotline.FlowEngine.WorkflowModules;
using Hotline.FlowEngine.Workflows;
using Hotline.Orders;
using Hotline.OrderTranspond;
using Hotline.Settings;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.DataSharing.PusherHotlineDto;
using Hotline.Share.Dtos.FlowEngine;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Dtos.OrderTranspond;
using Hotline.Share.Enums.FlowEngine;
using Hotline.Share.Enums.Order;
using Hotline.Share.Enums.Quality;
using Hotline.Share.Mq;
using MapsterMapper;
using XF.Domain.Dependency;
using XF.Domain.Exceptions;
using XF.Domain.Repository;

namespace Hotline.Application.Subscribers
{
    /// <summary>
    /// 订阅来自DataSharing的消息
    /// </summary>
    public class DataSharingSubscriber : ICapSubscribe, ITransientDependency
    {
        private readonly IRepository<OrderVisit> _orderVisitRepository;
        private readonly IRepository<OrderVisitDetail> _orderVisitDetailRepository;
        private readonly IMapper _mapper;
        private readonly IOrderRepository _orderRepository;
        private readonly IOrderDomainService _orderDomainService;
        private readonly ICapPublisher _capPublisher;
        private readonly IQualityApplication _qualityApplication;
        private readonly IRepository<OrderDelay> _orderDelayRepository;
        private readonly IRepository<OrderSendBack> _orderSendBackRepository;
        private readonly IWorkflowApplication _workflowApplication;
        private readonly IWorkflowDomainService _workflowDomainService;
        private readonly IFileRepository _fileRepository;
        private readonly IRepository<OrderUrge> _orderUrgeRepository;
        private readonly IRepository<OrderSupervise> _orderSuperviseRepository;
        private readonly IRepository<OrderVisitDetail> _orderVisitedDetailRepository;
        private readonly IOrderScreenRepository _orderScreenRepository;
        private readonly IRepository<OrderExtension> _orderExtensionRepository;
        private readonly IRepository<SystemDicData> _systemDicDataRepository;
        private readonly ISystemOrganizeRepository _systemOrganizeRepository;
        private readonly IRepository<TranspondCityRawData> _transpondCityRawDataRepository;
        private readonly IRepository<Workflow> _workflowRepository;

        public DataSharingSubscriber(
            IRepository<OrderVisit> orderVisitRepository,
            IRepository<OrderVisitDetail> orderVisitDetailRepository,
            IMapper mapper,
            IOrderRepository orderRepository,
            IOrderDomainService orderDomainService,
            ICapPublisher capPublisher,
            IQualityApplication qualityApplication,
            IRepository<OrderDelay> orderDelayRepository,
            IRepository<OrderSendBack> orderSendBackRepository,
            IWorkflowApplication workflowApplication,
            IWorkflowDomainService workflowDomainService,
            IRepository<OrderUrge> orderUrgeRepository,
            IRepository<OrderSupervise> orderSuperviseRepository,
            IRepository<OrderVisitDetail> orderVisitedDetailRepository,
            IOrderScreenRepository orderScreenRepository,
            IRepository<OrderExtension> orderExtensionRepository,
            IFileRepository fileRepository,
            IRepository<SystemDicData> systemDicDataRepository,
            ISystemOrganizeRepository systemOrganizeRepository,
            IRepository<TranspondCityRawData> transpondCityRawDataRepository,
            IRepository<Workflow> workflowRepository
            )
        {
            _orderSendBackRepository = orderSendBackRepository;
            _workflowApplication = workflowApplication;
            _workflowDomainService = workflowDomainService;
            _orderUrgeRepository = orderUrgeRepository;
            _orderSuperviseRepository = orderSuperviseRepository;
            _orderScreenRepository = orderScreenRepository;
            _orderExtensionRepository = orderExtensionRepository;
            _orderVisitedDetailRepository = orderVisitedDetailRepository;
            _orderRepository = orderRepository;
            _orderDomainService = orderDomainService;
            _fileRepository = fileRepository;
            _orderVisitRepository = orderVisitRepository;
            _orderVisitDetailRepository = orderVisitDetailRepository;
            _mapper = mapper;
            _capPublisher = capPublisher;
            _orderDelayRepository = orderDelayRepository;
            _systemDicDataRepository = systemDicDataRepository;
            _systemOrganizeRepository = systemOrganizeRepository;
            _transpondCityRawDataRepository = transpondCityRawDataRepository;
            _workflowRepository = workflowRepository;
        }

        /// <summary>
        /// 接收工单退回结果
        /// </summary>
        [CapSubscribe(Hotline.Share.Mq.EventNames.SharingOrderReturnFeedback)]
        public async Task RecOrderReturnAsync(OrderSendBackResultDto dto, CancellationToken cancellationToken)
        {
            var sendBack = await _orderSendBackRepository.GetAsync(dto.Id, cancellationToken);
            if (sendBack != null)
            {
                sendBack.Result = dto.Result;
                sendBack.Reason = dto.Reason;
                var order = await _orderRepository.GetAsync(sendBack.OrderId, cancellationToken);
                order.Status = EOrderStatus.WaitForAccept;
                await _orderRepository.UpdateAsync(order, cancellationToken);
                if (dto.Result is 1)
                {
                    var current = SessionContextCreator.CreateSessionContext(dto.Source);
                    if (string.IsNullOrEmpty(order.WorkflowId))
                    {
                        var startDto = new StartWorkflowDto
                        {
                            DefinitionModuleCode = WorkflowModuleConsts.OrderHandle,
                            Title = order.Title,
                            Opinion = dto.Reason ?? "省工单同意退回",
                        };
                        await _workflowApplication.StartToEndAsync(startDto, current, order.Id, order.ExpiredTime,
                            cancellationToken);
                    }
                    else
                    {
                        //await _workflowApplication.HandleToEndAsync(current, order.WorkflowId, "省工单同意退回", null,
                        //    EReviewResult.Approval, cancellationToken);
                        await _workflowApplication.JumpToEndAsync(current, order.WorkflowId, dto.Reason ?? "省工单同意退回",
                            null, cancellationToken: cancellationToken);
                    }
                }
            }
            await _orderSendBackRepository.UpdateAsync(sendBack, cancellationToken);
        }

        /// <summary>
        /// 服务工单撤单
        /// </summary>
        [CapSubscribe(Hotline.Share.Mq.EventNames.SharingOrderRevoke)]
        public async Task RecCancelOrderAsync(CancelOrderDto dto, CancellationToken cancellationToken)
        {
            var order = await _orderRepository.GetAsync(p => p.ProvinceNo == dto.ProvinceNo, cancellationToken);
            if (order is null)
                throw new UserFriendlyException("未查询到工单");
            var current = SessionContextCreator.CreateSessionContext(dto.Source);
            if (string.IsNullOrEmpty(order?.WorkflowId))
            {
                var startDto = new StartWorkflowDto
                {
                    DefinitionModuleCode = WorkflowModuleConsts.OrderHandle,
                    Title = order.Title,
                    Opinion = dto.Opinion,
                };
                await _workflowApplication.StartToEndAsync(startDto, current, order.Id, order.ExpiredTime,
                    cancellationToken);
            }
            else
            {
                //await _workflowApplication.HandleToEndAsync(current, order.WorkflowId, dto.Opinion, null,
                //    cancellationToken: cancellationToken);
                await _workflowApplication.JumpToEndAsync(current, order.WorkflowId, dto.Opinion, null,
                    cancellationToken: cancellationToken);
            }
        }

        /// <summary>
        /// 服务工单催单
        /// </summary>
        [CapSubscribe(Hotline.Share.Mq.EventNames.SharingOrderRemind)]
        public async Task RecOrderUrgeAsync(ProvinceOrderUrgeDto dto, CancellationToken cancellationToken)
        {
            var order = await _orderRepository.Queryable().Where(x => x.ProvinceNo == dto.CaseSerial).FirstAsync(cancellationToken);
            var model = new OrderUrge();
            model.InitId();
            model.State = 0;
            model.CreatorOrgName = "省12345";
            model.CrUser = dto.RemindName;
            model.ApplyContent = dto.RemindReasion;
            model.OrderId = order.Id;
            model.OrgId = "001";
            model.OrgName = "热线中心";
            model.ApplyContent = dto.RemindReasion;

            if (!string.IsNullOrEmpty(order.WorkflowId))
            {
                var org = await _workflowDomainService.FindActualHandlerAsync(order.WorkflowId, cancellationToken);
                if (org != null)
                {
                    model.OrgId = org.Key;
                    model.OrgName = org.Value;
                }
            }


            if (dto.Files.Any())
                model.FileJson =
                    await _fileRepository.AddFileAsync(dto.Files, model.Id, "", cancellationToken);
            await _orderUrgeRepository.AddAsync(model, cancellationToken);
        }

        /// <summary>
        /// 服务工单预警---收到预警给当前办理部门发催办，如果没有办理部门直接催办中心
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.SharingOrderWarning)]
        public async Task RecWarnInfoAsync(WarningDto dto, CancellationToken cancellationToken)
        {
            var order = await _orderRepository.Queryable().Where(x => x.ProvinceNo == dto.CaseSerial).FirstAsync(cancellationToken);
            var model = new OrderUrge();
            model.InitId();
            model.State = 0;
            model.CreatorOrgName = "省12345";
            model.CrUser = "省12345";
            model.ApplyContent = dto.WarnRulename + "    " + dto.WarnDescribe;
            model.OrderId = order.Id;
            model.ReplyLimitTime = dto.WarnTimebf;
            model.OrgId = "001";
            model.OrgName = "热线中心";

            if (!string.IsNullOrEmpty(order.WorkflowId))
            {
                var org = await _workflowDomainService.FindActualHandlerAsync(order.WorkflowId, cancellationToken);
                if (org != null)
                {
                    model.OrgId = org.Key;
                    model.OrgName = org.Value;
                }
            }

            await _orderUrgeRepository.AddAsync(model, cancellationToken);
        }

        /// <summary>
        /// 督办工单派发接口
        /// </summary>
        [CapSubscribe(Hotline.Share.Mq.EventNames.SharingOrderSupervise)]
        public async Task RecOrderSuperviseAsync(ProvinceSendOrderSuperviseDto dto, CancellationToken cancellationToken)
        {
            var order = await _orderRepository.Queryable().Where(x => x.ProvinceNo == dto.ProvinceOrderSuperviseDto!.CaseSerial).FirstAsync(cancellationToken);
            var org = await _systemOrganizeRepository.GetAsync(x => x.Id == order.ActualHandleOrgCode, cancellationToken);
            var model = new OrderSupervise();
            model.InitId();
            model.OrderId = order.Id;
            model.ReplyLimitTime = dto.ProvinceOrderSuperviseDto.SuperviseReturnDate;
            model.OrgName = org.Name;
            model.OrgId = org.Id;
            model.LaunchOrgName = dto.ProvinceOrderSuperviseDto.SuperviseSendDept;
            model.State = 0;
            model.Province = true;
            model.ApplyContent = dto.ProvinceOrderSuperviseDto.SuperviseContent;
            model.SuperviseSerial = dto.ProvinceOrderSuperviseDto.SuperviseSerial;
            if (dto.Files.Any())
                model.FileJson =
                    await _fileRepository.AddFileAsync(dto.Files, model.Id, "", cancellationToken);
            await _orderSuperviseRepository.AddAsync(model, cancellationToken);
        }

        /// <summary>
        /// 服务工单甄别结果
        /// </summary>
        [CapSubscribe(Hotline.Share.Mq.EventNames.SharingOrderScreen)]
        public async Task RecOrderScreenResultAsync(ProvinceSendScreenResultDto dto, CancellationToken cancellationToken)
        {
            var order = await _orderRepository.Queryable()
                .Where(x => x.ProvinceNo == dto.ProvinceScreenResult!.CaseSerial)
                .FirstAsync(cancellationToken);
            var orderScreen = await _orderScreenRepository.Queryable()
                .Where(x => x.OrderId == order.Id && x.Status == Share.Enums.Order.EScreenStatus.Approval)
                .FirstAsync(cancellationToken);

            var current = SessionContextCreator.CreateSessionContext(dto.Source);
            await _workflowApplication.HandleToEndAsync(current,
                orderScreen.WorkflowId, "省上推送甄别结果", null,
                dto.ProvinceScreenResult.AuditResult
                    ? Share.Enums.FlowEngine.EReviewResult.Approval
                    : Share.Enums.FlowEngine.EReviewResult.Failed, cancellationToken);
            orderScreen.Status = dto.ProvinceScreenResult.AuditResult ? Share.Enums.Order.EScreenStatus.End : Share.Enums.Order.EScreenStatus.Refuse;
            if (orderScreen.Status == Share.Enums.Order.EScreenStatus.End)
            {
                var visitDetail = await _orderVisitedDetailRepository.GetAsync(orderScreen.VisitDetailId, cancellationToken);
                if (visitDetail != null)
                {
                    var screenSatisfy = new Kv() { Key = "-1", Value = "视为满意" };
                    visitDetail.OrgProcessingResults = screenSatisfy;
                    visitDetail.OrgHandledAttitude = screenSatisfy;
                    await _orderVisitedDetailRepository.UpdateAsync(visitDetail, cancellationToken);
                }
            }
            orderScreen.ReplyContent = dto.ProvinceScreenResult.AuditOpinion;
            if (dto.Files.Any())
                orderScreen.FileJson =
                    await _fileRepository.AddFileAsync(dto.Files, orderScreen.Id, "", cancellationToken);
            await _orderScreenRepository.UpdateAsync(orderScreen, cancellationToken);
        }

        /// <summary>
        /// 更新工单受理附件
        /// </summary>
        [CapSubscribe(Hotline.Share.Mq.EventNames.SharingOrderUpdataFiles)]
        public async Task RecOrderUpdateFilesAsync(OrderUpdataFiles dto, CancellationToken cancellationToken)
        {
            if (dto == null && dto.Files.Any())
            {
                var order = await _orderRepository.GetAsync(dto.OrderId, cancellationToken);
                order.FileJson = await _fileRepository.AddFileAsync(dto.Files, dto.OrderId, "", cancellationToken);
            }
        }

        /// <summary>
        /// 省下行回访
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.SharingOrderEvlResult)]
        public async Task OrderVisitProvince(ProvinceOrderVisitDto dto, CancellationToken cancellationToken)
        {
            var orderVisit = await _orderVisitRepository.Queryable()
                .Includes(x => x.Order)
                .Includes(x => x.OrderVisitDetails)
                .Where(x => x.Order.ProvinceNo == dto.ProvinceNo &&
             x.VisitState != Share.Enums.Order.EVisitState.None).FirstAsync(cancellationToken);

            if (orderVisit != null)
            {
                //处理评价结果
                var processingResult = dto.OrgProcessingResults;
                Kv orgProcessingResults = null;
                if (!string.IsNullOrEmpty(processingResult))
                {
                    var dicData = await _systemDicDataRepository.GetAsync(x => x.DicTypeCode == SysDicTypeConsts.VisitSatisfaction &&
                                                                               x.DicDataValue == processingResult, cancellationToken);
                    if (dicData != null)
                    {
                        orgProcessingResults = new Kv();
                        orgProcessingResults.Key = dicData.DicDataValue;
                        orgProcessingResults.Value = dicData.DicDataName;
                    }
                    if (orgProcessingResults != null)
                    {
                        //主表
                        orderVisit.VisitState = Share.Enums.Order.EVisitState.Visited;
                        orderVisit.VisitTime = dto.VisitTime;
                        orderVisit.VisitType = dto.VisitType;
                        orderVisit.IsCanHandle = orgProcessingResults.Key == "2";
                        orderVisit.IsCanAiVisit = false;
                        orderVisit.NowEvaluate = orgProcessingResults;
                        await _orderVisitRepository.UpdateAsync(orderVisit, cancellationToken);
                        //子表
                        for (int i = 0; i < orderVisit.OrderVisitDetails.Count; i++)
                        {
                            if (orderVisit.OrderVisitDetails[i].VisitTarget == EVisitTarget.Seat)
                            {
                                orderVisit.OrderVisitDetails[i].VoiceEvaluate = (EVoiceEvaluate)int.Parse(orgProcessingResults.Key);
                                orderVisit.OrderVisitDetails[i].SeatEvaluate = (ESeatEvaluate)int.Parse(orgProcessingResults.Key);
                            }
                            else
                            {
                                orderVisit.OrderVisitDetails[i].OrgProcessingResults = orgProcessingResults;
                            }
                            orderVisit.OrderVisitDetails[i].VisitContent = dto.VisitContent;
                        }
                        await _orderVisitedDetailRepository.UpdateRangeAsync(orderVisit.OrderVisitDetails, cancellationToken);
                        //工单
                        orderVisit.Order.Visited(orgProcessingResults.Key, orgProcessingResults.Value);
                        await _orderRepository.UpdateAsync(orderVisit.Order);

                        ////处理网站通知差评数据
                        //if (orderVisit.Order.Source == ESource.Hotline && orderVisit.OrderVisitDetails.Any(x => x.OrgHandledAttitude?.Key == "1" || x.OrgHandledAttitude?.Key == "2" || x.OrgProcessingResults?.Key == "1" || x.OrgProcessingResults?.Key == "2"))
                        //{
                        //    //包含不满意数据，重新生成新的回访
                        //    var newOrderVisit = _mapper.Map<OrderVisit>(orderVisit);
                        //    newOrderVisit.InitId();
                        //    newOrderVisit.VisitState = EVisitState.NoSatisfiedWaitForVisit;
                        //    newOrderVisit.VisitTime = null;
                        //    newOrderVisit.IsCanHandle = false;
                        //    newOrderVisit.IsCanAiVisit = false;
                        //    newOrderVisit.AiVisitCount = 0;
                        //    await _orderVisitRepository.AddAsync(newOrderVisit, cancellationToken);
                        //    var list = _mapper.Map<List<OrderVisitDetail>>(orderVisit.OrderVisitDetails);
                        //    list.ForEach(x =>
                        //    {
                        //        x.VisitId = newOrderVisit.Id;
                        //        x.VoiceEvaluate = null;
                        //        x.VoiceEvaluate = null;
                        //        x.OrgHandledAttitude = null;
                        //        x.OrgNoSatisfiedReason = null;
                        //        x.OrgProcessingResults = null;
                        //        x.VisitContent = "";
                        //    });
                        //    await _orderVisitedDetailRepository.AddRangeAsync(list, cancellationToken);
                        //}
                    }
                }
            }
        }

        /// <summary>
        /// 工单回访
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.SharingOrderVisitAllOther)]
        public async Task OrderVisitWeb(OrderVisitWebDto dto, CancellationToken cancellationToken)
        {
            var visit = await _orderVisitRepository.Queryable()
                .Includes(x => x.Order)
                .Includes(x => x.OrderVisitDetails)
                .FirstAsync(x => x.Id == dto.Id);
            if (visit != null)
            {
                var first = dto.OrderVisitDetailDto.FirstOrDefault(x => x.VisitTarget == EVisitTarget.Org);

                if (first != null)
                {
                    visit.NowEvaluate = first.OrgProcessingResults;
                    visit.Order.Visited(first.OrgProcessingResults.Key, first.OrgProcessingResults.Value);
                }
                visit.VisitState = EVisitState.Visited;
                visit.VisitTime = dto.VisitTime;
                visit.VisitType = dto.VisitType;

                for (int i = 0; i < visit.OrderVisitDetails.Count; i++)
                {
                    var detail = visit.OrderVisitDetails[i];
                    var detaildto = dto.OrderVisitDetailDto.FirstOrDefault(x => x.Id == detail.Id);
                    if (detaildto != null)
                    {
                        _mapper.Map(detaildto, visit.OrderVisitDetails[i]);
                    }
                }

                await _orderVisitRepository.UpdateAsync(visit, cancellationToken);
                await _orderVisitDetailRepository.UpdateRangeAsync(visit.OrderVisitDetails, cancellationToken);
                await _orderRepository.UpdateAsync(visit.Order, cancellationToken);
                var orderDto = _mapper.Map<OrderDto>(visit.Order);
                if (first != null)
                {
                    //推省上
                    await _capPublisher.PublishAsync(Hotline.Share.Mq.EventNames.HotlineOrderVisited,
                            new PublishVisitDto()
                            {
                                Order = orderDto,
                                No = visit.No,
                                VisitType = visit.VisitType,
                                VisitName = visit.CreatorName,
                                VisitTime = visit.VisitTime,
                                VisitRemark = string.IsNullOrEmpty(first.VisitContent) ? first.OrgProcessingResults?.Value : first.VisitContent,
                                AreaCode = visit.Order.AreaCode!,
                                SubjectResultSatifyCode = first.OrgProcessingResults.Key,
                                FirstSatisfactionCode = visit.Order.FirstVisitResultCode!,
                                ClientGuid = ""
                            }, cancellationToken: cancellationToken);
                }
                //处理网站通知差评数据
                //if (visit.Order.Source == ESource.Hotline && visit.OrderVisitDetails.Any(x => x.OrgHandledAttitude?.Key == "1" || x.OrgHandledAttitude?.Key == "2" || x.OrgProcessingResults?.Key == "1" || x.OrgProcessingResults?.Key == "2"))
                //{
                //    //处理老数据
                //    visit.VisitState = EVisitState.None;
                //    await _orderVisitRepository.UpdateAsync(visit, cancellationToken);
                //    //推送老数据变更给门户
                //    await _capPublisher.PublishAsync(Hotline.Share.Mq.EventNames.HotlineOrderVisitedWeb, new PublishVisitAllDto()
                //    {
                //        Id = visit.Id,
                //        Order = orderDto,
                //        OrderVisitDetails = _mapper.Map<List<VisitDetailDto>>(visit.OrderVisitDetails),
                //        VisitTime = visit.VisitTime,
                //        VisitType = visit.VisitType,
                //        VisitState = visit.VisitState,
                //        PublishTime = visit.PublishTime,
                //    }, cancellationToken: cancellationToken);

                //    //包含不满意数据，重新生成新的回访
                //    var newOrderVisit = _mapper.Map<OrderVisit>(visit);
                //    newOrderVisit.InitId();
                //    newOrderVisit.VisitState = EVisitState.NoSatisfiedWaitForVisit;
                //    newOrderVisit.VisitTime = null;
                //    newOrderVisit.IsCanHandle = false;
                //    newOrderVisit.IsCanAiVisit = false;
                //    newOrderVisit.AiVisitCount = 0;
                //    await _orderVisitRepository.AddAsync(newOrderVisit, cancellationToken);
                //    var list = _mapper.Map<List<OrderVisitDetail>>(visit.OrderVisitDetails);
                //    list.ForEach(x =>
                //    {
                //        x.VisitId = newOrderVisit.Id;
                //        x.VoiceEvaluate = null;
                //        x.VoiceEvaluate = null;
                //        x.OrgHandledAttitude = null;
                //        x.OrgNoSatisfiedReason = null;
                //        x.OrgProcessingResults = null;
                //        x.VisitContent = "";
                //    });
                //    await _orderVisitDetailRepository.AddRangeAsync(list, cancellationToken);
                //    //推送新数据给门户
                //    await _capPublisher.PublishAsync(Hotline.Share.Mq.EventNames.HotlineOrderVisitedWeb, new PublishVisitAllDto()
                //    {
                //        Id = newOrderVisit.Id,
                //        Order = orderDto,
                //        OrderVisitDetails = _mapper.Map<List<VisitDetailDto>>(list),
                //        VisitTime = newOrderVisit.VisitTime,
                //        VisitType = newOrderVisit.VisitType,
                //        VisitState = newOrderVisit.VisitState,
                //        PublishTime = newOrderVisit.PublishTime,
                //    }, cancellationToken: cancellationToken);
                //}
                //else
                //{
                //写入质检
                await _qualityApplication.AddQualityAsync(EQualitySource.Visit, orderDto.Id, visit.Id,
                    cancellationToken);
                //}
            }
        }

        /// <summary>
        /// 订阅省工单延期消息
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        [CapSubscribe(Hotline.Share.Mq.EventNames.SharingOrderDelayResult)]
        public async Task OrderDelayWeb(ProvinceSendDelayResultDto dto, CancellationToken cancellationToken)
        {
            var order = await _orderRepository.GetAsync(x => x.ProvinceNo == dto.No, cancellationToken);
            if (order != null)
            {
                //查询延期
                var orderDelay = await _orderDelayRepository.GetAsync(x => x.OrderId == order.Id && x.DelayState == EDelayState.Examining, cancellationToken);
                var current = SessionContextCreator.CreateSessionContext(dto.Source);
                await _workflowApplication.HandleToEndAsync(current, orderDelay.WorkflowId, dto.Opinion, dto.Files,
                    dto.IsPass ? EReviewResult.Approval : EReviewResult.Failed, cancellationToken);

                //await _workflowApplication.JumpToEndAsync(current, orderDelay.WorkflowId, dto.Opinion, dto.Files,
                //    dto.IsPass ? EReviewResult.Approval : EReviewResult.Failed, cancellationToken);
            }
        }

        /// <summary>
        /// 接收工单处理结果
        /// </summary>
        [CapSubscribe(EventNames.SharingOrderReultSend)]
        public async Task RecOrderResultAsync(OrderResultDto dto, CancellationToken cancellationToken)
        {
            var order = await _orderRepository.GetAsync(dto.OrderId, cancellationToken);
            if (order is null)
                throw new UserFriendlyException($"无效工单编号, orderId: {dto.OrderId}");
            if (string.IsNullOrEmpty(order.WorkflowId))
                throw new UserFriendlyException($"该工单未开启流程，orderId: {dto.OrderId}");

            //if (dto.Files != null && dto.Files.Any())
            //{
            //    order.FileJson = await _fileRepository.AddFileAsync(dto.Files, order.Id, order.WorkflowId,
            //        cancellationToken);
            //    await _orderRepository.FileAsync(order, cancellationToken);
            //}

            var current = SessionContextCreator.CreateSessionContext(dto.Source);
            switch (dto.FinishType)
            {
                case "0":
                    //退回:撤回至发起人
                    await _workflowDomainService.RecallToStartStepAsync(order.WorkflowId, dto.Opinion, current, cancellationToken);
                    break;
                case "1":
                    //办结:归档
                    await _workflowApplication.HandleToEndAsync(current, order.WorkflowId, dto.Opinion, dto.Files,
                        cancellationToken: cancellationToken);
                    break;
            }
        }

        /// <summary>
        /// 接收工单扩展信息
        /// </summary>
        [CapSubscribe(EventNames.SharingOrderExtends)]
        public async Task RecOrderExtensionAsync(OrderExtensionDto dto, CancellationToken cancellationToken)
        {
            var order = await _orderRepository.Queryable()
                .FirstAsync(d => d.ProvinceNo == dto.ProvinceNo, cancellationToken);

            var orderExtension = await _orderDomainService.GetOrderExtensionsAsync(dto.ProvinceNo, cancellationToken);
            if (orderExtension is null)
            {
                orderExtension = _mapper.Map<OrderExtension>(dto);
                if (order != null)
                    orderExtension.Id = order.Id;
                await _orderExtensionRepository.AddAsync(orderExtension, cancellationToken);
            }
            else
            {
                _mapper.Map(dto, orderExtension);
                if (order != null)
                    orderExtension.Id = order.Id;
                await _orderExtensionRepository.UpdateAsync(orderExtension, cancellationToken);
            }
        }

        /// <summary>
        /// 接收工单办理流程
        /// </summary>
        [CapSubscribe(EventNames.SharingOrderAddTraces)]
        public async Task RecOrderTracesAsync(AddOrderTracesDto dto, CancellationToken cancellationToken)
        {
            var order = await _orderRepository.GetAsync(dto.OrderId, cancellationToken);
            if (order is null)
                throw new UserFriendlyException($"未查询到对应工单，orderId: {dto.OrderId}");
            if (string.IsNullOrEmpty(order.WorkflowId))
                throw new UserFriendlyException($"该工单未开启流程，orderId: {dto.OrderId}");

            var traces = dto.Traces.Select(d =>
            {
                var trace = _mapper.Map<WorkflowTrace>(d);
                trace.WorkflowId = order.WorkflowId;
                return trace;
            }).ToList();

            await _workflowDomainService.AddTracesAsync(order.WorkflowId, traces, cancellationToken);
        }

        /// <summary>
        /// 接收工单补充内容
        /// </summary>
        [CapSubscribe(EventNames.SharingOrderSupplements)]
        public async Task RecOrderSupplementsAsync(AddOrderComplementDto dto, CancellationToken cancellationToken)
        {
            await _orderDomainService.AddOrderComplementAsync(dto, cancellationToken);
        }

        /// <summary>
        /// 接收市州互转返回数据
        /// </summary>
        [CapSubscribe(EventNames.SharingOrderTranspondCity)]
        public async Task RecTranspondCityRawDataAsync(TranspondCityRawDataDto dto, CancellationToken cancellationToken)
        {
            var data = await _transpondCityRawDataRepository.GetAsync(p => p.OrderCode == dto.OrderCode && p.Direction == ETranspondDirection.Out, cancellationToken);
            if (data != null)
            {
                data.IsSuccess = dto.IsSuccess;
                data.SendTimes = dto.SendTimes;
                data.Result = dto.Result;
                await _transpondCityRawDataRepository.UpdateAsync(data, cancellationToken);
            }
        }

        /// <summary>
        /// 接收市州互转接收原始数据
        /// </summary>
        [CapSubscribe(EventNames.SharingOrderReceiveTranspondCity)]
        public async Task RecTranspondCityReceiveRawDataAsync(TranspondCityRawDataDto dto, CancellationToken cancellationToken)
        {
            await _transpondCityRawDataRepository.AddAsync(_mapper.Map<TranspondCityRawData>(dto), cancellationToken);
        }
    }
}