hotline/src/Hotline.Api/Controllers/OrderApi/OrderComplementController.cs

using Hotline.Article;
using Hotline.FlowEngine.Workflows;
using Hotline.Orders;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.Article;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Enums.Article;
using Hotline.Tools;
using Hotline.Users;
using MapsterMapper;
using Microsoft.AspNetCore.Mvc;
using XF.Domain.Authentications;
using XF.Domain.Exceptions;
using XF.Domain.Repository;

namespace Hotline.Api.Controllers.OrderApi;

public class OrderComplementController : BaseController
{
    private readonly IOrderDomainService _orderDomainService;
    private readonly ISessionContext _sessionContext;
    private readonly IRepository<OrderComplement> _orderComplementRepository;
    private readonly IRepository<WorkflowStep> _workflowStepRepository;
    private readonly IRepository<User> _userRepository;
    private readonly ICircularRecordDomainService _circularRecordDomainService;
    private readonly IComplementOrderService _complementOrderService;
    private readonly IMapper _mapper;
    private readonly IRepository<OrderComplementCopy> _orderComplementCopyRepository;

    public OrderComplementController(IOrderDomainService orderDomainService,
       ISessionContext sessionContext,
       IRepository<OrderComplement> orderComplementRepository,
       IRepository<WorkflowStep> workflowStepRepository,
       IRepository<User> userRepository,
       ICircularRecordDomainService circularRecordDomainService,
       IComplementOrderService complementOrderService,
       IMapper mapper,
       IRepository<OrderComplementCopy> orderComplementCopyRepository)
    {
        _orderDomainService = orderDomainService;
        _sessionContext = sessionContext;
        _orderComplementRepository = orderComplementRepository;
        _workflowStepRepository = workflowStepRepository;
        _userRepository = userRepository;
        _circularRecordDomainService = circularRecordDomainService;
        _complementOrderService = complementOrderService;
        _mapper = mapper;
        _orderComplementCopyRepository = orderComplementCopyRepository;
    }

    /// <summary>
    /// 补充
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost]
    public async Task<string> Supplement([FromBody] AddOrderComplementDto dto)
    {
        return await _orderDomainService.AddOrderComplementAsync(dto, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 添加补充 
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost("add_order_complement")]
    public async Task AddOrderComplement([FromBody] AddComplementDto dto)
    {
        if (dto == null)
            throw UserFriendlyException.SameMessage("数据错误！");
        if (string.IsNullOrEmpty(dto.Opinion))
            throw UserFriendlyException.SameMessage("补充内容不能为空！");
        if (dto.Opinion.Length > 2000)
            throw UserFriendlyException.SameMessage("补充内容限制2000字！");
        var data = await _orderDomainService.GetOrderAsync(dto.OrderId, cancellationToken: HttpContext.RequestAborted);
        if (data == null)
            throw UserFriendlyException.SameMessage("工单查询失败！");

        OrderComplement complement = new OrderComplement()
        {
            OrderId = dto.OrderId,
            Opinion = dto.Opinion,
            SupplyName = _sessionContext.UserName,
            SupplyOrg = _sessionContext.OrgName,
            SupplyTime = DateTime.Now,
            No = data.No,
            IsProComplement = false
        };

        var id = await _orderComplementRepository.AddAsync(complement, HttpContext.RequestAborted);
        if (!string.IsNullOrEmpty(id))
        {
            #region 处理推送消息

            //获取当前办理节点数据
            var work = await _workflowStepRepository.GetAsync(p => p.Id == data.ActualHandleStepId, HttpContext.RequestAborted);
            if (work != null)
            {
                //获取办理指定类型
                var workflowStepHandler = work.GetWorkflowStepHandler();
                if (workflowStepHandler != null)
                {
                    AddCircularDto circularDto = new AddCircularDto()
                    {
                        Title = "工单补充",
                        Content = "工单" + data.No + "有补充内容，请注意查收！",
                        CircularTypeId = "6",
                        CircularTypeName = "工单补充",
                        IsMustRead = true,
                        SourceOrgId = _sessionContext.RequiredOrgId,
                        SourceOrgName = _sessionContext.OrgName,
                        CircularType = ECircularType.Person
                    };

                    List<CircularReadGroupDto> users = [];
                    if (!string.IsNullOrEmpty(workflowStepHandler.UserId)) //指定用户
                    {
                        users.Add(new CircularReadGroupDto()
                        {
                            UserId = workflowStepHandler.UserId,
                            UserName = workflowStepHandler.Username
                        });
                    }
                    else if (!string.IsNullOrEmpty(workflowStepHandler.RoleId)) //指定角色
                    {
                        //查询指定角色下面所有的用户
                        var userlist = await _userRepository.Queryable().Where(x =>
                                x.OrgId == workflowStepHandler.OrgId && x.Roles.Any(d => workflowStepHandler.RoleId.Contains(d.Id)))
                            .Select(d => new CircularReadGroupDto
                            {
                                UserId = d.Id,
                                UserName = d.Name
                            }).ToListAsync();
                        users.AddRange(userlist);
                    }
                    else if (!string.IsNullOrEmpty(workflowStepHandler.OrgId)) //指定部门
                    {
                        users.Add(new CircularReadGroupDto()
                        {
                            OrgId = workflowStepHandler.OrgId,
                            OrgName = workflowStepHandler.OrgName
                        });
                        circularDto.CircularType = ECircularType.Org;
                    }

                    if (users != null && users.Count > 0)
                    {
                        circularDto.CircularReadGroups = users;
                        //调用推送消息通用接口
                        await _circularRecordDomainService.AddCircularMessage(circularDto, HttpContext.RequestAborted);
                    }
                }
            }

            #endregion
        }
    }

    /// <summary>
    /// 修改补充
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost("update_order_complement")]
    public async Task UpdateOrderComplement([FromBody] UpdateComplementDto dto)
    {
        if (dto == null)
            throw UserFriendlyException.SameMessage("数据错误！");
        if (string.IsNullOrEmpty(dto.Opinion))
            throw UserFriendlyException.SameMessage("补充内容不能为空！");
        if (dto.Opinion.Length > 2000)
            throw UserFriendlyException.SameMessage("补充内容限制2000字！");
        var data = await _orderComplementRepository.GetAsync(p => p.Id == dto.Id, cancellationToken: HttpContext.RequestAborted);
        if (data == null)
            throw UserFriendlyException.SameMessage("补充查询失败！");
        //修改记录
        var dataCopy = new OrderComplementCopy
        {
            OperationType = "0",
            OrderId = data.OrderId,
            Opinion = data.Opinion,
            SupplyName = data.SupplyName,
            SupplyOrg = data.SupplyOrg,
            SupplyTime = data.SupplyTime,
            DsBisId = data.DsBisId,
            No = data.No,
            IsProComplement = data.IsProComplement,
            FileJson = data.FileJson,
            ComplementId = data.Id
        };

        await _orderComplementCopyRepository.AddAsync(dataCopy, HttpContext.RequestAborted);
        //修改
        data.Opinion = dto.Opinion;
        await _orderComplementRepository.UpdateAsync(data, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 删除补充
    /// </summary>
    /// <returns></returns>
    [HttpGet("delete_order_complement/{id}")]
    public async Task DeleteOrderComplement(string id)
    {
        var data = await _orderComplementRepository.GetAsync(p => p.Id == id, cancellationToken: HttpContext.RequestAborted);
        if (data == null)
            throw UserFriendlyException.SameMessage("补充查询失败！");

        //修改记录
        var dataCopy = new OrderComplementCopy
        {
            OperationType = "1",
            OrderId = data.OrderId,
            Opinion = data.Opinion,
            SupplyName = data.SupplyName,
            SupplyOrg = data.SupplyOrg,
            SupplyTime = data.SupplyTime,
            DsBisId = data.DsBisId,
            No = data.No,
            IsProComplement = data.IsProComplement,
            FileJson = data.FileJson,
            ComplementId = data.Id
        };

        await _orderComplementCopyRepository.AddAsync(dataCopy, HttpContext.RequestAborted);

        //删除
        await _orderComplementRepository.RemoveAsync(p => p.Id == id, false, HttpContext.RequestAborted);
    }

    /// <summary>
    /// 查询补充详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("get_complement_order_info/{id}")]
    public async Task<ComplementOrderDto> GetComplementOrderInfo(string id)
    {
        var data = await _orderComplementRepository.GetAsync(p => p.Id == id, cancellationToken: HttpContext.RequestAborted);
        if (data == null)
            throw UserFriendlyException.SameMessage("补充查询失败！");

        return _mapper.Map<ComplementOrderDto>(data);
    }

    /// <summary>
    /// 补充查询
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("get-order-complement-list")]
    public async Task<PagedDto<ComplementOrderDto>> GetOrderComplementList([FromQuery] ComplementOrderRequestDto dto)
    {
        var (total, items) = await _complementOrderService.GetOrderComplementList(dto)
              .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
        return new PagedDto<ComplementOrderDto>(total, _mapper.Map<IReadOnlyList<ComplementOrderDto>>(items));
    }

    /// <summary>
    /// 补充查询列表导出
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>

    [HttpPost("get-order-complement-list/export")]
    public async Task<FileStreamResult> OrderTerminateListExport([FromBody] ExportExcelDto<ComplementOrderRequestDto> dto)
    {
        var query = _complementOrderService.GetOrderComplementList(dto.QueryDto);
        List<OrderComplement> data;
        if (dto.IsExportAll)
        {
            data = await query.ToListAsync(HttpContext.RequestAborted);
        }
        else
        {
            var (_, items) = await query.ToPagedListAsync(dto.QueryDto, HttpContext.RequestAborted);
            data = items;
        }

        var dataDtos = _mapper.Map<ICollection<ComplementOrderDto>>(data);

        dynamic? dynamicClass = DynamicClassHelper.CreateDynamicClass<ComplementOrderDto>(dto.ColumnInfos);

        var dtos = dataDtos
            .Select(stu => _mapper.Map(stu, typeof(ComplementOrderDto), dynamicClass))
            .Cast<object>()
            .ToList();

        var stream = ExcelHelper.CreateStream(dtos);

        return ExcelStreamResult(stream, "补充查询列表");
    }

    /// <summary>
    /// 补充操作记录查询
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpGet("get-order-complement-copy-list")]
    public async Task<PagedDto<ComplementOrderCopDto>> GetOrderComplementCopyList([FromQuery] ComplementOrderCopyRequestDto dto)
    {
        var (total, items) = await _complementOrderService.GetOrderComplementCopyList(dto)
              .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
        return new PagedDto<ComplementOrderCopDto>(total, _mapper.Map<IReadOnlyList<ComplementOrderCopDto>>(items));
    }

    /// <summary>
    /// 补充操作记录列表导出
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpPost("get-order-complement-copy-list/export")]
    public async Task<FileStreamResult> OrderTerminateCopyListExport([FromBody] ExportExcelDto<ComplementOrderCopyRequestDto> dto)
    {
        var query = _complementOrderService.GetOrderComplementCopyList(dto.QueryDto);
        List<OrderComplementCopy> data;
        if (dto.IsExportAll)
        {
            data = await query.ToListAsync(HttpContext.RequestAborted);
        }
        else
        {
            var (_, items) = await query.ToPagedListAsync(dto.QueryDto, HttpContext.RequestAborted);
            data = items;
        }

        var dataDtos = _mapper.Map<ICollection<ComplementOrderCopDto>>(data);

        dynamic? dynamicClass = DynamicClassHelper.CreateDynamicClass<ComplementOrderCopDto>(dto.ColumnInfos);

        var dtos = dataDtos
            .Select(stu => _mapper.Map(stu, typeof(ComplementOrderCopDto), dynamicClass))
            .Cast<object>()
            .ToList();

        var stream = ExcelHelper.CreateStream(dtos);

        return ExcelStreamResult(stream, " 补充操作记录列表");
    }

    /// <summary>
    /// 查看记录删除
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("get-complement-order-copy-delete/{id}")]
    public async Task<ComplementOrderCopyDetailDto> GetComplementOrderCopyDelete(string id)
    {
        ComplementOrderCopyDetailDto detailDto = new ComplementOrderCopyDetailDto();
        var data = await _orderComplementCopyRepository.Queryable()
            .Includes(p => p.Order)
            .Where(p => p.Id == id)
            .FirstAsync();
        if (data != null)
        {
            detailDto.No = data.No;
            detailDto.OrderTitle = data.Order.Title;
            detailDto.UserName = data.SupplyName;
            detailDto.OrgName = data.CreatorOrgName;
            detailDto.Opinion = data.Opinion;
            detailDto.OperationName = data.CreatorName;
            detailDto.OperationTime = data.CreationTime;
        }
        return detailDto;
    }

    /// <summary>
    /// 查看记录修改
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("get-complement-order-copy-update/{id}")]
    public async Task<object> GetComplementOrderCopyUpdate(string id)
    {
        ComplementOrderCopyDetailListDto copyDetailListDto = new ComplementOrderCopyDetailListDto();
        var updateData = await _orderComplementCopyRepository.Queryable()
            .Includes(p => p.Order)
            .Where(p => p.Id == id)
            .FirstAsync();
        if (updateData is null)
            throw UserFriendlyException.SameMessage("修改明细查询失败！");

        ComplementOrderCopyDetailDto oldInfo = new ComplementOrderCopyDetailDto
        {
            No = updateData.No,
            OrderTitle = updateData.Order.Title,
            UserName = updateData.SupplyName,
            OrgName = updateData.SupplyOrg,
            SupplyTime = updateData.SupplyTime,
            Opinion = updateData.Opinion,
        };

        var copyNew = await _orderComplementCopyRepository.Queryable()
            .OrderBy(x => x.CreationTime)
            .FirstAsync(p => p.ComplementId == updateData.ComplementId && p.CreationTime > updateData.CreationTime);

        ComplementOrderCopyDetailDto newInfo = null;
        if (copyNew != null)
        {
            newInfo = new ComplementOrderCopyDetailDto
            {
                No = copyNew.No,
                OrderTitle = updateData.Order.Title,
                UserName = updateData.CreatorName,
                OrgName = updateData.CreatorOrgName,
                SupplyTime = updateData.CreationTime,
                Opinion = copyNew.Opinion,
            };
        }
        else
        {
            var orderComplement = await _orderComplementRepository.Queryable()
                .FirstAsync(d => d.Id == updateData.ComplementId);
            if (orderComplement is not null)
            {
                newInfo = new ComplementOrderCopyDetailDto
                {
                    No = orderComplement.No,
                    OrderTitle = updateData.Order.Title,
                    UserName = updateData.CreatorName,
                    OrgName = updateData.CreatorOrgName,
                    SupplyTime = updateData.CreationTime,
                    Opinion = orderComplement.Opinion
                };
            }
        }

        return new { OldInfo = oldInfo, NewInfo = newInfo };
    }
}