OA2023/OASystem/OASystem.Infrastructure/Repositories/Groups/ProcessOverviewRepository.cs

using AutoMapper;
using Newtonsoft.Json;
using OASystem.Domain;
using OASystem.Domain.Entities.Groups;
using OASystem.Domain.ViewModels.JuHeExchangeRate;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OASystem.Infrastructure.Repositories.Groups
{
    /// <summary>
    /// 团组流程总览表仓储
    /// </summary>
    public class ProcessOverviewRepository : BaseRepository<Grp_ProcessOverview, Grp_ProcessOverview>
    {
        private readonly IMapper _mapper;
        private readonly DelegationInfoRepository _groupRep;
        public ProcessOverviewRepository(SqlSugarClient sqlSugar, IMapper mapper, DelegationInfoRepository groupRep) : base(sqlSugar)
        {
            _mapper = mapper;
            _groupRep = groupRep;
        }

        /// <summary>
        /// 团组流程初始化
        /// </summary>
        /// <param name="request">创建流程请求参数</param>
        /// <returns>创建的流程信息</returns>
        public async Task<Result> ProcessInitAsync(int groupId, int currUserId)
        {
            //团组验证
            var groupInfo = await _sqlSugar.Queryable<Grp_DelegationInfo>().FirstAsync(g => g.Id == groupId);
            if (groupInfo == null)
            {
                return new Result { Code = 400, Msg = "团组不存在" };
            }

            // 检查是否已存在流程
            var existingProcesses = await _sqlSugar.Queryable<Grp_ProcessOverview>().Where(p => p.GroupId == groupId).ToListAsync();
            if (existingProcesses.Any())
            {
                return new Result { Code = 400, Msg = "该团组的流程已存在" };
            }

            //处理签证国家
            var visaCountries = _groupRep.GroupSplitCountry(groupInfo.VisitCountry);

            // 定义默认的流程节点
            var processs = Grp_ProcessOverview.ProcessInit(groupId, currUserId, visaCountries);

            _sqlSugar.BeginTran();

            foreach (var item in processs)
            {
                var processId = await _sqlSugar.Insertable(item).ExecuteReturnIdentityAsync();

                if (processId < 1)
                {
                    _sqlSugar.RollbackTran();
                    return new Result { Code = 400, Msg = "团组流程进度总览表添加失败！" };
                }

                var nodes = item.Nodes.Select((nodeDto, index) => new Grp_ProcessNode
                {
                    ProcessId = processId,
                    NodeName = nodeDto.NodeName,
                    NodeOrder = nodeDto.NodeOrder,
                    OverallStatus = nodeDto.OverallStatus,
                    //Country = nodeDto.Country,
                    IsCurrent = nodeDto.IsCurrent,
                    Remark = nodeDto.Remark
                }).ToList();

                var nodeIds = await _sqlSugar.Insertable(nodes).ExecuteCommandAsync();
                if (nodeIds < 1)
                {
                    _sqlSugar.RollbackTran();
                    return new Result { Code = 400, Msg = "团组流程进度流程表添加失败！" };
                }
            }
            _sqlSugar.CommitTran();
            return new Result { Code = 200, Msg = "添加成功！" }; ;
        }

        /// <summary>
        /// 获取团组的所有流程及流程详情
        /// </summary>
        /// <param name="request">创建流程请求参数</param>
        /// <returns>创建的流程信息</returns>
        public async Task<Result> ProcessesDetailsAsync(int groupId)
        {
            //团组验证
            var groupInfo = await _sqlSugar.Queryable<Grp_DelegationInfo>().FirstAsync(g => g.Id == groupId);
            if (groupInfo == null)
            {
                return new Result { Code = 400, Msg = "团组不存在" };
            }

            // 检查是否已存在流程
            var existingProcesses = await _sqlSugar.Queryable<Grp_ProcessOverview>().Where(p => p.GroupId == groupId).ToListAsync();
            if (!existingProcesses.Any())
            {
                return new Result { Code = 400, Msg = "该团组的流程不存在" };
            }

            var users = await _sqlSugar.Queryable<Sys_Users>().ToListAsync();

            var processData = await _sqlSugar.Queryable<Grp_ProcessOverview>()
                .Where(p => p.GroupId == groupId && p.IsDel == 0)
                .Mapper(p => p.Nodes, p => p.Nodes.First().ProcessId)
                .ToListAsync();

            var processes = processData.Select(p => new
            {
                p.Id,
                p.GroupId,
                p.ProcessType,
                ProcessName = p.ProcessType.GetEnumDescription(),
                //p.OverallStatus,
                //StatusText = p.OverallStatus.GetDescription(),
                Nodes = p.Nodes.Select(n =>
                {

                    //单独处理签证板块
                    var visaSubNodes = new List<VisaProcessNode>();
                    string remark = string.Empty;

                    if (p.ProcessType == GroupProcessType.Visa)
                    {
                        visaSubNodes = JsonConvert.DeserializeObject<List<VisaProcessNode>>(n.Remark);
                    }
                    return new
                    {
                        n.Id,
                        n.ProcessId,
                        n.NodeOrder,
                        n.NodeName,
                        n.OverallStatus,
                        StatusText = n.OverallStatus.GetEnumDescription(),
                        Operator = users.FirstOrDefault(u => u.Id == n.Operator)?.CnName ?? "-",
                        OpeateTime = n.OperationTime.HasValue ? n.OperationTime.Value.ToString("yyyy-MM-dd HH:mm:ss") : "-",
                        //节点类型为签证时使用
                        visaSubNodes
                    };
                }).OrderBy(n => n.NodeOrder).ToList()
            }).ToList();

            return new Result { Code = 200, Data = processes, Msg = "查询成功！" };
        }

        /// <summary>
        /// 更新节点状态
        /// </summary>
        /// <param name="nodeId">节点ID</param>
        /// <param name="currUserId">当前用户ID</param>
        /// <param name="processStatus">流程状态，默认为已完成</param>
        /// <returns>操作结果</returns>
        public async Task<Result> UpdateNodeStatusAsync(int nodeId, int currUserId, ProcessStatus processStatus = ProcessStatus.Completed)
        {
            try
            {
                // 使用事务确保数据一致性
                var result = await _sqlSugar.Ado.UseTranAsync(async () =>
                {
                    // 1. 获取并验证节点
                    var node = await _sqlSugar.Queryable<Grp_ProcessNode>()
                        .FirstAsync(n => n.Id == nodeId && n.IsDel == 0);

                    if (node == null)
                    {
                        throw new BusinessException("当前节点不存在或已被删除。");
                    }

                    // 2. 更新节点状态
                    node.OverallStatus = processStatus;
                    node.Operator = currUserId;
                    node.OperationTime = DateTime.Now;

                    var updateCount = await _sqlSugar.Updateable(node)
                        .UpdateColumns(n => new
                        {
                            n.OverallStatus,
                            n.Operator,
                            n.OperationTime
                        })
                        .ExecuteCommandAsync();

                    if (updateCount == 0)
                    {
                        throw new BusinessException("节点状态更新失败。");
                    }

                    // 3. 如果是完成当前节点，处理流程流转
                    if (processStatus == ProcessStatus.Completed && node.IsCurrent)
                    {
                        await ProcessCurrentNodeCompletionAsync(node, currUserId);
                    }

                    return new Result { Code = StatusCodes.Status200OK, Msg = "操作成功。" };
                });

                return result.IsSuccess ? result.Data : new Result
                {
                    Code = StatusCodes.Status500InternalServerError,
                    Msg = result.ErrorMessage
                };
            }
            catch (BusinessException ex)
            {
                // 业务异常
                return new Result { Code = StatusCodes.Status400BadRequest, Msg = ex.Message };
            }
            catch (Exception ex)
            {
                // 系统异常
                return new Result { Code = StatusCodes.Status500InternalServerError, Msg = "系统错误，请稍后重试" };
            }
        }

        /// <summary>
        /// 处理当前节点完成后的流程流转
        /// </summary>
        private async Task ProcessCurrentNodeCompletionAsync(Grp_ProcessNode currentNode, int currUserId)
        {
            // 1. 获取流程信息
            var process = await _sqlSugar.Queryable<Grp_ProcessOverview>()
                .FirstAsync(p => p.Id == currentNode.ProcessId && p.IsDel == 0);

            if (process == null)
            {
                throw new BusinessException("关联的流程不存在。");
            }

            // 2. 取消当前节点的当前状态
            currentNode.IsCurrent = false;
            await _sqlSugar.Updateable(currentNode)
                .UpdateColumns(n => new { n.IsCurrent })
                .ExecuteCommandAsync();

            // 3. 查找并激活下一个节点
            var nextNode = await _sqlSugar.Queryable<Grp_ProcessNode>()
                .Where(n => n.ProcessId == currentNode.ProcessId
                         && n.NodeOrder == currentNode.NodeOrder + 1
                         && n.IsDel == 0)
                .FirstAsync();

            if (nextNode != null)
            {
                // 激活下一个节点
                nextNode.IsCurrent = true;
                nextNode.OverallStatus = ProcessStatus.InProgress;
                nextNode.Operator = currUserId;
                nextNode.OperationTime = DateTime.Now;

                var updateCount = await _sqlSugar.Updateable(nextNode)
                    .UpdateColumns(n => new
                    {
                        n.IsCurrent,
                        n.OverallStatus,
                        n.Operator,
                        n.OperationTime
                    })
                    .ExecuteCommandAsync();

                if (updateCount == 0)
                {
                    throw new BusinessException("激活下一节点失败");
                }

                // 更新流程状态为进行中
                process.OverallStatus = ProcessStatus.InProgress;
            }
            else
            {
                // 下一节点不存在，整个流程完成
                process.OverallStatus = ProcessStatus.Completed;
                process.EndTime = DateTime.Now;
            }

            // 4. 更新流程信息
            process.UpdatedUserId = currUserId;
            process.UpdatedTime = DateTime.Now;

            var processUpdateCount = await _sqlSugar.Updateable(process)
                .UpdateColumns(p => new
                {
                    p.OverallStatus,
                    p.EndTime,
                    p.UpdatedUserId,
                    p.UpdatedTime
                })
                .ExecuteCommandAsync();

            if (processUpdateCount == 0)
            {
                throw new BusinessException("流程状态更新失败。");
            }
        }
    }
}