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 XF.Domain.Authentications;
using XF.Domain.Cache;
using XF.Domain.Dependency;
using XF.Domain.Entities;
using XF.Domain.Exceptions;
using XF.Domain.Extensions;

namespace Hotline.Orders;

public class OrderDomainService : IOrderDomainService, IScopeDependency
{
    private const string OrderNoPrefix = "OrderNo:";
    private readonly IOrderRepository _orderRepository;
    private readonly IOrderRedoRepository _orderRedoRepository;
    private readonly ITypedCache<CacheOrderNO> _cacheOrderNo;
    private readonly ISessionContext _sessionContext;
    private readonly ICapPublisher _capPublisher;
    private readonly IMapper _mapper;
    private readonly ILogger<OrderDomainService> _logger;

    public OrderDomainService(
        IOrderRepository orderRepository,
        IOrderRedoRepository orderRedoRepository,
        ITypedCache<CacheOrderNO> cacheOrderNo,
        ISessionContext sessionContext,
        ICapPublisher capPublisher,
        IMapper mapper,
        ILogger<OrderDomainService> logger)
    {
        _orderRepository = orderRepository;
        _orderRedoRepository = orderRedoRepository;
        _cacheOrderNo = cacheOrderNo;
        _sessionContext = sessionContext;
        _capPublisher = capPublisher;
        _mapper = mapper;
        _logger = logger;
    }

    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.AcceptType == EAcceptType.Complain && order.OrderComplain == null)
            throw UserFriendlyException.SameMessage("非法投诉参数");
        if (order.OrderType == EOrderType.MarketSupervisionBy12315 && order.AcceptType == EAcceptType.Report && 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))
            await _capPublisher.PublishAsync(EventNames.HotlineCallConnectWithOrder, new CallConnectOrderDto
            {
                Order = _mapper.Map<OrderDto>(order),
                //todo calldto
            }, 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);
    }

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