hotline/src/Hotline/Orders/OrderDomainService.cs

using Hotline.FlowEngine;
using Hotline.Share.Enums.Order;
using Microsoft.Extensions.Logging;
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 ITypedCache<CacheOrderNO> _cacheOrderNo;
    private readonly ISessionContext _sessionContext;
    private readonly ILogger<OrderDomainService> _logger;

    public OrderDomainService(
        IOrderRepository orderRepository,
        ITypedCache<CacheOrderNO> cacheOrderNo,
        ISessionContext sessionContext,
        ILogger<OrderDomainService> logger)
    {
        _orderRepository = orderRepository;
        _cacheOrderNo = cacheOrderNo;
        _sessionContext = sessionContext;
        _logger = logger;
    }

    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);
        order.No = GenerateNewOrderNo();

        return await _orderRepository.AddOrderNavAsync(order, cancellationToken);
    }

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

    /// <summary>
    /// 接办工单（查看详情视为接办）
    /// </summary>
    public async Task AcceptAsync(string? orderId, CancellationToken cancellationToken)
    {
        var order = await GetOrderAsync(orderId, cancellationToken);
        CheckOrderIfFiled(order);
        order.Accept();
        await _orderRepository.UpdateAsync(order, cancellationToken);
    }

    /// <summary>
    /// 工单办理(每个节点都会触发)
    /// </summary>
    public async Task ManageFlowNextAsync(FlowAssignMode assignMode,
        bool isCountersignStart, bool isCountersignEnd,
        string? orderId, DateTime? currentStepTime, string? CurrentStepName, DateTime expiredTime,
        CancellationToken cancellationToken)
    {
        _logger.LogInformation($"{nameof(ManageFlowNextAsync)}");
        var order = await GetOrderAsync(orderId, cancellationToken);
        CheckOrderIfFiled(order);

        _logger.LogInformation($"{nameof(ManageFlowNextAsync)}, before: order.AssignUserIds: {string.Join(',', order.AssignUserIds)}, order.AssignOrgs: {string.Join(',', order.AssignOrgCodes)}");
        //更新指派信息
        order.Assign(assignMode.FlowAssignType, assignMode.Handlers);
        _logger.LogInformation($"{nameof(ManageFlowNextAsync)}, after: order.AssignUserIds: {string.Join(',', order.AssignUserIds)}, order.AssignOrgs: {string.Join(',', order.AssignOrgCodes)}");

        //更新流转信息
        order.ManageFlow(isCountersignStart, isCountersignEnd, currentStepTime, CurrentStepName, expiredTime);
        _logger.LogInformation($"更新流转信息 over, order.AssignUserIds: {string.Join(',', order.AssignUserIds)}");
        await _orderRepository.UpdateAsync(order, cancellationToken);
        _logger.LogInformation($"update db over, order.AssignUserIds: {string.Join(',', order.AssignUserIds)}");

        //todo push msg to next step handler
    }

    /// <summary>
    /// 工单最终办理（此完结流程并未结束）
    /// </summary>
    /// <remarks>
    /// 需求：工单实际办理部门办理完成视为工单最终办理完结，
    /// 实际办理部门指：1.第一个汇总节点的前一个非汇总节点代表的办理部门 2.汇总以后如果再次开启会签需将工单回退到未办理完结的状态重新等待下一个汇总节点
    /// </remarks>
    /// <returns></returns>
    public async Task FinalManageAsync(string? orderId, CancellationToken cancellationToken)
    {
        var order = await GetOrderAsync(orderId, cancellationToken);
        CheckOrderIfFiled(order);
        order.FinalManage();
        await _orderRepository.UpdateAsync(order, cancellationToken);
    }

    /// <summary>
    /// 取消最终办理（汇总以后又重新指派到非汇总汇总节点办理的场景）
    /// </summary>
    /// <returns></returns>
    public async Task RecallFinalManageAsync(string? orderId, CancellationToken cancellationToken)
    {
        var order = await GetOrderAsync(orderId, cancellationToken);
        CheckOrderIfFiled(order);
        order.RecallFinalManage();
        await _orderRepository.UpdateAsync(order, cancellationToken);
    }

    /// <summary>
    /// 工单办理流程流转到结束节点
    /// </summary>
    public async Task ManageFlowEndAsync(string? orderId, CancellationToken cancellationToken)
    {
        var order = await GetOrderAsync(orderId, cancellationToken);
        CheckOrderIfFiled(order);
        order.Filed();
        await _orderRepository.UpdateAsync(order, cancellationToken);
    }

    #region private

    private async Task<Order> GetOrderAsync(string? orderId, CancellationToken cancellationToken)
    {
        if (string.IsNullOrEmpty(orderId))
            throw UserFriendlyException.SameMessage("无效工单编号");
        var order = await _orderRepository.GetAsync(orderId, cancellationToken);
        if (order == null)
            throw new UserFriendlyException($"无效工单编号, orderId: {orderId}", "无效工单编号");
        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.GetOrAdd(cacheKey, f =>
        {
            var todayOrderCount = _orderRepository.Queryable(true)
                .CountAsync(d => d.CreationTime.Date == today.Date)
                .GetAwaiter()
                .GetResult();
            return new CacheOrderNO { TotalCount = todayOrderCount };
        }, ExpireMode.Absolute, TimeSpan.FromDays(1));
        cacheOrderNo.TotalCount += 1;
        var no = GenerateOrderNo(today, cacheOrderNo.TotalCount);
        _cacheOrderNo.Update(cacheKey, d => 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; }
}