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

using Hotline.Application.FlowEngine;
using Hotline.FlowEngine.Workflows;
using Hotline.Orders;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Settings;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.FlowEngine;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Enums.Order;
using Hotline.Share.Requests;
using MapsterMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using XF.Domain.Authentications;
using XF.Domain.Exceptions;
using XF.Domain.Extensions;
using XF.Utility.EnumExtensions;

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 IHotSpotTypeRepository _hotSpotTypeRepository;
    private readonly ISystemDomainService _systemDomainService;
    private readonly ISystemOrganizeRepository _organizeRepository;
    private readonly IMapper _mapper;

    public OrderController(
        IOrderDomainService orderDomainService,
        IOrderRepository orderRepository,
        IWorkflowApplication workflowApplication,
        IWorkflowDomainService workflowDomainService,
        IHotSpotTypeRepository hotSpotTypeRepository,
        ISystemDomainService systemDomainService,
        ISystemOrganizeRepository organizeRepository,
        IMapper mapper)
    {
        _orderDomainService = orderDomainService;
        _orderRepository = orderRepository;
        _workflowApplication = workflowApplication;
        _workflowDomainService = workflowDomainService;
        _hotSpotTypeRepository = hotSpotTypeRepository;
        _systemDomainService = systemDomainService;
        _organizeRepository = organizeRepository;
        _mapper = mapper;
    }

    /// <summary>
    /// 工单列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [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.Channel))
            .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(!string.IsNullOrEmpty(dto.NameOrNo), d => d.Employee.Name.Contains(dto.NameOrNo) || d.Employee.StaffNo.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(dto.PushType.HasValue, d => d.PushType == dto.PushType)
            .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))
            .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>
    [HttpGet("history")]
    public async Task<PagedDto<OrderDto>> Query([FromQuery] PagedRequest dto)
    {
        var (total, items) = await _orderRepository.Queryable()
            .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>
    [HttpGet("{id}")]
    public async Task<OrderDto> Get(string id)
    {
        var order = await _orderRepository.Queryable()
            .Includes(d => d.OrderComplain)
            .Includes(d => d.OrderReport)
            .FirstAsync(d => d.Id == id);
        if (!string.IsNullOrEmpty(order.WorkflowId))
            order.Workflow = await _workflowDomainService.GetWorkflowAsync(order.WorkflowId, withSupplements: true, cancellationToken: HttpContext.RequestAborted);

        return _mapper.Map<OrderDto>(order);
    }

    /// <summary>
    /// 新增工单
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost]
    public async Task<string> Add([FromBody] AddOrderDto dto)
    {
        var order = _mapper.Map<Order>(dto);
        return await _orderDomainService.AddAsync(order, HttpContext.RequestAborted);
    }

    [HttpDelete("{id}")]
    public async Task Remove(string id)
    {
        var order = await _orderRepository.GetAsync(id, HttpContext.RequestAborted);
        if (order == null) return;
        if (order.Status != EOrderStatus.Temporary)
            throw UserFriendlyException.SameMessage("非草稿工单不可删除");
        await _orderRepository.RemoveAsync(order);
    }

    /// <summary>
    /// 更新工单信息
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPut]
    public async Task Update([FromBody] UpdateOrderDto dto)
    {
        var order = await _orderRepository.GetAsync(dto.Id, HttpContext.RequestAborted);
        if (order == null)
            throw UserFriendlyException.SameMessage("无效工单编号");
        if (order.Status != EOrderStatus.Temporary)
            throw UserFriendlyException.SameMessage("非草稿工单不可编辑");
        await _orderRepository.UpdateAsync(order, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 开始流程
    /// </summary>
    /// <param name="id">工单id</param>
    /// <param name="dto">流程开启参数</param>
    /// <returns></returns>
    [HttpPost("{id}/startflow")]
    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.Temporary || !string.IsNullOrEmpty(order.WorkflowId))
            throw UserFriendlyException.SameMessage("工单已发起流程");
        var workflowId = await _workflowApplication.StartWorkflowAsync(dto, HttpContext.RequestAborted);
        order.StartFlow(workflowId);
        await _orderRepository.UpdateAsync(order, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 列表页面基础数据
    /// </summary>
    /// <returns></returns>
    [HttpGet("base-data")]
    public dynamic BaseData()
    {
        return new
        {
            AcceptTypeOptions = EnumExts.GetDescriptions<EAcceptType>(),
            ChannelOptions = EnumExts.GetDescriptions<EChannel>(),
            OrgsOptions = _organizeRepository.GetOrgJson(),
            EmergencyLevelOptions = EnumExts.GetDescriptions<EEmergencyLevel>(),
            PushTypeOptions = EnumExts.GetDescriptions<EPushType>(),
            OrderStatusOptions = EnumExts.GetDescriptions<EOrderStatus>(),
        };
    }

    /// <summary>
    /// 新增页面基础数据
    /// </summary>
    /// <returns></returns>
    [HttpGet("base-data-add")]
    public dynamic BaseDataAdd()
    {
        return new
        {
            ChannelOptions = EnumExts.GetDescriptions<EChannel>(),
            GenderOptions = EnumExts.GetDescriptions<EGender>(),
            IdentityTypeOptions = EnumExts.GetDescriptions<EIdentityType>(),
            LicenceTypeOptions = EnumExts.GetDescriptions<ELicenceType>(),
            AgeRangeOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.AgeRange),
            OrderTypeOptions = EnumExts.GetDescriptions<EOrderType>(),
            AcceptTypeOptions = EnumExts.GetDescriptions<EAcceptType>(),
            EmergencyLevelOptions = EnumExts.GetDescriptions<EEmergencyLevel>(),
            PushTypeOptions = EnumExts.GetDescriptions<EPushType>(),
        };
    }

    /// <summary>
    /// 扩展信息新增页面基础数据
    /// </summary>
    /// <returns></returns>
    [HttpGet("base-data-ext")]
    public dynamic BaseDataExtension()
    {
        return new
        {
            LicenceTypeOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.LicenceType),
            IdentityTypeOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.ProviderIdentityType),
            IdentityOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.Identity),
            NationalityOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.Nationality),
            NationOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.Nation),
            MarketTypeOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.MarketType),
            IndustryClassifyOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.IndustryClassify),
            BrandOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.Brand),
            ObjectClassifyOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.ObjectClassify),
            ComplainClassifyOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.ComplainClassify),
            SalesModeOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.SalesMode),
            ECommercePlatformOptions = _systemDomainService.GetSysDicDataByCode(SysDicTypeConsts.ECommercePlatform),
            ComplainTypeOptions = EnumExts.GetDescriptions<EComplainType>()
        };
    }


    /// <summary>
    /// 获取热点
    /// </summary>
    /// <param name="parentId">父级ID</param>
    /// <returns></returns>
    [HttpGet("hotspottype-list-parent")]
    public async Task<List<HotSpotType>> GetHotSpotType(string? parentId)
    {
        return await _hotSpotTypeRepository.Queryable().Where(x => x.ParentId == parentId).ToListAsync();
    }
}