hotline/src/Hotline.Api/Controllers/OrderController.cs

using DotNetCore.CAP;
using Hotline.Application.FlowEngine;
using Hotline.Caching.Interfaces;
using Hotline.File;
using Hotline.FlowEngine.Definitions;
using Hotline.FlowEngine.Workflows;
using Hotline.Orders;
using Hotline.Orders.Notifications;
using Hotline.Permissions;
using Hotline.Quality;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Repository.SqlSugar.Ts;
using Hotline.Settings;
using Hotline.Settings.Hotspots;
using Hotline.Settings.TimeLimits;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.FlowEngine;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Dtos.Settings;
using Hotline.Share.Enums.Order;
using Hotline.Share.Enums.Quality;
using Hotline.Share.Enums.Settings;
using Hotline.Share.Mq;
using Hotline.Share.Requests;
using MapsterMapper;
using MediatR;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using Hotline.FlowEngine.WorkflowModules;
using XF.Domain.Authentications;
using XF.Domain.Constants;
using XF.Domain.Exceptions;
using XF.Domain.Repository;
using XF.Utility.EnumExtensions;
using Microsoft.IdentityModel.Tokens;

namespace Hotline.Api.Controllers;

/// <summary>
/// 工单
/// </summary>
public class OrderController : BaseController
{
    private readonly IOrderDomainService _orderDomainService;
    private readonly IOrderRepository _orderRepository;
    private readonly IWorkflowApplication _workflowApplication;
    private readonly IWorkflowDomainService _workflowDomainService;
    private readonly IRepository<Hotspot> _hotspotTypeRepository;
    private readonly ISystemOrganizeRepository _organizeRepository;
    private readonly IDefinitionDomainService _definitionDomainService;
    private readonly ISystemDicDataCacheManager _sysDicDataCacheManager;
    private readonly ISessionContext _sessionContext;
    private readonly IMapper _mapper;
    private readonly IMediator _mediator;
    private readonly IRepository<OrderPublish> _orderPublishRepository;
    private readonly IRepository<OrderVisit> _orderVisitRepository;
    private readonly IRepository<OrderVisitDetail> _orderVisitedDetailRepository;
    private readonly ICapPublisher _capPublisher;
    private readonly IRepository<OrderDelay> _orderDelayRepository;
    private readonly ITimeLimitDomainService _timeLimitDomainService;
    private readonly ISystemSettingCacheManager _systemSettingCacheManager;
    private readonly IRepository<OrderRedo> _orderRedoRepository;
    private readonly IRepository<OrderSupervise> _orderSuperviseRepository;
    private readonly IRepository<OrderUrge> _orderUrgeRepository;
    private readonly IFileRepository _fileRepository;
    private readonly IRepository<OrderScreen> _orderScreenRepository;
    private readonly IRepository<OrderPublishHistory> _orderPublishHistoryRepository;
    private readonly IRepositoryTextSearch<OrderTs> _repositoryts;
    private readonly IQualityRepository _qualityRepository;
    private readonly IRepository<Workflow> _workflowRepository;
    private readonly ICitizenRepository _citizenRepository;
    private readonly IRepository<CitizenLabelDetail> _labelDetailRepository;
    private readonly IRepository<RepeatableEvent> _repeatableEventRepository;
    private readonly IRepeatableEventDetailRepository _repeatableEventDetailRepository;
    private readonly IRepository<OrderWord> _orderWrodRepository;
    private readonly IRepository<OrderObserve> _orderObserveRepository;


	public OrderController(
        IOrderDomainService orderDomainService,
        IOrderRepository orderRepository,
        IWorkflowApplication workflowApplication,
        IWorkflowDomainService workflowDomainService,
        IRepository<Hotspot> hotspotTypeRepository,
        ISystemOrganizeRepository organizeRepository,
        IDefinitionDomainService definitionDomainService,
        ISystemDicDataCacheManager sysDicDataCacheManager,
        ISessionContext sessionContext,
        IMapper mapper,
        IMediator mediator,
        IRepository<OrderPublish> orderPublishRepository,
        IRepository<OrderVisit> orderVisitRepository,
        IRepository<OrderVisitDetail> orderVisitedDetailRepository,
        ICapPublisher capPublisher,
        IRepository<OrderDelay> orderDelayRepository,
        ITimeLimitDomainService timeLimitDomainService,
        ISystemSettingCacheManager systemSettingCacheManager,
        IRepository<OrderRedo> orderRedoRepository,
        IRepository<OrderSupervise> orderSuperviseRepository,
        IRepository<OrderUrge> orderUrgeRepository,
        IFileRepository fileRepository,
        IRepository<OrderScreen> orderScreenRepository,
        IRepository<OrderPublishHistory> orderPublishHistoryRepository,
        IRepositoryTextSearch<OrderTs> repositoryts,
        IQualityRepository qualityRepository,
        IRepository<Workflow> workflowRepository,
        ICitizenRepository citizenRepository,
        IRepository<CitizenLabelDetail> labelDetailRepository,
        IRepository<RepeatableEvent> repeatableEventRepository,
        IRepeatableEventDetailRepository repeatableEventDetailRepository,
        IRepository<OrderWord> orderWrodRepository,
        IRepository<OrderObserve> orderObserveRepository
		)
    {
        _orderDomainService = orderDomainService;
        _orderRepository = orderRepository;
        _workflowApplication = workflowApplication;
        _workflowDomainService = workflowDomainService;
        _hotspotTypeRepository = hotspotTypeRepository;
        _organizeRepository = organizeRepository;
        _definitionDomainService = definitionDomainService;
        _sysDicDataCacheManager = sysDicDataCacheManager;
        _sessionContext = sessionContext;
        _mapper = mapper;
        _mediator = mediator;
        _orderPublishRepository = orderPublishRepository;
        _orderVisitRepository = orderVisitRepository;
        _orderVisitedDetailRepository = orderVisitedDetailRepository;
        _capPublisher = capPublisher;
        _orderDelayRepository = orderDelayRepository;
        _timeLimitDomainService = timeLimitDomainService;
        _systemSettingCacheManager = systemSettingCacheManager;
        _orderRedoRepository = orderRedoRepository;
        _orderSuperviseRepository = orderSuperviseRepository;
        _orderUrgeRepository = orderUrgeRepository;
        _fileRepository = fileRepository;
        _orderScreenRepository = orderScreenRepository;
        _orderPublishHistoryRepository = orderPublishHistoryRepository;
        _repositoryts = repositoryts;
        _qualityRepository = qualityRepository;
        _workflowRepository = workflowRepository;
        _citizenRepository = citizenRepository;
        _labelDetailRepository = labelDetailRepository;
        _repeatableEventRepository = repeatableEventRepository;
        _repeatableEventDetailRepository = repeatableEventDetailRepository;
        _orderWrodRepository = orderWrodRepository;
        _orderObserveRepository = orderObserveRepository;

	}

    #region 工单发布

    /// <summary>
    /// 查询（工单发布）
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.PublishOrderList)]
    [HttpGet("publish")]
    public async Task<PagedDto<PublishDto>> PublishOrderList([FromQuery] QueryOrderPublishDto dto)
    {
        var (total, items) = await _orderRepository.Queryable()
            .Includes(d => d.OrderPublish)
            .Where(x => x.Status == EOrderStatus.Filed)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword),
                d => d.Title.Contains(dto.Keyword!) || d.No.Contains(dto.Keyword!))
            .WhereIF(dto.PubState == EPubState.Pub, d => d.Status >= EOrderStatus.Published)
            .WhereIF(dto.PubState == EPubState.NoPub, d => d.Status < EOrderStatus.Published)
            .WhereIF(!string.IsNullOrEmpty(dto.PubMan),
                d => d.Acceptor.Name.Contains(dto.PubMan!) || d.Acceptor.StaffNo.Contains(dto.PubMan!))
            .WhereIF(dto.PubRange == EPublicState.Pub, d => d.OrderPublish.PublishState)
            .WhereIF(dto.PubRange == EPublicState.NoPub, d => !d.OrderPublish.PublishState)
            .WhereIF(dto.AcceptTypes.Any(), d => dto.AcceptTypes.Contains(d.AcceptType))
            .WhereIF(dto.HotspotIds.Any(), d => dto.HotspotIds.Contains(d.HotspotId))
            .WhereIF(dto.CreationTimeStart.HasValue, d => d.CreationTime >= dto.CreationTimeStart)
            .WhereIF(dto.CreationTimeEnd.HasValue, d => d.CreationTime <= dto.CreationTimeEnd)
            .WhereIF(dto.FiledTimeStart.HasValue, d => d.OrderPublish.CreationTime >= dto.CreationTimeStart)
            .WhereIF(dto.FiledTimeEnd.HasValue, d => d.OrderPublish.CreationTime <= dto.CreationTimeEnd)
            .OrderBy(d => d.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);

        return new PagedDto<PublishDto>(total, _mapper.Map<IReadOnlyList<PublishDto>>(items));
    }

    /// <summary>
    /// 发布工单
    /// </summary>
    /// <returns></returns>
    [Permission(EPermission.PublishOrder)]
    [HttpPost("publish")]
    public async Task PublishOrder([FromBody] PublishOrderDto dto)
    {
        //验证订单
        var order = await _orderRepository.GetAsync(dto.Id, HttpContext.RequestAborted);

        if (order is null)
            throw UserFriendlyException.SameMessage("未找到工单，无法发布");

        //新增发布工单
        OrderPublish orderPublish = new OrderPublish();
        orderPublish.OrderId = order.Id;
        orderPublish.No = order.No;
        orderPublish.PublishState = dto.PublishState;
        orderPublish.ArrangeTitle = dto.ArrangeTitle;
        orderPublish.ArrangeContent = dto.ArrangeContent;
        orderPublish.ArrangeOpinion = dto.ArrangeOpinion;
        orderPublish.ProPublishState = dto.ProPublishState;
        orderPublish.FeedBackPhone = dto.FeedBackPhone;
        orderPublish.NoPubReason = dto.NoPubReason;
        orderPublish.CreatorName = _sessionContext.UserName;
        string id = await _orderPublishRepository.AddAsync(orderPublish);
        order.Publish(orderPublish.PublishState);
        await _orderRepository.UpdateAsync(order);

        var orderVisit = new OrderVisit();
        orderVisit.No = order.No;
        orderVisit.OrderId = order.Id;
        orderVisit.VisitState = EVisitState.WaitForVisit;
        orderVisit.PublishTime = DateTime.Now;
        string visitId = await _orderVisitRepository.AddAsync(orderVisit);

        //新增回访信息
        var visitedDetail = new List<OrderVisitDetail>();

        var seatDetail = new OrderVisitDetail();
        seatDetail.VisitId = visitId;
        seatDetail.VisitTarget = EVisitTarget.Seat;

        visitedDetail.Add(seatDetail);

        foreach (var item in dto.IdNames)
        {
            var orgDetail = new OrderVisitDetail();
            orgDetail.VisitId = visitId;
            orgDetail.VisitOrgCode = item.Key;
            orgDetail.VisitOrgName = item.Value;
            orgDetail.VisitTarget = EVisitTarget.Org;
            visitedDetail.Add(orgDetail);
        }

        await _mediator.Publish(new AddVisitNotify(visitedDetail), HttpContext.RequestAborted);

        //TODO 中国政府网
        if (order.SourceChannelCode == "ZGZFW")
        {
        }

        //TODO 省政民互动
        if (order.SourceChannelCode == "ZMHD")
        {
        }
    }

    /// <summary>
    /// 发布页面基础信息
    /// </summary>
    /// <returns></returns>
    [Permission(EPermission.PublishOrderPageBase)]
    [HttpGet("publish-order-pagebase/{id}")]
    public async Task<PublishOrderPageBaseDto> PublishOrderPageBase(string id)
    {
        var order = await _orderRepository.Queryable()
            .Includes(d => d.Acceptor)
            .Includes(d => d.OrderComplain)
            .FirstAsync(d => d.Id == id);

        if (order is null)
            throw UserFriendlyException.SameMessage("未知工单，无法发布");

        var res = new PublishOrderPageBaseDto()
        {
            SourceChannel = order.SourceChannel,
            OrderTitle = order.Title,
            Content = order.Content,
            ActualOpinion = order.ActualOpinion
        };
        var (idName, idNames) =
            await _workflowDomainService.GetUnvisitOrgsAsync(order.WorkflowId, HttpContext.RequestAborted);
        res.ActualHandleOrgName = idName;
        res.idNames = idNames.ToList();
        return res;
    }


    /// <summary>
    /// 已发布列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.PublishedOrderList)]
    [HttpGet("published")]
    public async Task<PagedDto<PublishedDto>> PublishedOrderList([FromQuery] PagedKeywordRequest dto)
    {
        var (total, items) = await _orderPublishRepository.Queryable()
            .Includes(x => x.Order)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword),
                d => d.Order.Title.Contains(dto.Keyword!) || d.Order.No.Contains(dto.Keyword!))
            .OrderBy(d => d.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);

        return new PagedDto<PublishedDto>(total, _mapper.Map<IReadOnlyList<PublishedDto>>(items));
    }

    /// <summary>
    /// 发布详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.PublishedOrder)]
    [HttpGet("published-order/{id}")]
    public async Task<PublishedEntityDto> PublishedOrder(string id)
    {
        var publishedOrder = await _orderPublishRepository.GetAsync(id, HttpContext.RequestAborted);

        if (publishedOrder is null)
        {
            throw UserFriendlyException.SameMessage("未知数据!");
        }

        var pubentity = _mapper.Map<PublishedEntityDto>(publishedOrder);
        var visit = await _orderVisitRepository.Queryable().Includes(x => x.OrderVisitDetails)
            .OrderByDescending(x => x.CreationTime)
            .FirstAsync(x => x.OrderId == publishedOrder.OrderId, HttpContext.RequestAborted);
        if (visit != null)
        {
            var details = visit.OrderVisitDetails.Where(x => x.VisitTarget == EVisitTarget.Org).ToList();
            if (details != null && details.Count > 0)
            {
                pubentity.IdNames = new List<Kv>();
                details.ForEach(f => pubentity.IdNames.Add(new Kv() { Key = f.VisitOrgCode, Value = f.VisitOrgName }));
            }
        }

        return pubentity;
    }

    /// <summary>
    /// 修改发布内容
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.PublishedModify)]
    [HttpPost("published-order-modify")]
    public async Task PublishedModify([FromBody] PublishOrderModifyDto dto)
    {
        var publishOrder = await _orderPublishRepository.GetAsync(dto.Id, HttpContext.RequestAborted);

        if (publishOrder is null)
        {
            throw UserFriendlyException.SameMessage("无效数据");
        }

        var history = new OrderPublishHistory();
        history.ArrangeTitleBefor = publishOrder.ArrangeTitle;
        history.ArrangeTitleAfter = dto.ArrangeTitle;
        history.ArrangeContentBefor = publishOrder.ArrangeContent;
        history.ArrangeContentAfter = dto.ArrangeContent;
        history.ArrangeOpinionBefor = publishOrder.ArrangeOpinion;
        history.ArrangeOpinionAfter = dto.ArrangeOpinion;
        history.No = publishOrder.No;
        history.OrderId = publishOrder.OrderId;
        history.OrderPublishId = publishOrder.Id;


        publishOrder.ArrangeTitle = dto.ArrangeTitle;
        publishOrder.ArrangeContent = dto.ArrangeContent;
        publishOrder.ArrangeOpinion = dto.ArrangeOpinion;

        await _orderPublishRepository.UpdateAsync(publishOrder, HttpContext.RequestAborted);
        await _orderPublishHistoryRepository.AddAsync(history, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 发布修改记录
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.QueryPublishedHistory)]
    [HttpGet("published-history-list/{id}")]
    public async Task<List<OrderPublishHistory>> QueryPublishedHistory(string id)
    {
        return await _orderPublishHistoryRepository.Queryable().Where(x => x.OrderPublishId == id)
            .OrderByDescending(x => x.CreationTime).ToListAsync(HttpContext.RequestAborted);
    }

    #endregion

    #region 工单回访

    /// <summary>
    /// 回访列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.QueryOrderVisitList)]
    [HttpGet("visit")]
    public async Task<PagedDto<OrderVisitDto>> QueryOrderVisitList([FromQuery] QueryOrderVisitDto dto)
    {
        var (total, items) = await _orderVisitRepository.Queryable()
            .Includes(x => x.Order)
            .Includes(x => x.Employee)
            .Includes(x => x.OrderVisitDetails)
            .WhereIF(dto.VisitState == EVisitStateQuery.NoVisit,
                x => x.VisitState == Share.Enums.Order.EVisitState.WaitForVisit ||
                     x.VisitState == Share.Enums.Order.EVisitState.NoSatisfiedWaitForVisit)
            .WhereIF(dto.VisitState == EVisitStateQuery.Visited,
                x => x.VisitState == Share.Enums.Order.EVisitState.Visited)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword),
                d => d.Order.Title.Contains(dto.Keyword!) || d.Order.No.Contains(dto.Keyword!))
            .OrderBy(x => x.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
        return new PagedDto<OrderVisitDto>(total, _mapper.Map<IReadOnlyList<OrderVisitDto>>(items));
    }

    /// <summary>
    /// 回访详情
    /// </summary>
    /// <returns></returns>
    [Permission(EPermission.VisitInfo)]
    [HttpGet("visit/{id}")]
    public async Task<object> VisitInfo(string id)
    {
        var orderVisit = await _orderVisitRepository.Queryable()
            .Includes(x => x.Order)
            .Includes(x => x.Employee)
            .Includes(x => x.OrderVisitDetails)
            .FirstAsync(x => x.Id == id, HttpContext.RequestAborted);

        if (orderVisit is null)
        {
            throw UserFriendlyException.SameMessage("未知工单回访");
        }

        int visitCount = await _orderVisitRepository.CountAsync(
            x => x.OrderId == orderVisit.OrderId && x.VisitState == Share.Enums.Order.EVisitState.Visited,
            HttpContext.RequestAborted);
        int againCount = await _orderVisitRepository.CountAsync(
            x => x.OrderId == orderVisit.OrderId && x.AgainState == EAgainState.DoAgain, HttpContext.RequestAborted);
        var voiceEvaluate = EnumExts.GetDescriptions<EVoiceEvaluate>();
        var seatEvaluate = EnumExts.GetDescriptions<ESeatEvaluate>();
        var visitSatisfaction = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.VisitSatisfaction);
        var dissatisfiedReason = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.DissatisfiedReason);
        var visitManner = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.VisitManner);

        return new
        {
            OrderVisitModel = orderVisit,
            VisitCount = visitCount,
            AgainCount = againCount,
            VisitSatisfaction = visitSatisfaction,
            DissatisfiedReason = dissatisfiedReason,
            VisitManner = visitManner,
            ViceEvaluate = voiceEvaluate,
            SeatEvaluate = seatEvaluate
        };
    }

    /// <summary>
    /// 回访明细
    /// </summary>
    /// <returns></returns>
    [Permission(EPermission.VisitDetailList)]
    [HttpGet("visit/detail")]
    public async Task<PagedDto<OrderVisitDetailDto>> VisitDetailList([FromQuery] VisitDetailListDto dto)
    {
        var (total, items) = await _orderVisitedDetailRepository.Queryable()
            .Includes(x => x.OrderVisit, s => s.Order)
            .WhereIF(dto.VisitState == EVisitStateQuery.NoVisit,
                x => x.OrderVisit.VisitState == Share.Enums.Order.EVisitState.WaitForVisit || x.OrderVisit.VisitState ==
                    Share.Enums.Order.EVisitState.NoSatisfiedWaitForVisit)
            .WhereIF(dto.VisitState == EVisitStateQuery.Visited,
                x => x.OrderVisit.VisitState == Share.Enums.Order.EVisitState.Visited)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword),
                d => d.OrderVisit.Order.Title.Contains(dto.Keyword!) || d.OrderVisit.Order.No.Contains(dto.Keyword!))
            .OrderByDescending(x => x.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);

        return new PagedDto<OrderVisitDetailDto>(total, _mapper.Map<IReadOnlyList<OrderVisitDetailDto>>(items));
    }


    /// <summary>
    /// 回访保存
    /// </summary>
    /// <returns></returns>
    [Permission(EPermission.Visit)]
    [HttpPost("visit")]
    public async Task Visit([FromBody] VisitDto dto)
    {
        //var visit = await _orderVisitRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
        var visit = await _orderVisitRepository.Queryable()
            .Includes(d => d.Order)
            .Includes(d => d.OrderVisitDetails)
            .FirstAsync(d => d.Id == dto.Id, HttpContext.RequestAborted);
        if (visit is null)
            throw UserFriendlyException.SameMessage("未知回访信息");

        if (visit.VisitState == EVisitState.Visited)
            throw UserFriendlyException.SameMessage("已回访，不能重复回访");

        var first = dto.VisitDetails.FirstOrDefault(x => x.VisitTarget == EVisitTarget.Org);


        //更新主表
        if (dto.IsPutThrough)
        {
            visit.VisitState = Share.Enums.Order.EVisitState.Visited;
            visit.VisitTime = DateTime.Now;
            visit.VisitType = EVisitType.ArtificialVisit;
        }

        visit.IsPutThrough = dto.IsPutThrough;
        visit.AgainState = dto.IsAgain ? EAgainState.NeedAgain : EAgainState.NoAgain;
        visit.EmployeeId = _sessionContext.UserId;
        if (first != null)
        {
            visit.NowEvaluate = first.OrgProcessingResults;
        }
        //await _orderVisitRepository.UpdateAsync(visit,HttpContext.RequestAborted);

        //update order
        if (dto.IsPutThrough)
        {
            if (first != null)
            {
                visit.Order.Visited(first.OrgProcessingResults.Key, first.OrgProcessingResults.Value);
            }

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

            await _orderVisitRepository.UpdateAsync(visit, HttpContext.RequestAborted);
            await _orderVisitedDetailRepository.UpdateRangeAsync(visit.OrderVisitDetails, HttpContext.RequestAborted);
            await _orderRepository.UpdateAsync(visit.Order, HttpContext.RequestAborted);
            var orderDto = _mapper.Map<OrderDto>(visit.Order);
            if (first != null)
            {
                //推省上
                _capPublisher.Publish(EventNames.HotlineOrderVisited,
                    new PublishVisitDto()
                    {
                        Order = orderDto,
                        No = visit.No,
                        VisitType = visit.VisitType,
                        VisitName = visit.CreatorName,
                        VisitTime = visit.VisitTime,
                        VisitRemark = first.VisitContent,
                        AreaCode = visit.Order.AreaCode!,
                        SubjectResultSatifyCode = first.OrgProcessingResults.Key,
                        FirstSatisfactionCode = visit.Order.FirstVisitResultCode!,
                        ClientGuid = ""
                    });
            }
            if (first != null)
            {
                //写入质检
                await _qualityRepository.AddQualityAsync(EQualitySource.Visit, visit.Order.Id, visit.Id, HttpContext.RequestAborted);
            }
        }
    }

    /// <summary>
    /// 批量分配回访人员
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost("visit/distribution")]
    public async Task<DistributionVisitRspDto> DistributionVisit([FromBody] DistributionVisitDto dto)
    {
        int error = 0;
        foreach (var id in dto.Ids)
        {
            var visit = await _orderVisitRepository.Queryable().FirstAsync(d => d.Id == id, HttpContext.RequestAborted);
            if (visit != null && visit.VisitState != EVisitState.WaitForVisit)
            {
                visit.EmployeeId = dto.EmployeeId;
                await _orderVisitRepository.UpdateAsync(visit, HttpContext.RequestAborted);
            }
            else
            {
                error++;
            }
        }
        return new DistributionVisitRspDto() { ErrorCount = error, SuccessCount = dto.Ids.Count - error };
    }


    #endregion

    #region 工单重办

    /// <summary>
    /// 重办查询
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.QueryOrderRedoRecord)]
	[HttpGet("redo")]
	public async Task<PagedDto<OrderRedo>> QueryOrderRedo([FromQuery] QueryOrderRedoRecordDto dto)
	{
		var (total, items) = await _orderRedoRepository.Queryable()
			.Includes(x => x.Order)
			.WhereIF(!string.IsNullOrEmpty(dto.Keyword),
				d => d.Order.Title.Contains(dto.Keyword!) || d.Order.No.Contains(dto.Keyword!))
			.OrderByDescending(x => x.CreationTime)
			.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);

        return new PagedDto<OrderRedo>(total, items);
    }

    /// <summary>
    /// 重办详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.OrderRedoRecord)]
    [HttpGet("redo/{id}")]
    public async Task<OrderRedo> GetOrderRedo(string id)
    {
        return await _orderRedoRepository.Queryable()
            .Includes(x => x.Order)
            .FirstAsync(x => x.Id == id);
    }

    /// <summary>
    /// 发起重办
    /// </summary>
    [HttpPost("redo")]
    public async Task<string> AddRedo([FromBody] OrderRedoStartFlowDto dto)
    {
        var redo = _mapper.Map<OrderRedo>(dto.Data);
        redo.CreatorName = _sessionContext.UserName ?? string.Empty;
        redo.CreatorOrgName = _sessionContext.OrgName ?? string.Empty;
        //redo.TimeLimitCount = dto.Workflow.Extension.TimeLimitCount;
        //redo.TimeLimitUnit = dto.Workflow.Extension.TimeLimitUnit;
        //todo
        var handler = dto.Workflow.NextHandlers.First();
        redo.RedoOrgCode = handler.Key;
        redo.RedoOrgCode = handler.Value;

        var id = await _orderRedoRepository.AddAsync(redo, HttpContext.RequestAborted);

        try
        {
            var order = await _orderRepository.GetAsync(dto.Data.OrderId, HttpContext.RequestAborted);
            if (order == null)
                throw UserFriendlyException.SameMessage("无效工单编号");
            if (string.IsNullOrEmpty(order.WorkflowId))
                throw UserFriendlyException.SameMessage("无效工单流程编号");

            var redoFlowDto = _mapper.Map<RecallDto>(dto.Workflow);
            redoFlowDto.WorkflowId = order.WorkflowId;

            await _workflowApplication.RedoAsync(redoFlowDto, HttpContext.RequestAborted);
            return id;
        }
        catch (Exception e)
        {
            await _orderRedoRepository.RemoveAsync(id, cancellationToken: HttpContext.RequestAborted);
            throw new UserFriendlyException($"发起重办失败，{e.Message}");
        }
    }

    /// <summary>
    /// 重办基础数据
    /// </summary>
    /// <returns></returns>
    [HttpGet("base-data-redo")]
    public async Task<dynamic> BaseDataRedo()
    {
        var rsp = new
        {
            OrderRedoReasonOptions = EnumExts.GetDescriptions<EOrderRedoReason>(),
        };
        return rsp;
    }

    #endregion

    #region 工单延期

    /// <summary>
    /// 可申请延期工单
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.CanDelayOrderList)]
    [HttpGet("candelay")]
    public async Task<PagedDto<OrderDto>> CanDelayOrderList([FromQuery] CanDelayOrderListDto dto)
    {
        var (total, items) = await _orderRepository.Queryable()
            .Includes(d => d.Acceptor)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword),
                d => d.Title.Contains(dto.Keyword!) || d.No.Contains(dto.Keyword!))
            .Where(d => d.Status != EOrderStatus.WaitForAccept && d.Status != EOrderStatus.Filed &&
                        SqlFunc.Subqueryable<OrderDelay>()
                            .Where(s => s.OrderId == d.Id && s.DelayState == EDelayState.Examining).NotAny())
            .OrderByDescending(d => d.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);

        return new PagedDto<OrderDto>(total, _mapper.Map<IReadOnlyList<OrderDto>>(items));
    }

    /// <summary>
    /// 申请延期
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.ApplyDelay)]
    [HttpPost("delay")]
    public async Task ApplyDelay([FromBody] DelayStartFlowDto dto)
    {
        var delaydto = _mapper.Map<ApplyDelayDto>(dto.Data);
        //验证工单是否可以申请
        var order = await _orderRepository.GetAsync(delaydto.OrderId, HttpContext.RequestAborted);
        if (order is null)
            throw UserFriendlyException.SameMessage("无效工单");
        //验证工单是否在办理中
        if (order.Status == EOrderStatus.WaitForAccept || order.Status == EOrderStatus.Filed)
            throw UserFriendlyException.SameMessage("当前工单状态不能申请延期");

        bool IsHas = await _orderDelayRepository.AnyAsync(x => x.OrderId == delaydto.OrderId && x.DelayState == EDelayState.Examining, HttpContext.RequestAborted);
        if (IsHas)
            throw UserFriendlyException.SameMessage("该存在延期申请正在审核");
        //验证延期次数
        var setting = _systemSettingCacheManager.GetSetting(SettingConstants.DelayNum);
        int count = await _orderDelayRepository.CountAsync(x => x.OrderId == delaydto.OrderId);
        if (count > int.Parse(setting?.SettingValue[0]))
            throw UserFriendlyException.SameMessage("延期申请已超过系统预定设置，不能申请");

        var model = _mapper.Map<OrderDelay>(delaydto);
        model.EmployeeId = _sessionContext.UserId;
        model.ApplyOrgName = _sessionContext.OrgName;
        model.ApplyOrgCode = _sessionContext.OrgId;
        model.BeforeDelay = order.ExpiredTime;
        model.DelayState = EDelayState.Examining;
        if (model.BeforeDelay != null)
        {
            model.AfterDelay = _timeLimitDomainService.CalcEndTime(model.BeforeDelay.Value, delaydto.DelayUnit, delaydto.DelayNum, false)?.EndTime;//todo
        }

        model.ApplyDelayTime = DateTime.Now;
        model.No = order.No;
        var id = await _orderDelayRepository.AddAsync(model, HttpContext.RequestAborted);
        try
        {
            var startDto = _mapper.Map<StartWorkflowDto>(dto.Workflow);
            startDto.DefinitionModuleCode = WorkflowModuleConsts.OrderDelay;
            startDto.Title = model.DelayReason;
            string workFlowId = await _workflowApplication.StartWorkflowAsync(startDto, id, HttpContext.RequestAborted);
            model.WorkFlowId = workFlowId;
            await _orderDelayRepository.UpdateAsync(model, HttpContext.RequestAborted);
        }
        catch (Exception ex)
        {
            await _orderDelayRepository.RemoveAsync(id, false, HttpContext.RequestAborted);
            throw new UserFriendlyException($"工单延期流程失败!, {ex.Message}", "工单延期流程失败");
        }
    }

    /// <summary>
    /// 延期列表
    /// </summary>
    /// <returns></returns>
    [Permission(EPermission.DelayList)]
    [HttpGet("delay")]
    public async Task<PagedDto<OrderDelay>> DelayList([FromQuery] DelayListDto dto)
    {
        var (total, items) = await _orderDelayRepository.Queryable()
            .Includes(x => x.Order)
            .Includes(x => x.Employee)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword),
                d => d.Order.Title.Contains(dto.Keyword!) || d.Order.No.Contains(dto.Keyword!))
            .WhereIF(dto.IsApply, x => x.DelayState != EDelayState.Examining)
            .WhereIF(!dto.IsApply, x => x.DelayState == EDelayState.Examining)
            .WhereIF(dto.DelayState != null, x => x.DelayState == dto.DelayState)
            .OrderByDescending(x => x.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);

        return new PagedDto<OrderDelay>(total, _mapper.Map<IReadOnlyList<OrderDelay>>(items));
    }

    /// <summary>
    /// 延期详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.DelayEntity)]
    [HttpGet("delay/{id}")]
    public async Task<OrderDelay> DelayEntity(string id)
    {
        return await _orderDelayRepository.Queryable()
            .Includes(x => x.Order)
            .Includes(x => x.Employee)
            .FirstAsync(x => x.Id == id);
    }

    /// <summary>
    /// 计算期满时间
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.DelayCalcEndTime)]
    [HttpPost("delay/calc-endtime")]
    public async Task<TimeResult?> DelayCalcEndTime([FromBody] DelayCalcEndTimeDto dto)
    {
        return _timeLimitDomainService.CalcEndTime(dto.BeginTime, dto.DelayUnit, dto.DelayNum, false);
    }

    /// <summary>
    /// 查询工单延期流程开启参数
    /// </summary>
    /// <returns></returns>
    [HttpGet("delay/startflow")]
    public async Task<NextStepsDto> GetDelayFlowStartOptions()
    {
        return await _workflowApplication.GetStartStepsAsync(WorkflowModuleConsts.OrderDelay, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 延期页面基础信息
    /// </summary>
    /// <returns></returns>
    [HttpGet("delay/basedata")]
    public async Task<object> DelayBaseData()
    {
        var rsp = new
        {
            DelayState = EnumExts.GetDescriptions<EDelayState>(),
            TimeType = EnumExts.GetDescriptions<ETimeType>()
        };
        return rsp;
    }
    #endregion

    #region 工单甄别

    /// <summary>
    /// 工单甄别待申请列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.MayOrderScreenList)]
    [HttpGet("mayscreen")]
    public async Task<PagedDto<OrderVisitDetailDto>> MayScreenList([FromQuery] MayScreenListDto dto)
    {
        var query = _orderVisitedDetailRepository.Queryable()
            .Includes(x => x.OrderVisit)
            .Includes(x => x.OrderVisit, y => y.Order)
            .Includes(x => x.OrderVisit, y => y.Employee);
        if (_sessionContext.OrgId != null && !_sessionContext.OrgId.StartsWith("001"))
        {
            query.WhereIF(!string.IsNullOrEmpty(dto.Keyword), d => d.OrderVisit.Order.Title.Contains(dto.Keyword!) || d.OrderVisit.Order.No.Contains(dto.Keyword!))
                .Where(d => d.VisitTarget == EVisitTarget.Org && d.VisitOrgCode == _sessionContext.OrgId && (
                    SqlFunc.JsonField(d.OrgProcessingResults, "Name") == "不满意" || SqlFunc.JsonField(d.OrgProcessingResults, "Name") == "非常不满意" ||
                    SqlFunc.JsonField(d.OrgHandledAttitude, "Name") == "不满意" || SqlFunc.JsonField(d.OrgHandledAttitude, "Name") == "非常不满意"
                ));
        }
        else
        {
            query.WhereIF(!string.IsNullOrEmpty(dto.Keyword), d => d.OrderVisit.Order.Title.Contains(dto.Keyword!) || d.OrderVisit.Order.No.Contains(dto.Keyword!))
                .Where(d => d.VisitTarget == EVisitTarget.Org && (
                    SqlFunc.JsonField(d.OrgProcessingResults, "Name") == "不满意" || SqlFunc.JsonField(d.OrgProcessingResults, "Name") == "非常不满意" ||
                    SqlFunc.JsonField(d.OrgHandledAttitude, "Name") == "不满意" || SqlFunc.JsonField(d.OrgHandledAttitude, "Name") == "非常不满意"
                ));
        }
        var (total, items) = await query
            .OrderBy(x => x.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
        return new PagedDto<OrderVisitDetailDto>(total, _mapper.Map<IReadOnlyList<OrderVisitDetailDto>>(items));
    }


    /// <summary>
    /// 工单甄别列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.OrderScreenList)]
    [HttpGet("screen")]
    public async Task<PagedDto<OrderScreenListDto>> ScreenList([FromQuery] ScreenListDto dto)
    {
        var (total, items) = await _orderScreenRepository.Queryable()
            .Includes(x => x.Order)
            .Includes(x => x.VisitDetail)
            .Includes(x => x.Visit, d => d.Order)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword), d => d.Visit.Order.Title.Contains(dto.Keyword!) || d.Visit.Order.No.Contains(dto.Keyword!))
            .WhereIF(dto.Status == EScreenStatus.Apply || dto.Status == EScreenStatus.Approval || dto.Status == EScreenStatus.End, x => x.Status == dto.Status)
            .WhereIF(dto.CreationTimeStart.HasValue, d => d.CreationTime >= dto.CreationTimeStart)
            .WhereIF(dto.CreationTimeEnd.HasValue, d => d.CreationTime <= dto.CreationTimeEnd)
            .OrderByDescending(x => x.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
        return new PagedDto<OrderScreenListDto>(total, _mapper.Map<IReadOnlyList<OrderScreenListDto>>(items));
    }


    /// <summary>
    /// 开始工单甄别流程
    /// </summary>
    [Permission(EPermission.ApplyScreen)]
    [HttpPost("screen/startflow")]
    public async Task StartFlow([FromBody] ScreenStartFlowDto dto)
    {
        int screenCount = await _orderScreenRepository.CountAsync(x => x.VisitDetailId == dto.Data.VisitDetailId && (x.Status == EScreenStatus.Apply || x.Status == EScreenStatus.Approval));
        if (screenCount > 0)
            throw UserFriendlyException.SameMessage("该工单已提起甄别申请，正在审批过程中，不能申请");

        var setting = _systemSettingCacheManager.GetSetting(SettingConstants.ScreenApplyNum);
        int count = await _orderScreenRepository.CountAsync(x => x.OrderId == dto.Data.OrderId && x.Status == EScreenStatus.Refuse);
        if (count > int.Parse(setting?.SettingValue[0]))
            throw UserFriendlyException.SameMessage("甄别申请已超过系统预定设置，不能申请");

        var visit = await _orderVisitRepository.GetAsync(dto.Data.VisitId, HttpContext.RequestAborted);
        setting = _systemSettingCacheManager.GetSetting(SettingConstants.ScreenApplyEndTime);
        var endTime = _timeLimitDomainService.CalcEndTime(visit.VisitTime.Value, ETimeType.WorkDay, int.Parse(setting?.SettingValue[0]), false).EndTime.Value;
        if (DateTime.Now > endTime)
            throw UserFriendlyException.SameMessage("甄别申请时限已超过系统预定设置，不能申请");

        var model = _mapper.Map<OrderScreen>(dto.Data);
        model.Status = EScreenStatus.Apply;
        model.ApplyEndTime = endTime;
        var id = await _orderScreenRepository.AddAsync(model, HttpContext.RequestAborted);
        if (dto.Data.Files.Any()) await _fileRepository.AddFileAsync(dto.Data.Files, id, HttpContext.RequestAborted);
        var workflowId = string.Empty;
        try
        {
            var startDto = _mapper.Map<StartWorkflowDto>(dto.Workflow);
            startDto.DefinitionModuleCode = WorkflowModuleConsts.OrderScreen;
            startDto.Title = dto.Data.Content;
            workflowId = await _workflowApplication.StartWorkflowAsync(startDto, id, HttpContext.RequestAborted);
            var screen = await _orderScreenRepository.GetAsync(id, HttpContext.RequestAborted);
            if (screen != null)
            {
                screen.WorkFlowId = workflowId;
                await _orderScreenRepository.UpdateAsync(screen, HttpContext.RequestAborted);
            }
        }
        catch (Exception e)
        {
            await _orderScreenRepository.RemoveAsync(id);
            id = string.Empty;
            throw new UserFriendlyException($"工单开启甄别流程失败!, {e.Message}", "工单开启甄别流程失败");
        }
        if (!string.IsNullOrEmpty(id))
        {
            var screen = await _orderScreenRepository.GetAsync(x => x.Id == id);
            if (screen != null)
            {
                var screenDto = _mapper.Map<OrderScreenListDto>(screen);
                var order = await _orderRepository.GetAsync(x => x.Id == dto.Data.OrderId);
                if (order != null && order.Source == ESource.ProvinceStraight)
                {
                    var orderDto = _mapper.Map<OrderDto>(order);
                    //推省上
                    _capPublisher.Publish(EventNames.HotlineOrderScreenApply, new PublishScreenDto()
                    {
                        Order = orderDto,
                        Screen = screenDto,
                        ClientGuid = ""
                    });
                }
            }
        }
    }

    /// <summary>
    /// 查询工单甄别流程开启参数
    /// </summary>
    /// <returns></returns>
    [HttpGet("screen/startflow")]
    public async Task<NextStepsDto> GetScreenFlowStartOptionsAsync()
    {
        //return await _workflowApplication.GetStartOptionsAsync(WorkflowModuleConsts.OrderScreen,
        //    HttpContext.RequestAborted);

        return await _workflowApplication.GetStartStepsAsync(WorkflowModuleConsts.OrderScreen,
            HttpContext.RequestAborted);
    }

    /// <summary>
    /// 查询工单甄别流程参数
    /// </summary>
    /// <returns></returns>
    [HttpGet("screen/workflow/{id}")]
    public async Task<string> GetScreenWorkFlowAsync(string id)
    {
        var workflow = await _workflowRepository.Queryable().FirstAsync(x => x.ExternalId == id);
        return workflow.Id;
    }

    /// <summary>
    /// 列表页面基础数据
    /// </summary>
    /// <returns></returns>
    [HttpGet("screen/base")]
    public async Task<object> ScreenBaseData()
    {
        var rsp = new
        {
            ScreenStatus = EnumExts.GetDescriptions<EScreenStatus>(),
            ScreenType = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.ScreenType),
        };
        return rsp;
    }

    /// <summary>
    /// 甄别详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.ScreenEntity)]
    [HttpGet("screen/{id}")]
    public async Task<OrderScreen> ScreenEntity(string id)
    {
        return await _orderScreenRepository.Queryable()
            .Includes(x => x.Visit, d => d.Order)
            .FirstAsync(x => x.Id == id);
    }

    #endregion

    #region 工单督办

    /// <summary>
    /// 工单督办列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.SuperviseOrderList)]
    [HttpGet("supervise")]
    public async Task<PagedDto<SuperviseOrderDto>> SuperviseList([FromQuery] SuperviseListDto dto)
    {
        var (total, items) = await _orderSuperviseRepository.Queryable()
            .Includes(x => x.Order)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword),
                d => d.Order.Title.Contains(dto.Keyword!) || d.Order.No.Contains(dto.Keyword!))
            .WhereIF(dto.SuperviseState > -1, x => x.State == dto.SuperviseState)
            .WhereIF(dto.CreationTimeStart.HasValue, d => d.CreationTime >= dto.CreationTimeStart)
            .WhereIF(dto.CreationTimeEnd.HasValue, d => d.CreationTime <= dto.CreationTimeEnd)
            .OrderByDescending(x => x.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);

        return new PagedDto<SuperviseOrderDto>(total, _mapper.Map<IReadOnlyList<SuperviseOrderDto>>(items));
    }

    /// <summary>
    /// 申请督办
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.ApplySupervise)]
    [HttpPost("supervise/apply")]
    public async Task ApplySupervise([FromBody] ApplyOrderSuperviseDto dto)
    {
        if (!dto.SuperviseOrgDtos.Any())
            throw UserFriendlyException.SameMessage("请选择被督办部门");
        //验证工单是否可以申请
        var order = await _orderRepository.GetAsync(dto.OrderId, HttpContext.RequestAborted);
        if (order is null)
            throw UserFriendlyException.SameMessage("无效工单");

        foreach (var item in dto.SuperviseOrgDtos)
        {
            var model = _mapper.Map<OrderSupervise>(dto);
            model.OrgId = item.OrgId;
            model.OrgName = item.OrgName;
            model.CreatorOrgName = _sessionContext.OrgName;
            model.CrUser = _sessionContext.UserName;
            model.State = 0;
            var id = await _orderSuperviseRepository.AddAsync(model, HttpContext.RequestAborted);
            if (dto.Files.Any()) await _fileRepository.AddFileAsync(dto.Files, id, HttpContext.RequestAborted);
            if (dto.AcceptSms)
            {
                //TODO 发送短信
            }
            //推省上
            if (!string.IsNullOrEmpty(id) && order.Source == ESource.ProvinceStraight)
            {
                var orderDto = _mapper.Map<OrderDto>(order);
                var supervise = await _orderSuperviseRepository.GetAsync(x => x.Id == id);
                if (supervise != null)
                {
                    var superviseDto = _mapper.Map<SuperviseOrderDto>(supervise);
                    _capPublisher.Publish(EventNames.HotlineOrderSuperviseCourse, new PublishSuperviseDto()
                    {
                        Order = orderDto,
                        Supervise = superviseDto,
                        ClientGuid = ""
                    });
                }
            }
        }
    }

    /// <summary>
    /// 回复督办
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.ReplySupervise)]
    [HttpPost("supervise/reply")]
    public async Task ReplySupervise([FromBody] ReplyOrderSuperviseDto dto)
    {
        //验证是否存在督办
        var supervise = await _orderSuperviseRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
        if (supervise is null)
            throw UserFriendlyException.SameMessage("无效督办");
        if (supervise.State > 0)
            throw UserFriendlyException.SameMessage("督办已回复,请勿重复回复");
        _mapper.Map(dto, supervise);
        supervise.ReplyId = _sessionContext.UserId;
        supervise.ReUser = _sessionContext.UserName;
        supervise.ReplyTime = DateTime.Now;
        supervise.State = 1;
        if (dto.Files.Any()) await _fileRepository.AddFileAsync(dto.Files, supervise.Id, HttpContext.RequestAborted);
        await _orderSuperviseRepository.UpdateAsync(supervise, HttpContext.RequestAborted);
        var order = await _orderRepository.GetAsync(supervise.OrderId, HttpContext.RequestAborted);
        //推省上
        if (order != null && order.Source == ESource.ProvinceStraight)
        {
            var orderDto = _mapper.Map<OrderDto>(order);
            var superviseDto = _mapper.Map<SuperviseOrderDto>(supervise);
            _capPublisher.Publish(EventNames.HotlineOrderSuperviseCourse, new PublishSuperviseDto()
            {
                Order = orderDto,
                Supervise = superviseDto,
                ClientGuid = ""
            });
        }
    }

    /// <summary>
    /// 签收督办
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.SignSupervise)]
    [HttpPost("supervise/sign")]
    public async Task SignSupervise([FromBody] SignOrderSuperviseDto dto)
    {
        //验证是否存在督办
        var supervise = await _orderSuperviseRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
        if (supervise is null)
            throw UserFriendlyException.SameMessage("无效督办");
        supervise.SignTime = DateTime.Now;
        supervise.SignUser = _sessionContext.UserName;
        await _orderSuperviseRepository.UpdateAsync(supervise, HttpContext.RequestAborted);
        var order = await _orderRepository.GetAsync(supervise.OrderId, HttpContext.RequestAborted);
        //推省上
        if (order != null && order.Source == ESource.ProvinceStraight)
        {
            var orderDto = _mapper.Map<OrderDto>(order);
            var superviseDto = _mapper.Map<SuperviseOrderDto>(supervise);
            _capPublisher.Publish(EventNames.HotlineOrderSuperviseCourse, new PublishSuperviseDto()
            {
                Order = orderDto,
                Supervise = superviseDto,
                ClientGuid = ""
            });
        }
    }


    /// <summary>
    /// 督办详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.SuperviseEntity)]
    [HttpGet("supervise/{id}")]
    public async Task<OrderSupervise> SuperviseEntity(string id)
    {
        return await _orderSuperviseRepository.Queryable()
            .Includes(x => x.Order)
            .FirstAsync(x => x.Id == id);
    }

    #endregion

    #region 工单催办

    /// <summary>
    /// 工单催办列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.UrgeOrderList)]
    [HttpGet("urge")]
    public async Task<PagedDto<UrgeOrderDto>> UrgeList([FromQuery] UrgeListDto dto)
    {
        var (total, items) = await _orderUrgeRepository.Queryable()
            .Includes(x => x.Order)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword),
                d => d.Order.Title.Contains(dto.Keyword!) || d.Order.No.Contains(dto.Keyword!))
            .WhereIF(dto.SuperviseState > -1, x => x.State == dto.SuperviseState)
            .WhereIF(dto.CreationTimeStart.HasValue, d => d.CreationTime >= dto.CreationTimeStart)
            .WhereIF(dto.CreationTimeEnd.HasValue, d => d.CreationTime <= dto.CreationTimeEnd)
            .OrderByDescending(x => x.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);

        return new PagedDto<UrgeOrderDto>(total, _mapper.Map<IReadOnlyList<UrgeOrderDto>>(items));
    }

    /// <summary>
    /// 申请催办
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.ApplyUrge)]
    [HttpPost("urge/apply")]
    public async Task ApplyUrge([FromBody] ApplyOrderUrgeDto dto)
    {
        if (!dto.UrgeOrgDtos.Any())
            throw UserFriendlyException.SameMessage("请选择被催办部门");
        //验证工单是否可以申请
        var order = await _orderRepository.GetAsync(dto.OrderId, HttpContext.RequestAborted);
        if (order is null)
            throw UserFriendlyException.SameMessage("无效工单");

        foreach (var item in dto.UrgeOrgDtos)
        {
            var model = _mapper.Map<OrderUrge>(dto);
            model.OrgId = item.OrgId;
            model.OrgName = item.OrgName;
            model.CreatorOrgName = _sessionContext.OrgName;
            model.CrUser = _sessionContext.UserName;
            model.State = 0;
            var id = await _orderUrgeRepository.AddAsync(model, HttpContext.RequestAborted);
            if (dto.Files.Any()) await _fileRepository.AddFileAsync(dto.Files, id, HttpContext.RequestAborted);
            if (dto.AcceptSms)
            {
                //TODO 发送短信
            }
            //推省上
            if (!string.IsNullOrEmpty(id) && order.Source == ESource.ProvinceStraight)
            {
                var orderDto = _mapper.Map<OrderDto>(order);
                var urge = await _orderUrgeRepository.GetAsync(x => x.Id == id);
                if (urge != null)
                {
                    var urgeDto = _mapper.Map<UrgeOrderDto>(urge);
                    _capPublisher.Publish(EventNames.HotlineOrderSuperviseCourse, new PublishUrgeDto()
                    {
                        Order = orderDto,
                        Urge = urgeDto,
                        ClientGuid = ""
                    });
                }
            }
        }
    }

    /// <summary>
    /// 回复催办
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.ReplyUrge)]
    [HttpPost("urge/reply")]
    public async Task ReplyUrge([FromBody] ReplyOrderUrgeDto dto)
    {
        //验证是否存在催办
        var urge = await _orderUrgeRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
        if (urge is null)
            throw UserFriendlyException.SameMessage("无效催办");
        if (urge.State > 0)
            throw UserFriendlyException.SameMessage("督办已回复,请勿重复回复");

        _mapper.Map(dto, urge);
        urge.ReplyId = _sessionContext.UserId;
        urge.ReUser = _sessionContext.UserName;
        urge.ReplyContent = dto.ReplyContent;
        urge.ReplyTime = DateTime.Now;
        urge.State = 1;
        if (dto.Files.Any()) await _fileRepository.AddFileAsync(dto.Files, urge.Id, HttpContext.RequestAborted);
        await _orderUrgeRepository.UpdateAsync(urge, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 签收催办
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.SignUrge)]
    [HttpPost("urge/sign")]
    public async Task SignUrge([FromBody] SignOrderUrgeDto dto)
    {
        //验证是否存在催办
        var urge = await _orderUrgeRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
        if (urge is null)
            throw UserFriendlyException.SameMessage("无效催办");
        urge.SignUser = _sessionContext.UserName;
        urge.SignTime = DateTime.Now;
        await _orderUrgeRepository.UpdateAsync(urge, HttpContext.RequestAborted);
    }


    /// <summary>
    /// 催办详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.UrgeEntity)]
    [HttpGet("urge/{id}")]
    public async Task<OrderUrge> UrgeEntity(string id)
    {
        return await _orderUrgeRepository.Queryable()
            .Includes(x => x.Order)
            .FirstAsync(x => x.Id == id);
    }

    #endregion

    #region 工单办理

    /// <summary>
    /// 工单列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.OrderQuery)]
    [HttpGet]
    public async Task<PagedDto<OrderDto>> Query([FromQuery] QueryOrderDto dto)
    {
        var (total, items) = await _orderRepository.Queryable()
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword),
                d => d.Title.Contains(dto.Keyword!) || d.No.Contains(dto.Keyword!))
            .WhereIF(!string.IsNullOrEmpty(dto.Content), d => d.Content.Contains(dto.Content!))
            .WhereIF(dto.AcceptTypes.Any(), d => dto.AcceptTypes.Contains(d.AcceptType))
            .WhereIF(dto.Channels.Any(), d => dto.Channels.Contains(d.SourceChannel))
            .WhereIF(dto.HotspotIds.Any(), d => dto.HotspotIds.Contains(d.HotspotId))
            .WhereIF(!string.IsNullOrEmpty(dto.TransferPhone), d => d.TransferPhone.Contains(dto.TransferPhone!))
            //.WhereIF(dto.OrgCodes.Any(), d => d.Workflow.Assigns.Any(s => dto.OrgCodes.Contains(s.OrgCode)))
            .WhereIF(dto.OrgCodes.Any(), d => dto.OrgCodes.Contains(d.Workflow.ActualHandleOrgCode))
            .WhereIF(!string.IsNullOrEmpty(dto.NameOrNo),
                d => d.AcceptorName.Contains(dto.NameOrNo!) || d.AcceptorStaffNo.Contains(dto.NameOrNo!))
            .WhereIF(dto.CreationTimeStart.HasValue, d => d.CreationTime >= dto.CreationTimeStart)
            .WhereIF(dto.CreationTimeEnd.HasValue, d => d.CreationTime <= dto.CreationTimeEnd)
            .WhereIF(dto.EmergencyLevels.Any(), d => dto.EmergencyLevels.Contains(d.EmergencyLevel))
            .WhereIF(!string.IsNullOrEmpty(dto.PhoneNo),
                d => d.FromPhone.Contains(dto.PhoneNo!) || d.Contact.Contains(dto.PhoneNo!))
            .WhereIF(!string.IsNullOrEmpty(dto.PushTypeCode), d => d.PushTypeCode == dto.PushTypeCode)
            .WhereIF(dto.ExpiredTimeStart.HasValue, d => d.ExpiredTime >= dto.ExpiredTimeStart)
            .WhereIF(dto.ExpiredTimeEnd.HasValue, d => d.ExpiredTime <= dto.ExpiredTimeEnd)
            .WhereIF(dto.Statuses.Any(), d => dto.Statuses.Contains(d.Status))
            .OrderByDescending(d => d.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);

        return new PagedDto<OrderDto>(total, _mapper.Map<IReadOnlyList<OrderDto>>(items));
    }

    /// <summary>
    /// 历史工单
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.OrderHistory)]
    [HttpGet("history")]
    public async Task<PagedDto<OrderDto>> Query([FromQuery] QueryOrderHistoryDto dto)
    {
        var (total, items) = await _orderRepository.Queryable()
            .Where(d => d.FromPhone == dto.PhoneNo)
            .WhereIF(!string.IsNullOrEmpty(dto.OrderId), d => d.Id != dto.OrderId)
            .OrderByDescending(d => d.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
        return new PagedDto<OrderDto>(total, _mapper.Map<IReadOnlyList<OrderDto>>(items));
    }

    /// <summary>
    /// 查询重复工单
    /// </summary>
    [HttpGet("duplicate")]
    public async Task<PagedDto<OrderDto>> Query([FromQuery] QueryOrderDuplicateDto dto)
    {
        if (!dto.OrderIds.Any())
            return new PagedDto<OrderDto>(0, new List<OrderDto>());

        var (total, items) = await _orderRepository.Queryable()
            .Where(d => dto.OrderIds.Contains(d.Id))
            .OrderByDescending(d => d.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
        return new PagedDto<OrderDto>(total, _mapper.Map<IReadOnlyList<OrderDto>>(items));
    }

    /// <summary>
    /// 查询工单详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.GetOrder)]
    [HttpGet("{id}")]
    public async Task<OrderDto> Get(string id)
    {
        var order = await _orderRepository.Queryable()
            .Includes(d => d.Acceptor)
            .Includes(d => d.OrderComplain)
            .Includes(d => d.OrderReport)
            .FirstAsync(d => d.Id == id);
        if (order == null)
            return new();

        var canHandle = false;
        if (!string.IsNullOrEmpty(order?.WorkflowId))
        {
            var (workflow, handlePermission) = await _workflowDomainService.GetWorkflowHandlePermissionAsync(
                order.WorkflowId, _sessionContext.RequiredUserId, _sessionContext.RequiredOrgId,
                withSteps: true, withSupplements: true,
                cancellationToken: HttpContext.RequestAborted);
            order.Workflow = workflow;
            canHandle = handlePermission;

            await _mediator.Publish(new GetOrderDetailNotify(order.Workflow,
                _sessionContext.RequiredUserId, _sessionContext.UserName,
                _sessionContext.RequiredOrgId, _sessionContext.OrgName,
                _sessionContext.OrgAreaCode, _sessionContext.OrgAreaName));
        }

        var dto = _mapper.Map<OrderDto>(order!);

        if (order?.Workflow != null)
            dto.Workflow.CanHandle = canHandle;
        var repeatablesMap = await _repeatableEventDetailRepository.Queryable()
            .Includes(x => x.Order)
            .Where(x => x.OrderId == id).Distinct().ToListAsync();
        var repeatables = _mapper.Map<List<RepeatableEventDetailOpDto>>(repeatablesMap);
        dto.RepeatableEventDetails = repeatables;
		return dto;
    }

    /// <summary>
    /// 新增工单
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.OrderAdd)]
    [HttpPost]
    public async Task<string> Add([FromBody] AddOrderDto dto)
    {
        var order = _mapper.Map<Order>(dto);
        var orderId = await _orderDomainService.AddAsync(order, HttpContext.RequestAborted);
        if (dto.Tags.Any()) await _repositoryts.AddVectorAsync(orderId, DateTime.Now, dto.Tags, HttpContext.RequestAborted);
        if (dto.Files.Any()) await _fileRepository.AddFileAsync(dto.Files, orderId, HttpContext.RequestAborted);
        if (dto.RepeatableEventDetails?.Any() ?? false)
        {
            dto.RepeatableEventDetails.ForEach(x => x.OrderId = orderId);
            List<RepeatableEventDetail> repeatables = _mapper.Map<List<RepeatableEventDetail>>(dto.RepeatableEventDetails);
            await _repeatableEventDetailRepository.AddRangeAsync(repeatables, HttpContext.RequestAborted);
        }
        return orderId;
    }

    /// <summary>
    /// 删除工单
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.OrderRemove)]
    [HttpDelete("{id}")]
    public async Task Remove(string id)
    {
        var order = await _orderRepository.GetAsync(id, HttpContext.RequestAborted);
        if (order == null) return;
        if (order.Status != EOrderStatus.WaitForAccept)
            throw UserFriendlyException.SameMessage("非草稿工单不可删除");
        await _orderRepository.RemoveAsync(order);
    }

    /// <summary>
    /// 更新工单信息
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.OrderUpdate)]
    [HttpPut]
    public async Task Update([FromBody] UpdateOrderDto dto)
    {
        var order = await _orderRepository.Queryable()
            .Includes(d => d.OrderComplain)
            .Includes(d => d.OrderReport)
            .FirstAsync(d => d.Id == dto.Id);
        if (order == null)
            throw UserFriendlyException.SameMessage("无效工单编号");
        if (order.Status != EOrderStatus.WaitForAccept || !string.IsNullOrEmpty(order.WorkflowId))
            throw UserFriendlyException.SameMessage("工单已发起流程");

        if (order?.OrderComplain is not null)
            await _orderRepository.RemoveOrderComplainAsync(order.OrderComplain, HttpContext.RequestAborted);
        if (order?.OrderReport is not null)
            await _orderRepository.RemoveOrderReportAsync(order.OrderReport, HttpContext.RequestAborted);
        if (dto.Tags.Any()) await _repositoryts.UpdateVectorAsync(dto.Id, dto.Tags, HttpContext.RequestAborted);
        if (dto.RepeatableEventDetails?.Any() ?? false)
        {
            var reAdds = dto.RepeatableEventDetails.Where(x => string.IsNullOrEmpty(x.OrderId) && !x.IsDeleted).ToList();
            var reDeletes = dto.RepeatableEventDetails.Where(x => !string.IsNullOrEmpty(x.OrderId) && x.IsDeleted).ToList();
			reAdds.ForEach(x => x.OrderId = dto.Id);
	        List<RepeatableEventDetail> repeatables = _mapper.Map<List<RepeatableEventDetail>>(reAdds);
	        await _repeatableEventDetailRepository.AddRangeAsync(repeatables, HttpContext.RequestAborted);
	        if (reDeletes?.Any()?? false)
	        {
                await _repeatableEventDetailRepository.DeleteAsync(reDeletes, HttpContext.RequestAborted);
			}
        }
		_mapper.Map(dto, order);
        await _orderRepository.UpdateOrderNavAsync(order, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 开始流程
    /// </summary>
    /// <param name="id">工单id</param>
    /// <param name="dto">流程开启参数</param>
    /// <returns></returns>
    [HttpPost("{id}/startflow")]
    [Obsolete]
    public async Task StartFlow(string id, [FromBody] StartWorkflowDto dto)
    {
        var order = await _orderRepository.GetAsync(id, HttpContext.RequestAborted);
        if (order == null)
            throw UserFriendlyException.SameMessage("无效工单编号");
        if (order.Status != EOrderStatus.WaitForAccept || !string.IsNullOrEmpty(order.WorkflowId))
            throw UserFriendlyException.SameMessage("工单已发起流程");

        dto.DefinitionModuleCode = WorkflowModuleConsts.OrderHandle;
        dto.Title = order.Title;
        order.StartManageFlow();
        await _orderRepository.UpdateAsync(order, HttpContext.RequestAborted);
        await _workflowApplication.StartWorkflowAsync(dto, order.Id, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 开始工单办理流程
    /// </summary>
    [HttpPost("startflow")]
    public async Task StartFlow([FromBody] OrderStartFlowDto dto)
    {
        var id = dto.Data.Id;
        var isAdd = string.IsNullOrEmpty(dto.Data.Id);
        if (isAdd)
        {
            id = await Add(_mapper.Map<AddOrderDto>(dto.Data));
        }
        else
        {
            await Update(dto.Data);
        }

        try
        {
            var startDto = _mapper.Map<StartWorkflowDto>(dto.Workflow);
            startDto.DefinitionModuleCode = WorkflowModuleConsts.OrderHandle;
            startDto.Title = dto.Data.Title;
            await _workflowApplication.StartWorkflowAsync(startDto, id, HttpContext.RequestAborted);
        }
        catch (Exception e)
        {
            if (isAdd)
                await Remove(id);
            throw new UserFriendlyException($"工单开启流程失败!, {e.Message}", "工单开启流程失败");
        }
    }

    /// <summary>
    /// 查询工单办理流程开启参数
    /// </summary>
    /// <returns></returns>
    [HttpGet("startflow")]
    public async Task<NextStepsDto> GetFlowStartOptionsAsync()
    {
        //return await _workflowApplication.GetStartOptionsAsync(WorkflowModuleConsts.OrderHandle,
        //    HttpContext.RequestAborted);

        return await _workflowApplication.GetStartStepsAsync(WorkflowModuleConsts.OrderHandle,
                    HttpContext.RequestAborted);
    }

    /// <summary>
    /// 列表页面基础数据
    /// </summary>
    /// <returns></returns>
    [HttpGet("base-data")]
    public async Task<object> BaseData()
    {
        var rsp = new
        {
            AcceptTypeOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.AcceptType),
            ChannelOptions = _sysDicDataCacheManager.GetSysDicDataCache(TimeLimitBaseDataConsts.SourceChannel),
            OrgsOptions = await _organizeRepository.GetOrgJson(),
            EmergencyLevelOptions = EnumExts.GetDescriptions<EEmergencyLevel>(),
            PushTypeOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.PushType),
            OrderStatusOptions = EnumExts.GetDescriptions<EOrderStatus>(),
        };
        return rsp;
    }

    /// <summary>
    /// 新增页面基础数据
    /// </summary>
    /// <returns></returns>
    [HttpGet("base-data-add")]
    public async Task<object> BaseDataAdd()
    {
        var rsp = new
        {
            ChannelOptions = _sysDicDataCacheManager.GetSysDicDataCache(TimeLimitBaseDataConsts.SourceChannel),
            AcceptTypeOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.AcceptType),
            EmergencyLevelOptions = EnumExts.GetDescriptions<EEmergencyLevel>(),
            PushTypeOptions =_sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.PushType),
            GenderOptions = EnumExts.GetDescriptions<EGender>(),
            IdentityTypeOptions = EnumExts.GetDescriptions<EIdentityType>(),
            LicenceTypeOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.LicenceType),
            AgeRangeOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.AgeRange),
            OrderTypeOptions = EnumExts.GetDescriptions<EOrderType>(),
        };
        return rsp;
    }

    /// <summary>
    /// 扩展信息新增页面基础数据
    /// </summary>
    /// <returns></returns>
    [HttpGet("base-data-ext")]
    public async Task<object> BaseDataExtension()
    {
        var rsp = new
        {
            LicenceTypeOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.LicenceType),
            IdentityTypeOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.ProviderIdentityType),
            IdentityOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.Identity),
            NationalityOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.Nationality),
            NationOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.Nation),
            MarketTypeOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.MarketType),
            IndustryClassifyOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.IndustryClassify),
            BrandOptions =_sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.Brand),
            ObjectClassifyOptions =_sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.ObjectClassify),
            ComplainClassifyOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.ComplainClassify),
            ReportClassifyOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.ReportClassify),
            SalesModeOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.SalesMode),
            ECommercePlatformOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.ECommercePlatform),
            PatentTypeOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.PatentType),
            AffairTargetOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.AffairTarget),
            ComplainTypeOptions = EnumExts.GetDescriptions<EComplainType>().Select(d => new Kv(d.Key.ToString(), d.Value)),
            SalesChannelOptions = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.SalesChannel),
        };
        return rsp;
    }

	/// <summary>
	/// 扩展信息新增页面基础数据
	/// </summary>
	/// <returns></returns>
	[HttpPost("order_repeatable_event")]
	public async Task<bool> RepeatableEvent(QueryRepeatableEventDto dto)
	{
		var exp = Expressionable.Create<Order>()
			.OrIF(!string.IsNullOrEmpty(dto.HotspotSpliceName), x => x.HotspotSpliceName.EndsWith(dto.HotspotSpliceName!))
			.OrIF(!string.IsNullOrEmpty(dto.Address), x => x.Address != null && x.Address.EndsWith(dto.Address!));
		var count = await _orderRepository.Queryable()
			.Where(exp.ToExpression())
			.Where(d => d.CreationTime.ToString("yyyy-MM-dd") == DateTime.Now.ToString("yyyy-MM-dd"))
			.CountAsync();
		var setting = _systemSettingCacheManager.GetSetting(SettingConstants.RepeatableEventNum);
		return count >= int.Parse(setting?.SettingValue[0] ?? "0");
	}

    #endregion

    #region 工单待办

    /// <summary>
    /// 查询待办工单
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("waited")]
    public async Task<PagedDto<OrderWaitedDto>> QueryWaited([FromQuery] PagedRequest dto)
    {
        if (dto.PageSize > 100)
            dto.PageSize = 100;

        var (total, items) = await _orderRepository.Queryable()
            .OrderBy(d => d.ExpiredTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);

        var dtos = _mapper.Map<IReadOnlyList<OrderWaitedDto>>(items);

        //calc expired description
        var now = DateTime.Now;
        foreach (var waitedDto in dtos)
        {
            var ts = waitedDto.ExpiredTime - now;
            if (ts.Value.TotalDays <= 0)
            {
                //已超期
                waitedDto.ExpiredDescription = $"已超期{Math.Abs(ts.Value.TotalDays):F1}天";
            }
            else
            {
                //未超期
                waitedDto.ExpiredDescription = $"{ts.Value.TotalDays:F1}天后超期";
            }
        }

        return new PagedDto<OrderWaitedDto>(total, dtos);
    }

    #endregion

    #region  市民信息

    /// <summary>
    /// 新增市民信息
    /// </summary>
    /// <param name="dtos"></param>
    /// <returns></returns>
    [Permission(EPermission.AddCitizen)]
    [HttpPost("citizen")]
    public async Task Add([FromBody] CitizenAddDto dto)
    {
        var citizen = await _citizenRepository.CountAsync(x => x.PhoneNumber == dto.PhoneNumber, HttpContext.RequestAborted);
        if (citizen > 0)
            throw UserFriendlyException.SameMessage("市民联系电话信息重复");
        await _citizenRepository.AddAsync(dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 删除市民信息
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.DeleteCitizen)]
    [HttpDelete("citizen")]
    public async Task Delete([FromBody] CitizenDeleteDto dto)
    {
        await _citizenRepository.RemoveAsync(x => x.Id == dto.Id);
    }

    /// <summary>
    /// 更新市民信息
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.UpdateCitizen)]
    [HttpPut("citizen")]
    public async Task Update([FromBody] CitizenUpdateDto dto)
    {
        var citizen = await _citizenRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
        if (citizen is null)
            throw UserFriendlyException.SameMessage("无效市民信息");
        _mapper.Map(dto, citizen);
        citizen.LastModificationName = _sessionContext.UserName;
        await _citizenRepository.UpdateAsync(citizen, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 获取市民信息列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.CitizenList)]
    [HttpGet("citizen/list")]
    public async Task<PagedDto<CitizenDto>> List([FromQuery] CitizenListDto dto)
    {
        var (total, items) = await _citizenRepository.Queryable()
            .OrderByDescending(x => x.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
        return new PagedDto<CitizenDto>(total, _mapper.Map<IReadOnlyList<CitizenDto>>(items));
    }

    /// <summary>
    /// 获取市民信息
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.CitizenEntity)]
    [HttpGet("citizen/{id}")]
    public async Task<Citizen> CitizenEntity(string id)
    {
        return await _citizenRepository.Queryable()
            .Includes(x => x.labelDetails)
            .FirstAsync(x => x.Id == id);
    }

    /// <summary>
    /// 获取市民信息
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("citizen_phone/{phone}")]
    public async Task<object> Citizen(string phone)
    {
        //市民基本信息
        var citizen = await _citizenRepository.Queryable()
            .Includes(x => x.labelDetails)
            .FirstAsync(x => x.PhoneNumber == phone);
        //工单历史 
        var oders = await _orderRepository.Queryable().Where(x => x.Contact == phone).OrderBy(x => x.CreationTime, OrderByType.Desc).ToListAsync();
        var allOrderNum = oders.Count;
        var endOrderNum = oders.Count(x => x.Status == EOrderStatus.Published || x.Status == EOrderStatus.Visited || x.Status == EOrderStatus.Filed);
        var handOrderNum = oders.Count(x => x.Status == EOrderStatus.Handling || x.Status == EOrderStatus.Countersigning);
        var DissatisfactionNum = await _orderVisitedDetailRepository.Queryable()
            .Includes(x => x.OrderVisit)
            .Where(x => SqlFunc.JsonField(x.OrgProcessingResults, "Name") == "不满意" || SqlFunc.JsonField(x.OrgProcessingResults, "Name") == "非常不满意")
            .Distinct().Select(s => new { s.OrderVisit.OrderId }).CountAsync();
        //来电历史
        //TODO 等待通讯对接完成 还缺少 上次来电时间 
        //关注诉求
        var hotspotNames = string.Join(",", oders.Select(x => x.HotspotName).Distinct().Take(5).ToList());
        var rsp = new
        {
            Citizen = citizen,
            LastCallTime = DateTime.Now,
            Order = new { allOrderNum = allOrderNum, endOrderNum = endOrderNum, handOrderNum = handOrderNum, DissatisfactionNum = DissatisfactionNum },
            CallHistory = new { AllCallNum = 0, ConnectNum = 0, CallBackNum = 0 },
            HotspotNames = hotspotNames,
        };
        return rsp;
    }


    /// <summary>
    /// 新增市民标签信息
    /// </summary>
    /// <param name="dtos"></param>
    /// <returns></returns>
    [HttpPost("citizen_label")]
    public async Task Add([FromBody] LabelDetailAddDto dto)
    {
        var label = await _labelDetailRepository.CountAsync(x => x.CitizenId == dto.CitizenId && x.Label == dto.Label, HttpContext.RequestAborted);
        if (label > 0)
            throw UserFriendlyException.SameMessage("市民联系标签信息重复");
        await _citizenRepository.LabelAddAsync(dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 删除市民标签信息
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpDelete("citizen_label")]
    public async Task Delete([FromBody] LabelDetailDeleteDto dto)
    {
        var label = await _labelDetailRepository.GetAsync(x => x.Id == dto.Id, HttpContext.RequestAborted);
        if (label == null || (label.CreatorName != _sessionContext.UserName))
            throw UserFriendlyException.SameMessage("市民联系标签信息错误");
        await _citizenRepository.LabelDeleteAsync(label, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 获取市民标签信息列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("citizen_label/list")]
    public async Task<PagedDto<LabelDetailDto>> List([FromQuery] CitizenQueryDto dto)
    {
        var (total, items) = await _labelDetailRepository.Queryable()
            .Includes(x => x.Citizen)
            .WhereIF(!string.IsNullOrEmpty(dto.Label), x => x.Label.Contains(dto.Label!))
            .WhereIF(!string.IsNullOrEmpty(dto.CreatorName), x => x.CreatorName != null && x.CreatorName.Contains(dto.CreatorName!))
            .Where(x => x.CitizenId == dto.CitizenId)
            .OrderByDescending(x => x.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
        return new PagedDto<LabelDetailDto>(total, _mapper.Map<IReadOnlyList<LabelDetailDto>>(items));
    }
    #endregion

    #region 重复性事件

    /// <summary>
    /// 新增重复性事件
    /// </summary>
    /// <param name="dtos"></param>
    /// <returns></returns>
    [Permission(EPermission.AddRepeatableEvent)]
    [HttpPost("repeatable_event")]
    public async Task Add([FromBody] RepeatableEventAddDto dto)
    {
        var repeatable = _mapper.Map<RepeatableEvent>(dto);
        var repeatableId = await _repeatableEventRepository.AddAsync(repeatable, HttpContext.RequestAborted);
        List<RepeatableEventDetail> detail;
        if (!string.IsNullOrEmpty(repeatableId) && dto.Details.Any())
            dto.Details.ForEach(x => x.RepeatableId = repeatableId);
        detail = _mapper.Map<List<RepeatableEventDetail>>(dto.Details);
        if (detail.Any())
            await _repeatableEventDetailRepository.AddRangeAsync(detail, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 删除重复性事件
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.DeleteRepeatableEvent)]
    [HttpDelete("repeatable_event")]
    public async Task Delete([FromBody] RepeatableEventDeleteDto dto)
    {
        await _repeatableEventRepository.RemoveAsync(x => x.Id == dto.Id);
        await _repeatableEventDetailRepository.RemoveAsync(x => x.RepeatableId == dto.Id);
    }

	/// <summary>
	/// 删除重复性事件明细
	/// </summary>
	/// <param name="dto"></param>
	/// <returns></returns>
	[Permission(EPermission.DeleteRepeatableEventDetail)]
	[HttpDelete("repeatable_event_detail/{id}")]
    public async Task Delete([FromBody] string id  )
    {
	    await _repeatableEventDetailRepository.RemoveAsync(x => x.Id == id);
    }

	/// <summary>
	/// 更新重复性事件
	/// </summary>
	/// <param name="dto"></param>
	/// <returns></returns>
	[Permission(EPermission.UpdateRepeatableEvent)]
    [HttpPut("repeatable_event")]
    public async Task Update([FromBody] RepeatableEventUpdateDto dto)
    {
        var repeatable = await _repeatableEventRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
        if (repeatable is null)
            throw UserFriendlyException.SameMessage("无效重复性事件");
        _mapper.Map(dto, repeatable);
        repeatable.LastModificationName = _sessionContext.UserName;
        await _repeatableEventRepository.UpdateAsync(repeatable, HttpContext.RequestAborted);
        List<RepeatableEventDetail> detail;
        if (dto.Details.Any())
            dto.Details.ForEach(x => x.RepeatableId = dto.Id);
        await _repeatableEventDetailRepository.DeleteAsync(dto.Id, HttpContext.RequestAborted);
        detail = _mapper.Map<List<RepeatableEventDetail>>(dto.Details);
        if (detail.Any())
            await _repeatableEventDetailRepository.AddRangeAsync(detail, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 获取重复性事件列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Permission(EPermission.RepeatableEventList)]
    [HttpGet("repeatable_event/list")]
    public async Task<PagedDto<RepeatableEventDto>> List([FromQuery] RepeatableEventListDto dto)
    {
        var (total, items) = await _repeatableEventRepository.Queryable()
            .Includes(x => x.Details)
            .Includes(x => x.Details, y => y.Order)
            .WhereIF(!string.IsNullOrEmpty(dto.Keyword), d => d.Title.Contains(dto.Keyword!) || (d.KeyWords != null && d.KeyWords.Contains(dto.Keyword!)))
            .WhereIF(dto.CreationTimeStart.HasValue, d => d.CreationTime >= dto.CreationTimeStart)
            .WhereIF(dto.CreationTimeEnd.HasValue, d => d.CreationTime <= dto.CreationTimeEnd)
            .WhereIF(!string.IsNullOrEmpty(dto.Code), x => x.Code != null && x.Code.Contains(dto.Code!))
            .WhereIF(!string.IsNullOrEmpty(dto.Title), x => x.Title.Contains(dto.Title!))
            .WhereIF(!string.IsNullOrEmpty(dto.KeyWords), x => x.KeyWords != null && x.KeyWords.Contains(dto.KeyWords!))
            .OrderByDescending(x => x.CreationTime)
            .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
        return new PagedDto<RepeatableEventDto>(total, _mapper.Map<IReadOnlyList<RepeatableEventDto>>(items));
    }

    /// <summary>
    /// 获取重复性事件
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [Permission(EPermission.RepeatableEventEntity)]
    [HttpGet("repeatable_event")]
    public async Task<RepeatableEvent> CitizenEntity([FromQuery] RepeatableEventEntityDto dto)
    {
        return await _repeatableEventRepository.Queryable()
            .Includes(x => x.Details.WhereIF(!string.IsNullOrEmpty(dto.Keyword), x => x.Order.Title.Contains(dto.Keyword!)).ToList())
            .Includes(x => x.Details, y => y.Order)
            .FirstAsync(x => x.Id == dto.Id);
    }
	#endregion

	#region 工单词库
	/// <summary>
	/// 新增工单词库
	/// </summary>
	/// <param name="dtos"></param>
	/// <returns></returns>
	[Permission(EPermission.AddOrderWord)]
	[HttpPost("order_word")]
	public async Task Add([FromBody] OrderWordAddDto dto)
	{
		var word = _mapper.Map<OrderWord>(dto);
		await _orderWrodRepository.AddAsync(word, HttpContext.RequestAborted);
	}

	/// <summary>
	/// 删除工单词库
	/// </summary>
	/// <param name="dto"></param>
	/// <returns></returns>
	[Permission(EPermission.DeleteOrderWord)]
	[HttpDelete("order_word")]
	public async Task Delete([FromBody] OrderWordDeleteDto dto)
	{
        await _orderRepository.RemoveOrderWrodBatchAsync(dto.Ids, HttpContext.RequestAborted);
	}

	/// <summary>
	/// 更新工单词库
	/// </summary>
	/// <param name="dto"></param>
	/// <returns></returns>
	[Permission(EPermission.UpdateOrderWord)]
	[HttpPut("order_word")]
	public async Task Update([FromBody] OrderWordUpdateDto dto)
	{
		var word = await _orderWrodRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
		if (word is null)
			throw UserFriendlyException.SameMessage("无效工单词库");
		_mapper.Map(dto, word);
		word.LastModificationName = _sessionContext.UserName;
		await _orderWrodRepository.UpdateAsync(word, HttpContext.RequestAborted);
	}

	/// <summary>
	/// 获取工单词库列表
	/// </summary>
	/// <param name="dto"></param>
	/// <returns></returns>
	[Permission(EPermission.OrderWordList)]
	[HttpGet("order_word/list")]
	public async Task<PagedDto<OrderWordDto>> List([FromQuery] OrderWordListDto dto)
	{
		var (total, items) = await _orderWrodRepository.Queryable()
			.WhereIF(!string.IsNullOrEmpty(dto.Tag), x => x.Tag == dto.Tag!)
			.WhereIF(!string.IsNullOrEmpty(dto.Classify), x => x.Classify.Contains(dto.Classify!))
			.WhereIF(!string.IsNullOrEmpty(dto.Synonym), x => x.Synonym != null && x.Synonym.Contains(dto.Synonym!))
			.OrderByDescending(x => x.CreationTime)
			.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
		return new PagedDto<OrderWordDto>(total, _mapper.Map<IReadOnlyList<OrderWordDto>>(items));
	}

	/// <summary>
	/// 获取工单词库
	/// </summary>
	/// <param name="id"></param>
	/// <returns></returns>
	[HttpGet("order_word/{id}")]
	public async Task<OrderWord> OrderWordEntity(string id)
	{
		return await _orderWrodRepository.Queryable()
			.FirstAsync(x => x.Id == id);
	}

	/// <summary>
	/// 获取工单词库基本信息
	/// </summary>
	/// <returns></returns>
	[HttpGet("order_word/base")]
	public async Task<object> Base()
	{
		var rsp = new
		{
			OrderWordClassify = _sysDicDataCacheManager.GetSysDicDataCache(SysDicTypeConsts.OrderWordClassify),
		};
		return rsp;
	}
	#endregion

	#region 工单观察
	/// <summary>
	/// 新增工单观察
	/// </summary>
	/// <param name="dtos"></param>
	/// <returns></returns>
	[Permission(EPermission.AddOrderObserve)]
	[HttpPost("order_observe")]
	public async Task Add([FromBody] OrderObserveAddDto dto)
	{
		var observe = _mapper.Map<OrderObserve>(dto);
		await _orderObserveRepository.AddAsync(observe, HttpContext.RequestAborted);
	}

	/// <summary>
	/// 删除工单观察
	/// </summary>
	/// <param name="dto"></param>
	/// <returns></returns>
	[Permission(EPermission.DeleteOrderObserve)]
	[HttpDelete("order_observe")]
	public async Task Delete([FromBody] OrderObserveDeleteDto dto)
	{
		await _orderRepository.RemoveOrderObserveBatchAsync(dto.Ids, HttpContext.RequestAborted);
	}

	/// <summary>
	/// 更新工单观察
	/// </summary>
	/// <param name="dto"></param>
	/// <returns></returns>
	[Permission(EPermission.UpdateOrderObserve)]
	[HttpPut("order_observe")]
	public async Task Update([FromBody] OrderObserveUpdateDto dto)
	{
		var word = await _orderObserveRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
		if (word is null)
			throw UserFriendlyException.SameMessage("无效工单观察");
		_mapper.Map(dto, word);
		await _orderObserveRepository.UpdateAsync(word, HttpContext.RequestAborted);
	}

	/// <summary>
	/// 获取工单观察列表
	/// </summary>
	/// <param name="dto"></param>
	/// <returns></returns>
	[Permission(EPermission.OrderObserveList)]
	[HttpGet("order_observe/list")]
	public async Task<PagedDto<OrderObserveDto>> List([FromQuery] OrderObserveListDto dto)
	{
		var (total, items) = await _orderObserveRepository.Queryable()
            .Includes(x=>x.Order)
			.WhereIF(dto.IsProvince.HasValue, x => x.Order.IsProvince == dto.IsProvince)
			.WhereIF(!string.IsNullOrEmpty(dto.Title), x => x.Order.Title.Contains(dto.Title!))
			.WhereIF(!string.IsNullOrEmpty(dto.No), x =>  x.Order.No.Contains(dto.No!))
			.OrderByDescending(x => x.CreationTime)
			.ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
		return new PagedDto<OrderObserveDto>(total, _mapper.Map<IReadOnlyList<OrderObserveDto>>(items));
	}

	/// <summary>
	/// 获取工单观察
	/// </summary>
	/// <param name="id"></param>
	/// <returns></returns>
	[HttpGet("order_observe/{id}")]
	public async Task<OrderObserve> OrderObserveEntity(string id)
	{
		return await _orderObserveRepository.Queryable()
			.FirstAsync(x => x.Id == id);
	}
	#endregion

}