hotline/src/Hotline/Orders/OrderDomainService.cs

using DotNetCore.CAP;
using Hotline.FlowEngine;
using Hotline.FlowEngine.Workflows;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Enums.Order;
using Hotline.Share.Mq;
using MapsterMapper;
using Microsoft.Extensions.Logging;
using System.Threading;
using Hotline.Share.Consts;
using SqlSugar;
using XF.Domain.Authentications;
using XF.Domain.Cache;
using XF.Domain.Dependency;
using XF.Domain.Entities;
using XF.Domain.Exceptions;
using XF.Domain.Extensions;
using XF.Domain.Repository;
using Hotline.CallCenter.Calls;
using Hotline.Share.Dtos.CallCenter;

namespace Hotline.Orders;

public class OrderDomainService : IOrderDomainService, IScopeDependency
{
    private const string OrderNoPrefix = "OrderNo:";
    private readonly IOrderRepository _orderRepository;
    private readonly IRepository<OrderRedo> _orderRedoRepository;
    private readonly IRepository<OrderPublish> _orderPublishRepository;
    private readonly IRepository<OrderVisit> _orderVisitRepository;
    private readonly ITypedCache<CacheOrderNO> _cacheOrderNo;
    private readonly ISessionContext _sessionContext;
    private readonly ICapPublisher _capPublisher;
    private readonly IMapper _mapper;
    private readonly ILogger<OrderDomainService> _logger;
    private readonly IRepository<WexCallRecord> _wexCallRecordRepository;

    public OrderDomainService(
        IOrderRepository orderRepository,
        IRepository<OrderRedo> orderRedoRepository,
        IRepository<OrderPublish> orderPublishRepository,
        IRepository<OrderVisit> orderVisitRepository,
        ITypedCache<CacheOrderNO> cacheOrderNo,
        ISessionContext sessionContext,
        ICapPublisher capPublisher,
        IMapper mapper,
        ILogger<OrderDomainService> logger,
        IRepository<WexCallRecord> wexCallRecordRepository)
    {
        _orderRepository = orderRepository;
        _orderRedoRepository = orderRedoRepository;
        _orderPublishRepository = orderPublishRepository;
        _orderVisitRepository = orderVisitRepository;
        _cacheOrderNo = cacheOrderNo;
        _sessionContext = sessionContext;
        _capPublisher = capPublisher;
        _mapper = mapper;
        _logger = logger;
        _wexCallRecordRepository = wexCallRecordRepository;
    }

    public async Task<Order> GetOrderAsync(string? orderId, CancellationToken cancellationToken)
    {
        if (string.IsNullOrEmpty(orderId))
            throw UserFriendlyException.SameMessage("无效工单编号");
        var order = await _orderRepository.Queryable()
            .Includes(d => d.Hotspot)
            .Includes(d => d.Acceptor)
            .FirstAsync(d => d.Id == orderId, cancellationToken);

        if (order == null)
            throw new UserFriendlyException($"无效工单编号, orderId: {orderId}", "无效工单编号");
        return order;
    }

    public async Task<string> AddAsync(Order order, CancellationToken cancellationToken)
    {
        if (order.OrderType == EOrderType.MarketSupervisionBy12315 && order.AcceptTypeCode == AcceptTypeConst.TouSu && order.OrderComplain == null)
            throw UserFriendlyException.SameMessage("非法投诉参数");
        if (order.OrderType == EOrderType.MarketSupervisionBy12315 && order.AcceptTypeCode == AcceptTypeConst.JuBao && order.OrderReport == null)
            throw UserFriendlyException.SameMessage("非法举报参数");

        order.Init(_sessionContext.RequiredUserId, _sessionContext.UserName, _sessionContext.StaffNo);
        order.No = GenerateNewOrderNo();

        if (order.SourceChannelCode == OrderDefaults.SourceChannel.DianHua && !string.IsNullOrEmpty(order.CallId))
        {
            var callRecord = await _wexCallRecordRepository.GetAsync(x => x.CallId == order.CallId,cancellationToken);
            if (callRecord != null)
            {
                await _capPublisher.PublishAsync(EventNames.HotlineCallConnectWithOrder, new CallConnectOrderDto
                {
                    Order = _mapper.Map<OrderDto>(order),
                    CallRecord = _mapper.Map<CallRecordDto>(callRecord)
                }, cancellationToken: cancellationToken);
            }
        }
        return await _orderRepository.AddOrderNavAsync(order, cancellationToken);
    }

    /// <summary>
    /// 归档
    /// </summary>
    public async Task FileAsync(string? orderId, CancellationToken cancellationToken)
    {
        var order = await GetOrderAsync(orderId, cancellationToken);
        order.Filed();
        await _orderRepository.UpdateAsync(order, cancellationToken);
    }

    /// <summary>
    /// 撤回或跳转前处理数据及校验
    /// <remarks>
    ///工单撤回时需校验工单当前是否存在待发布记录、待回访记录，若存在需删除对应记录（跳转同理）
    ///工单撤回时需校验工单是否存在甄别中记录，若存在不允许撤回当前工单（跳转同理）
    /// </remarks>
    /// </summary>
    public async Task ReadyToRecallAsync(string orderId, CancellationToken cancellationToken)
    {
        var order = await _orderRepository.Queryable()
            .Includes(d => d.OrderPublish)
            .Includes(d => d.OrderVisits.Where(d => d.VisitState == EVisitState.WaitForVisit))
            .Includes(d => d.OrderScreens)
            .FirstAsync(d => d.Id == orderId, cancellationToken);

        if (order.OrderScreens.Any())
            throw UserFriendlyException.SameMessage("已甄别工单无法撤回或跳转");

        if (order.OrderPublish is not null)
            await _orderPublishRepository.RemoveAsync(order.OrderPublish, cancellationToken: cancellationToken);

        if (order.OrderVisits.Any())
            await _orderVisitRepository.RemoveNav(order.OrderVisits)
                .Include(d => d.OrderVisitDetails)
                .ExecuteCommandAsync();
    }

    public Task<string> AddOrderRedoAsync(OrderRedo orderRedo, CancellationToken cancellationToken) =>
        _orderRedoRepository.AddAsync(orderRedo, cancellationToken);

    public Task RemoveOrderRedoAsync(string id, CancellationToken cancellationToken) =>
        _orderRedoRepository.RemoveAsync(id, cancellationToken: cancellationToken);

    public Task UpdateOrderRedoAsync(OrderRedo orderRedo, CancellationToken cancellationToken) =>
        _orderRedoRepository.UpdateAsync(orderRedo, cancellationToken);

    #region private

    private async Task<Order> GetOrderByFlowIdAsync(string workflowId, CancellationToken cancellationToken)
    {
        if (string.IsNullOrEmpty(workflowId))
            throw UserFriendlyException.SameMessage("无效流程编号");
        var order = await _orderRepository.Queryable()
            .Includes(d => d.Hotspot)
            .Includes(d => d.Acceptor)
            .FirstAsync(d => d.WorkflowId == workflowId);
        if (order == null)
            throw new UserFriendlyException($"无效流程编号, workflowId: {workflowId}", "无效流程编号");
        return order;
    }

    //private void CheckOrderIfFiled(Order order)
    //{
    //    if (order.Status is EOrderStatus.Filed)
    //        throw UserFriendlyException.SameMessage("工单已归档");
    //}

    private string GenerateNewOrderNo()
    {
        var today = DateTime.Today;
        var cacheKey = $"{OrderNoPrefix}{today:yyyyMMdd}";
        var cacheOrderNo = _cacheOrderNo.GetOrSet(cacheKey, f =>
        {
            var todayOrderCount = _orderRepository.Queryable(true)
                .CountAsync(d => d.CreationTime.Date == today.Date)
                .GetAwaiter()
                .GetResult();
            return new CacheOrderNO { TotalCount = todayOrderCount };
        }, TimeSpan.FromDays(1));
        cacheOrderNo!.TotalCount += 1;
        var no = GenerateOrderNo(today, cacheOrderNo.TotalCount);
        _cacheOrderNo.Set(cacheKey, cacheOrderNo);
        return no;
    }

    private string GenerateOrderNo(DateTime today, int count)
    {
        return $"{today:yyyyMMdd}{count.ToString("000000")}";
    }

    #endregion
}

public class CacheOrderNO
{
    public int TotalCount { get; set; }
}