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

using Aspose.Words;
using AutoMapper;
using EyeSoft.Extensions;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using OASystem.Domain;
using OASystem.Domain.Dtos.Groups;
using OASystem.Domain.Entities.Groups;
using OASystem.Domain.Entities.Resource;
using OASystem.Domain.ViewModels.Groups;
using Org.BouncyCastle.Asn1.X500;
using System.Diagnostics;
using System.Drawing;
using System.Reflection;
using System.Runtime.Intrinsics.Arm;
using System.Text.RegularExpressions;

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

        #region 团组流程

        /// <summary>
        /// 基础数据初始化-团组流程
        /// </summary>
        /// <param name="groupId"></param>
        /// <param name="currUserId"></param>
        /// <returns></returns>
        public async Task<List<Grp_ProcessOverview>> ProcessDataInitAsync(int groupId, int currUserId, List<string> visaCountries)
        {
            var processs = new List<Grp_ProcessOverview>();

            // 团组验证
            var groupInfo = await _sqlSugar.Queryable<Grp_DelegationInfo>().FirstAsync(g => g.Id == groupId);
            if (groupInfo == null) return processs;

            // 流程验证
            var existingProcesses = await _sqlSugar.Queryable<Grp_ProcessOverview>()
                .Where(p => p.IsDel == 0 && p.GroupId == groupId)
                .ToListAsync();
            if (existingProcesses.Any()) return processs;

            var users = await _sqlSugar.Queryable<Sys_Users>()
                .LeftJoin<Sys_Company>((u, c) => u.CompanyId == c.Id)
                .LeftJoin<Sys_Department>((u, c, d) => u.DepId == d.Id)
                .LeftJoin<Sys_JobPost>((u, c, d, jp) => u.JobPostId == jp.Id)
                .Where((u, c, d, jp) => u.IsDel == 0)
                .Select((u, c, d, jp) => new {
                    u.Id,
                    u.CnName,
                    u.CompanyId,
                    c.CompanyName,
                    u.DepId,
                    d.DepName,
                    u.JobPostId,
                    jp.JobName,
                })
                .ToListAsync();

            var defaultJobNames = new List<string>()
            {
                "OP主管"
            };

            #region 商邀报批流程

            string oaNode1Tips = NodeTipsMsg(groupInfo, GroupProcessType.Invitation, 1);
            string oaNode2Tips = NodeTipsMsg(groupInfo, GroupProcessType.Invitation, 2);
            string oaNode3Tips = NodeTipsMsg(groupInfo, GroupProcessType.Invitation, 3);
            string oaNode4Tips = NodeTipsMsg(groupInfo, GroupProcessType.Invitation, 4);
            string oaNode5Tips = NodeTipsMsg(groupInfo, GroupProcessType.Invitation, 5);
            string oaNode6Tips = NodeTipsMsg(groupInfo, GroupProcessType.Invitation, 6);
            string oaNode7Tips = NodeTipsMsg(groupInfo, GroupProcessType.Invitation, 7);

            //节点可操作用户列表
            var oaJobNames = new List<string>() {
                "商邀主管",
                "商邀"
            };
            var oaNodeOpUsers = users.Where(u =>
                u.JobName != null && oaJobNames.Contains(u.JobName)
            ).Select(u => u.Id)
            .ToList();

            processs.Add(
                Grp_ProcessOverview.Create(groupId, 1, GroupProcessType.Invitation, ProcessStatus.InProgress, currUserId,
                new List<Grp_ProcessNode>()
                    {
                        Grp_ProcessNode.Create(1, "初期报批文字材料",oaNode1Tips,ProcessStatus.InProgress, true,false,false,false,currUserId,oaNodeOpUsers),
                        Grp_ProcessNode.Create(2, "第一轮对接",oaNode2Tips, ProcessStatus.InProgress, false,false,false,false,currUserId,oaNodeOpUsers),
                        Grp_ProcessNode.Create(3, "第二轮对接",oaNode3Tips,ProcessStatus.InProgress, false,false,false,false, currUserId ,oaNodeOpUsers),
                        Grp_ProcessNode.Create(4, "取得邀请函",oaNode4Tips,ProcessStatus.InProgress, false,false,false,false, currUserId,oaNodeOpUsers),
                        Grp_ProcessNode.Create(5, "公务等事项确认",oaNode5Tips,ProcessStatus.InProgress, false,false,false,true, currUserId,oaNodeOpUsers),
                        Grp_ProcessNode.Create(6, "公务邀请数据有效录入",oaNode6Tips,ProcessStatus.InProgress, false,false,false,true, currUserId,oaNodeOpUsers),
                        Grp_ProcessNode.Create(7, "文件上传",oaNode7Tips,ProcessStatus.InProgress, false,false,true,false, currUserId,oaNodeOpUsers),
                    }
                ));
            #endregion

            #region 签证流程

            //节点可操作用户列表
            var visaNodeOpUsers = users.Where(u =>
                u.JobName != null && u.JobName.Contains("签证")
            ).Select(u => u.Id).ToList();

            //单独处理签证流程节点
            var visaNodes = new List<Grp_ProcessNode>();

            if (visaCountries != null && visaCountries.Count > 0)
            {
                var visaDefualtNodes = new List<VisaProcessNode>();
                for (int i = 1; i < visaCountries.Count + 1; i++)
                {
                    visaDefualtNodes.Add(VisaProcessNode.Info(i, visaCountries[i - 1].ToString()));
                }

                string visaNode1Tips = NodeTipsMsg(groupInfo, GroupProcessType.Visa, 1);
                string visaNode2Tips = NodeTipsMsg(groupInfo, GroupProcessType.Visa, 2);
                visaNodes.Add(Grp_ProcessNode.Create(1, "签证信息", visaNode1Tips, ProcessStatus.InProgress, true, false, false, false, currUserId, visaNodeOpUsers, JsonConvert.SerializeObject(visaDefualtNodes)));
                visaNodes.Add(Grp_ProcessNode.Create(2, "票据上传(明细表、费用票据、保单及超支费用账单)", visaNode2Tips, ProcessStatus.InProgress, false, false, true, false, currUserId, oaNodeOpUsers));
            }

            processs.Add(Grp_ProcessOverview.Create(groupId, 2, GroupProcessType.Visa, ProcessStatus.UnStarted, currUserId, visaNodes));
            #endregion

            #region 机票流程
            string airNode1Tips = NodeTipsMsg(groupInfo, GroupProcessType.AirTicket, 1);
            string airNode2Tips = NodeTipsMsg(groupInfo, GroupProcessType.AirTicket, 2);
            string airNode3Tips = NodeTipsMsg(groupInfo, GroupProcessType.AirTicket, 3);
            string airNode4Tips = NodeTipsMsg(groupInfo, GroupProcessType.AirTicket, 4);
            string airNode5Tips = NodeTipsMsg(groupInfo, GroupProcessType.AirTicket, 5);
            string airNode6Tips = NodeTipsMsg(groupInfo, GroupProcessType.AirTicket, 6);
            string airNode7Tips = NodeTipsMsg(groupInfo, GroupProcessType.AirTicket, 7);
            string airNode8Tips = NodeTipsMsg(groupInfo, GroupProcessType.AirTicket, 8);

            //节点可操作用户列表
            var airNodeOpJobNames = new List<string>() {
                "机票"
            };
            airNodeOpJobNames.AddRange(defaultJobNames);

            var airNodeOpUsers = users.Where(u =>
                u.JobName != null && airNodeOpJobNames.Contains(u.JobName)
            ).Select(u => u.Id).ToList();

            processs.Add(
                Grp_ProcessOverview.Create(groupId, 3, GroupProcessType.AirTicket, ProcessStatus.InProgress, currUserId,
                new List<Grp_ProcessNode>()
                    {
                        Grp_ProcessNode.Create(1, "初步拟定航程方案及价格", airNode1Tips, ProcessStatus.InProgress, true,false,false,false, currUserId ,airNodeOpUsers),
                        Grp_ProcessNode.Create(2, "机票占位、续位", airNode2Tips, ProcessStatus.InProgress, false,false,false,false,currUserId,airNodeOpUsers ),
                        Grp_ProcessNode.Create(3, "完成机票采购确认", airNode3Tips, ProcessStatus.InProgress,false,false,false,false, currUserId, airNodeOpUsers),
                        Grp_ProcessNode.Create(4, "进行出票操作并核查信息", airNode4Tips, ProcessStatus.InProgress, false,false,false,false, currUserId, airNodeOpUsers),
                        Grp_ProcessNode.Create(5, "机票已出", airNode5Tips, ProcessStatus.InProgress, false,false,false,false, currUserId, airNodeOpUsers),
                        Grp_ProcessNode.Create(6, "完成机票选座", airNode6Tips, ProcessStatus.InProgress, false,false,false,false,currUserId, airNodeOpUsers),
                        Grp_ProcessNode.Create(7, "票据上传(机票超支费用账单)", airNode7Tips, ProcessStatus.InProgress, false,false,true,false, currUserId,airNodeOpUsers),
                        Grp_ProcessNode.Create(8, "票据上传", airNode8Tips, ProcessStatus.InProgress, false,false,true,false, currUserId, airNodeOpUsers)
                    }
                )
             );
            #endregion

            #region 酒店流程
            string hotelNode1Tips = NodeTipsMsg(groupInfo, GroupProcessType.Hotel, 1);
            string hotelNode2Tips = NodeTipsMsg(groupInfo, GroupProcessType.Hotel, 2);
            string hotelNode3Tips = NodeTipsMsg(groupInfo, GroupProcessType.Hotel, 3);
            string hotelNode4Tips = NodeTipsMsg(groupInfo, GroupProcessType.Hotel, 4);
            string hotelNode5Tips = NodeTipsMsg(groupInfo, GroupProcessType.Hotel, 5);

            //节点可操作用户列表
            var hotelNodeOpJobNames = new List<string>() { "酒店" };
            hotelNodeOpJobNames.AddRange(defaultJobNames);

            var hotelNodeOpUsers = users.Where(u =>
                u.JobName != null && hotelNodeOpJobNames.Contains(u.JobName)
            ).Select(u => u.Id).ToList();

            processs.Add(
                Grp_ProcessOverview.Create(groupId, 4, GroupProcessType.Hotel, ProcessStatus.InProgress, currUserId,
                     new List<Grp_ProcessNode>()
                    {
                        Grp_ProcessNode.Create(1, "按照预算，询价、比价、谈价", hotelNode1Tips, ProcessStatus.InProgress, true, false, false, false, currUserId, hotelNodeOpUsers),
                        Grp_ProcessNode.Create(2, "获取酒店确认函与入住名单核对", hotelNode2Tips, ProcessStatus.InProgress, false, false, false,false, currUserId , hotelNodeOpUsers),
                        Grp_ProcessNode.Create(3, "预订酒店并录入OA", hotelNode3Tips, ProcessStatus.InProgress,false, false, false,false,currUserId , hotelNodeOpUsers),
                        Grp_ProcessNode.Create(4, "行前再次确认酒店相关情况",  hotelNode4Tips,ProcessStatus.InProgress, false, false, false,false,currUserId , hotelNodeOpUsers),
                        Grp_ProcessNode.Create(5, "行程结束后整理酒店发票与结算",  hotelNode5Tips, ProcessStatus.InProgress, false, false, true,false, currUserId ,hotelNodeOpUsers),
                    }
                )
            );
            #endregion

            #region 地接流程
            string opNode1Tips = NodeTipsMsg(groupInfo, GroupProcessType.LocalGuide, 1);
            string opNode2Tips = NodeTipsMsg(groupInfo, GroupProcessType.LocalGuide, 2);
            string opNode3Tips = NodeTipsMsg(groupInfo, GroupProcessType.LocalGuide, 3);
            string opNode4Tips = NodeTipsMsg(groupInfo, GroupProcessType.LocalGuide, 4);
            string opNode5Tips = NodeTipsMsg(groupInfo, GroupProcessType.LocalGuide, 5);
            string opNode6Tips = NodeTipsMsg(groupInfo, GroupProcessType.LocalGuide, 6);
            string opNode7Tips = NodeTipsMsg(groupInfo, GroupProcessType.LocalGuide, 7);

            //节点可操作用户列表
            var opNodeOpJobNames = new List<string>() { "OP" };
            opNodeOpJobNames.AddRange(defaultJobNames);

            var opNodeOpUsers = users.Where(u =>
                u.JobName != null && opNodeOpJobNames.Contains( u.JobName)
            ).Select(u => u.Id).ToList();

            processs.Add(
                Grp_ProcessOverview.Create(groupId, 5, GroupProcessType.LocalGuide, ProcessStatus.InProgress, currUserId,
                     new List<Grp_ProcessNode>()
                    {
                        Grp_ProcessNode.Create(1,"根据机票方案出框架行程", opNode1Tips,ProcessStatus.InProgress, true, false, false,false,currUserId,opNodeOpUsers),
                        Grp_ProcessNode.Create(2,"联系并询价地接相关的供应商", opNode2Tips,ProcessStatus.InProgress, false, false, false,false, currUserId,opNodeOpUsers),
                        Grp_ProcessNode.Create(3,"提交供应商报价及比价表", opNode3Tips, ProcessStatus.InProgress, false, false, false, false,currUserId,opNodeOpUsers),
                        Grp_ProcessNode.Create(4,"执行采购流程", opNode4Tips, ProcessStatus.InProgress, false, false, false,false, currUserId,opNodeOpUsers),
                        Grp_ProcessNode.Create(5,"制定最终行程单及出行手册", opNode5Tips, ProcessStatus.InProgress, false, false, false,false, currUserId ,opNodeOpUsers),
                        Grp_ProcessNode.Create(6,"送机", opNode6Tips, ProcessStatus.InProgress, false, false, false,false, currUserId,opNodeOpUsers ),
                        Grp_ProcessNode.Create(7,"最终版报批行程、票据上传", opNode7Tips, ProcessStatus.InProgress, false, false, true, false,currUserId,opNodeOpUsers )
                    }
                )
            );

            #endregion

            #region 费用结算流程
            var feeNode1Tips = NodeTipsMsg(groupInfo, GroupProcessType.FeeSettle, 1);
            var feeNode2Tips = NodeTipsMsg(groupInfo, GroupProcessType.FeeSettle, 2);
            var feeNode3Tips = NodeTipsMsg(groupInfo, GroupProcessType.FeeSettle, 3);
            var feeNode4Tips = NodeTipsMsg(groupInfo, GroupProcessType.FeeSettle, 4);
            //节点可操作用户列表
            var feeNodeOpUsers = users.Where(u =>
                u.JobName != null && u.JobName.Contains("会计") && u.CnName.Equals("曾艳")
            ).Select(u => u.Id).ToList();

            processs.Add(
                Grp_ProcessOverview.Create(groupId, 6, GroupProcessType.FeeSettle, ProcessStatus.InProgress, currUserId,
                    new List<Grp_ProcessNode>()
                    {
                        Grp_ProcessNode.Create(1, "城市间交通报批金额核定", feeNode1Tips, ProcessStatus.InProgress, true, true, false,false,currUserId,feeNodeOpUsers),
                        Grp_ProcessNode.Create(2, "团组城市间交通及国际机票数据分配的合理性核对", feeNode2Tips, ProcessStatus.InProgress, false, false, false,false,currUserId,feeNodeOpUsers),
                        Grp_ProcessNode.Create(3, "整理统计相关财务资料给到各单位", feeNode3Tips, ProcessStatus.InProgress, false, false, false,false,currUserId,feeNodeOpUsers),
                        Grp_ProcessNode.Create(4, "费用结算完毕", feeNode4Tips, ProcessStatus.InProgress, false, false, false,false, currUserId , feeNodeOpUsers),
                    }
                )
            );
            #endregion

            return processs;
        }

        /// <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.IsDel == 0 && p.GroupId == groupId)
                .ToListAsync();
            if (existingProcesses.Any())
            {
                return new Result { Code = 400, Msg = "该团组的流程已存在" };
            }

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

            // 定义默认的流程节点
            var processs = await ProcessDataInitAsync(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 = "团组流程进度总览表添加失败！" };
                }
                item.Id = processId;
                // 记录流程日志
                await LogProcessOpAsync(null, item, "Create", currUserId);

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

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

                //设置节点ID
                nodes = await _sqlSugar.Queryable<Grp_ProcessNode>().Where(x => x.IsDel == 0 && x.ProcessId == processId).ToListAsync();

                //记录节点日志
                foreach (var node in nodes)
                {
                    await LogNodeOpAsync(null, node, "Create", currUserId);
                }

            }
            _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.IsDel == 0 && p.GroupId == groupId).ToListAsync();
            if (!existingProcesses.Any())
            {
                //新建团组流程
                var res = await ProcessInitAsync(groupId, 4);
                if (res.Code != 200)
                {
                    return res;
                }
            }

            var users = await _sqlSugar.Queryable<Sys_Users>().Select(x => new { x.Id, x.CnName }).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 userDict = users.ToDictionary(u => u.Id, u => u.CnName);

            var processes = processData.Select(p =>
            {
                var orderedNodes = p.Nodes.Where(x => x.IsDel == 0).OrderBy(n => n.NodeOrder).ToList();
                var totalNodes = orderedNodes.Count;

                return new ProcessDetailsView()
                {
                    Id = p.Id,
                    GroupId = p.GroupId,
                    ProcessType = p.ProcessType,
                    ProcessName = p.ProcessType.GetEnumDescription(),
                    Nodes = orderedNodes.Select((n, index) =>
                    {
                        var isLastNode = index == totalNodes - 1;
                        var isSecondLastNode = index == totalNodes - 2;
                        var isFifthStep = index == 4;

                        // 计算按钮状态
                        bool isEnaAssistBtn = p.ProcessType == GroupProcessType.FeeSettle && n.NodeOrder == 1;

                        // 文件上传按钮启用规则
                        bool isEnaFileUpBtn = false;
                        // 是否参与按钮启用
                        bool isEnaPartBtn = false;

                        // 规则1：商邀流程第五步启用参与按钮
                        if (p.ProcessType == GroupProcessType.Invitation && isFifthStep)
                        {
                            isEnaPartBtn = true;
                        }
                        // 规则2：机票流程倒数第二步启用上传按钮
                        else if (p.ProcessType == GroupProcessType.AirTicket && isSecondLastNode)
                        {
                            isEnaFileUpBtn = true;
                        }
                        // 规则3：默认流程节点最后一步启用上传按钮
                        else if (isLastNode && p.ProcessType != GroupProcessType.FeeSettle)
                        {
                            isEnaFileUpBtn = true;
                        }

                        // 处理签证子节点
                        List<VisaProcessNode> visaSubNodes = new();
                        if (p.ProcessType == GroupProcessType.Visa && n.NodeOrder == 1)
                        {
                            visaSubNodes = JsonConvert.DeserializeObject<List<VisaProcessNode>>(n.Remark ?? "[]")
                                ?? new List<VisaProcessNode>();
                        }

                        // 获取操作人姓名
                        string operatorName = "-";
                        if (n.Operator.HasValue && userDict.TryGetValue(n.Operator.Value, out var name))
                        {
                            operatorName = name;
                        }

                        string nodeTipsMsg = NodeTipsMsg(groupInfo, p.ProcessType, n.NodeOrder);

                        return new ProcessNodeDetailsView()
                        {
                            Id = n.Id,
                            ProcessId = n.ProcessId,
                            NodeOrder = n.NodeOrder,
                            NodeName = n.NodeName,
                            OverallStatus = n.OverallStatus,
                            StatusText = n.OverallStatus.GetEnumDescription(),
                            Operator = operatorName,
                            OpeateTime = n.OperationTime?.ToString("yyyy-MM-dd HH:mm:ss") ?? "-",
                            ActualDone = n.ActualDone?.ToString("yyyy-MM-dd HH:mm:ss") ?? "",
                            OpUserList = n.OpUserList,       //可操作用户列表
                            NodeDescTips = nodeTipsMsg,      
                            IsEnaAssistBtn = isEnaAssistBtn, // 是否启用财务流程首节点协助按钮
                            IsAssist = n.IsAssist,           // 财务流程首节点 存储值
                            IsEnaFileUpBtn = isEnaFileUpBtn, // 是否启用上传文件按钮
                            IsFileUp = n.IsFileUp,           // 上传文件节点 存储值
                            IsEnaPartBtn = isEnaPartBtn,     // 是否启用参与按钮
                            IsPart = n.IsPart,               // 参与按钮 存储值
                            VisaSubNodes = visaSubNodes,     // 签证节点类型使用
                            Remark = n.Remark
                        };
                    }).ToList()
                };
            }).ToList();

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

        /// <summary>
        /// 指定日期增加工作日
        /// </summary>
        /// <param name="startDate"></param>
        /// <param name="days"></param>
        /// <returns></returns>
        private static DateTime AddWeekdays(DateTime startDate, int days)
        {
            DateTime currentDate = startDate;
            if (days >= 0)
            {
                while (days > 0)
                {
                    currentDate = currentDate.AddDays(1);
                    DayOfWeek day = currentDate.DayOfWeek;
                    if (day != DayOfWeek.Saturday && day != DayOfWeek.Sunday)
                    {
                        days--;
                    }
                }
            }
            else
            {
                days = Math.Abs(days);
                while (days > 0)
                {
                    currentDate = currentDate.AddDays(-1);
                    DayOfWeek day = currentDate.DayOfWeek;
                    if (day != DayOfWeek.Saturday && day != DayOfWeek.Sunday)
                    {
                        days--;
                    }
                }
            }
            return currentDate;
        }

        /// <summary>
        /// 节点提示消息
        /// </summary>
        /// <param name="groupInfo"></param>
        /// <param name="procType"></param>
        /// <param name="nodeOrder"></param>
        /// <returns></returns>
        private string NodeTipsMsg(Grp_DelegationInfo groupInfo, GroupProcessType procType, int nodeOrder)
        {
            string msg = string.Empty;
            int groupId = groupInfo.Id;
            groupInfo.VisitDate = groupInfo.VisitDate.AddDays(1); //第二天开始计算
            switch (procType)
            {
                case GroupProcessType.Invitation:
                    switch (nodeOrder)
                    {
                        case 1:
                            msg = "“完成基础请示、报批日程初稿”，4个工作日（仍需根据客户意见和联系情况及时修改补充所需其他材料，例如印证文件、成果表等，直至终稿）";

                            if (groupInfo.Step == 1 || groupInfo.Step == 2)
                            {
                                if (groupInfo.StepOperationTime.HasValue)
                                {
                                    msg = $"请于{AddWeekdays(groupInfo.StepOperationTime.Value, 4):yyyy年MM月dd日}内完成该项工作(“完成基础请示、报批日程初稿”，4个工作日（仍需根据客户意见和联系情况及时修改补充所需其他材料，例如印证文件、成果表等，直至终稿）)";
                                }
                            }

                            break;
                        case 2:
                            msg = $"请于{AddWeekdays(groupInfo.VisitDate, 7):yyyy年MM月dd日}内完成该项工作(7个工作日，所有报批机构前部联系，邀请机构一个国家不少于4家进行重点对接（4家机构中，其中3家机构需有效对接，其中1家可为付费机构备选）)";
                            break;
                        case 3:
                            msg = "10个工作日，根据最新情况，联系公务机构1/3取得回应；邀请机构基本明确。";
                            break;
                        case 4:
                            var custInfo = _sqlSugar.Queryable<Grp_TourClientList>()
                                .Where(c => c.DiId == groupId && c.IsDel == 0)
                                .OrderByDescending(c => c.CreateTime)
                                .First();

                            msg = $"正式名单下放后2周内（含非工作日）。如团组前期准备时间已经较长，则按客户要求尽快提供。 加急团组备注特殊情况。";

                            if (custInfo != null)
                            {
                                msg = $"请于{custInfo.CreateTime.AddDays(14):yyyy年MM月dd日}内完成该项工作(正式名单下放后2周内（含非工作日）。如团组前期准备时间已经较长，则按客户要求尽快提供。 加急团组备注特殊情况。)";
                            }
                            break;
                        case 5:
                            groupInfo.VisitDate = groupInfo.VisitDate.AddDays(-1); //时间倒推，调整回原始出发日期
                            msg = $"请于{AddWeekdays(groupInfo.VisitDate,-5):yyyy年MM月dd日}内完成该项工作(团组出发前，5个工作日完成所有公务确认工作。";

                            break;
                        case 6:
                            break;
                        case 7:
                            msg = $"请于{groupInfo.VisitEndDate:yyyy年MM月dd日}内完成该项工作(如果需要上传请在团组结束前完成)";
                            break;
                    }
                    break;
                case GroupProcessType.Visa:
                    switch (nodeOrder)
                    {
                        case 1:
                            break;
                        case 2:
                            msg = $"请于{groupInfo.VisitDate:yyyy年MM月dd日}内完成该项工作(按进度实际签证办理落实情况，团组出发前上传票据。)";
                            break;
                    }
                    break;
                case GroupProcessType.AirTicket:
                    switch (nodeOrder)
                    {
                        case 1:
                            msg = "建团后打勾确认出团的时候开始24小时内。";
                            if (groupInfo.Step == 1 || groupInfo.Step == 2)
                            {
                                if (groupInfo.StepOperationTime.HasValue)
                                {
                                    msg = $"请于{groupInfo.StepOperationTime.Value.AddDays(1):yyyy年MM月dd日}内完成该项工作(建团后打勾确认出团的时候开始24小时内)";
                                }
                            }
                            break;
                        case 2:
                            break;
                        case 3:
                            msg = $"完成机票采购确认（含预算核对、出票确认等）";
                            break;
                        case 4:
                            break;
                        case 5:
                            msg = $"请于{AddWeekdays(groupInfo.VisitDate,2):yyyy年MM月dd日}内完成该项工作(团组出发前2个工作日)";
                            break;
                        case 6:
                            break;
                        case 7:
                            msg = $"请于{AddWeekdays(groupInfo.VisitEndDate,5):yyyy年MM月dd日}内完成该项工作(机票蓝联打票及上传机票超支费用账单,团组归国后5个工作日内)";
                            break;
                        case 8:
                            msg = $"1. 票据上传(机票报销蓝联、行程单及机票说明) \r\n 2. 请于{AddWeekdays(groupInfo.VisitEndDate,10):yyyy年MM月dd日}内完成该项工作(团组归国后10个工作日内) *按机票报价*0.999折扣出具机票报销蓝联、行程单及机票说明";
                            break;
                    }
                    break;
                case GroupProcessType.Hotel:
                    switch (nodeOrder)
                    {
                        case 1:
                            msg = "1. 筛选并按照预算标准，对目标酒店进行询价、比价、谈价 \r\n2. 建团后打勾确认出团的时候开始2个工作日。";
                            if (groupInfo.Step == 1 || groupInfo.Step == 2)
                            {
                                if (groupInfo.StepOperationTime.HasValue)
                                {
                                    msg = $"请于{AddWeekdays(groupInfo.StepOperationTime.Value, 2):yyyy年MM月dd日}内完成该项工作(建团后打勾确认出团的时候开始2个工作日)";
                                }
                            }
                            break;
                        case 2:
                            break;
                        case 3:
                            break;
                        case 4:
                            msg = $"1.行前再次确认酒店订单、付款状态及入住安排 \r\n 2.请于{AddWeekdays(groupInfo.VisitDate,-2):yyyy年MM月dd日}内完成该项工作(团组出发前2个工作日)";
                            break;
                        case 5:
                            msg = $"1.行程结束后整理酒店发票(含超支费用发票)与结算 \r\n 2.请于{AddWeekdays(groupInfo.VisitEndDate,5):yyyy年MM月dd日}内完成该项工作(团组结束后5个工作日内)";
                            break;
                    }
                    break;
                case GroupProcessType.LocalGuide:
                    switch (nodeOrder)
                    {
                        case 1:
                            var airTripCodeInfo = _sqlSugar.Queryable<Air_TicketBlackCode>()
                                .Where(x => x.IsDel == 0 && x.DiId == groupId)
                                .OrderByDescending(x => x.CreateTime)
                                .First();
                            msg = $"机票行程代码最后一段录入后1个工作日内。";
                            if (airTripCodeInfo != null)
                            {
                                msg = $"请于{AddWeekdays(airTripCodeInfo.CreateTime, 1):yyyy年MM月dd日}内完成该项工作(机票行程代码最后一段录入后1个工作日内)";
                            }
                            break;
                        case 2:
                            msg = $"1.联系并询价地接、餐厅、用车、景点等供应商 \r\n 2. 请于{AddWeekdays(groupInfo.VisitDate, 20):yyyy年MM月dd日}内完成该项工作(团组出行前20个工作日)";
                            break;
                        case 3:
                            msg = $"请于{AddWeekdays(groupInfo.CreateTime, 10):yyyy年MM月dd日}内完成该项工作(上一步往后3个工作日内)";
                            break;
                        case 4:
                            msg = $"请于{AddWeekdays(groupInfo.CreateTime, 12):yyyy年MM月dd日}内完成该项工作(上一步往后2个工作日内)";
                            break;
                        case 5:
                            var backListInfo = _sqlSugar.Queryable<Grp_InvertedList>().Where(x => x.DiId == groupId && x.IsDel == 0).First();
                            msg = $"1.制定最终《行程单》及《出行手册》 \r\n2. 倒推表里开行前会 -3天。";
                            if (backListInfo != null)
                            {
                                if (DateTime.TryParse(backListInfo.PreTripMeetingDt, out DateTime dateTime))
                                {
                                    msg = $"请于{dateTime.AddDays(-3):yyyy年MM月dd日}内完成该项工作(倒推表里开行前会 -3天)";
                                }
                            }
                            break;
                        case 6:
                            break;
                        case 7:
                            msg = $"请于{AddWeekdays( groupInfo.VisitEndDate,5):yyyy年MM月dd日}内完成该项工作(团组归国后5个工作日内) *上传最终报批行程，确定城市间交通最终版报价分配；地接账单（清楚标注超时及其他项超支费用）、地接交通费用原始票据、城市间交通明细表；";
                            break;
                    }
                    break;
                case GroupProcessType.FeeSettle:
                    switch (nodeOrder)
                    {
                        case 1:
                            msg = "团组报批前";
                            break;
                        case 2:
                            msg = "团组报批前三公费用表";
                            break;
                        case 3:
                            msg = $"1.整理统计团组超支费用、三公报销资料给到各单位 \r\n 2. 请于{AddWeekdays(groupInfo.VisitEndDate,12):yyyy年MM月dd日}内完成该项工作(团组归国后12个工作日内)";
                            break;
                        case 4:
                            break;
                    }
                    break;
            }
            return msg;
        }

        #region 状态变更 可操作任意节点 进行中<-->已完成 双向变更

        /// <summary>
        /// 更新节点状态（支持任意节点状态变更，无需处理当前节点）
        /// </summary>
        /// <param name="nodeId"></param>
        /// <param name="currUserId"></param>
        /// <param name="targetStatus"></param>
        /// <returns></returns>
        public async Task<Result> UpdateNodeStatusSimpleAsync(int nodeId, int currUserId, ProcessStatus targetStatus = 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) return new Result { Code = StatusCodes.Status400BadRequest, Msg = "当前节点不存在或已被删除。" };

                    // 2. 用户权限验证
                    if (!HasNodeOperationPermission(node, currUserId))
                    {
                        return new Result { Code = StatusCodes.Status400BadRequest, Msg = "当前用户没有操作此节点的权限." };
                    }

                    var process = await _sqlSugar.Queryable<Grp_ProcessOverview>()
                        .FirstAsync(p => p.Id == node.ProcessId && p.IsDel == 0);

                    if (process == null) return new Result { Code = StatusCodes.Status400BadRequest, Msg = "关联的流程不存在。" };

                    // 3. 检查是否重复操作
                    if (node.OverallStatus == targetStatus)
                    {
                        return new Result { Code = StatusCodes.Status400BadRequest, Msg = $"当前节点已为{GetStatusDescription(targetStatus)}状态，无需重复操作。。" };
                    }

                    // 4. 存储更新前的值
                    var nodeBefore = CloneNode(node);
                    var processBefore = CloneProcess(process);

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

                    // 6. 保存节点更新
                    await _sqlSugar.Updateable(node)
                        .UpdateColumns(n => new
                        {
                            n.OverallStatus,
                            n.Operator,
                            n.OperationTime
                        })
                        .ExecuteCommandAsync();

                    // 7. 更新流程状态（基于所有节点的状态计算）
                    await UpdateProcessOverallStatusAsync(process, currUserId);

                    // 8. 记录日志
                    await LogNodeOpAsync(nodeBefore, node, "Update", currUserId);
                    await LogProcessOpAsync(processBefore, process, "Update", 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>
        /// <param name="process"></param>
        /// <param name="currUserId"></param>
        /// <returns></returns>
        private async Task UpdateProcessOverallStatusAsync(Grp_ProcessOverview process, int currUserId)
        {
            // 获取所有节点
            var allNodes = await _sqlSugar.Queryable<Grp_ProcessNode>()
                .Where(n => n.ProcessId == process.Id && n.IsDel == 0)
                .ToListAsync();

            // 统计节点状态
            int totalCount = allNodes.Count;
            int completedCount = allNodes.Count(n => n.OverallStatus == ProcessStatus.Completed);
            int inProgressCount = allNodes.Count(n => n.OverallStatus == ProcessStatus.InProgress);

            // 判断流程状态
            ProcessStatus newProcessStatus;

            if (completedCount == totalCount)
            {
                // 所有节点都已完成
                newProcessStatus = ProcessStatus.Completed;
                process.EndTime = DateTime.Now;
            }
            else if (inProgressCount > 0 || completedCount > 0)
            {
                // 有节点进行中或已完成
                newProcessStatus = ProcessStatus.InProgress;
                process.EndTime = null;
            }
            else
            {
                // 所有节点都未开始
                newProcessStatus = ProcessStatus.UnStarted;
                process.EndTime = null;
            }

            // 更新流程状态（只有状态变化时才更新）
            if (process.OverallStatus != newProcessStatus)
            {
                process.OverallStatus = newProcessStatus;
                process.UpdatedUserId = currUserId;
                process.UpdatedTime = DateTime.Now;

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

        /// <summary>
        /// 验证用户是否有操作节点的权限
        /// </summary>
        private static bool HasNodeOperationPermission(Grp_ProcessNode node, int userId)
        {
            // 如果 OpUserList 为空或 null，表示不限制权限
            if (node.OpUserList == null || node.OpUserList.Count == 0)
            {
                return true;
            }

            // 检查当前用户是否在权限列表中
            return node.OpUserList.Contains(userId);
        }

        /// <summary>
        /// 克隆节点对象
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        private static Grp_ProcessNode CloneNode(Grp_ProcessNode node)
        {
            return new Grp_ProcessNode()
            {
                Id = node.Id,
                ProcessId = node.ProcessId,
                NodeName = node.NodeName,
                NodeOrder = node.NodeOrder,
                OverallStatus = node.OverallStatus,
                Operator = node.Operator,
                OperationTime = node.OperationTime,
                IsCurrent = node.IsCurrent,
            };
        }

        /// <summary>
        /// 克隆流程对象
        /// </summary>
        /// <param name="process"></param>
        /// <returns></returns>
        private static Grp_ProcessOverview CloneProcess(Grp_ProcessOverview process)
        {
            return new Grp_ProcessOverview()
            {
                Id = process.Id,
                GroupId = process.GroupId,
                ProcessOrder = process.ProcessOrder,
                ProcessType = process.ProcessType,
                OverallStatus = process.OverallStatus,
                StartTime = process.StartTime,
                EndTime = process.EndTime,
                UpdatedUserId = process.UpdatedUserId,
                UpdatedTime = process.UpdatedTime
            };
        }

        #endregion

        #region 状态变更 流程导向

        /// <summary>
        /// 更新节点状态
        /// </summary>
        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)
                        ?? throw new BusinessException("当前节点不存在或已被删除。");

                    // 2. 获取流程信息
                    var process = await _sqlSugar.Queryable<Grp_ProcessOverview>()
                        .FirstAsync(p => p.Id == node.ProcessId && p.IsDel == 0)
                        ?? throw new BusinessException("关联的流程不存在。");

                    // 3. 验证节点操作
                    ValidateNodeOperation(node, processStatus);

                    // 4. 存储更新前的值
                    var nodeBefore = new Grp_ProcessNode()
                    {
                        Id = node.Id,
                        ProcessId = node.ProcessId,
                        NodeName = node.NodeName,
                        NodeOrder = node.NodeOrder,
                        OverallStatus = node.OverallStatus,
                        Operator = node.Operator,
                        OperationTime = node.OperationTime,
                        IsCurrent = node.IsCurrent,
                    };

                    var processBefore = new Grp_ProcessOverview()
                    {
                        Id = process.Id,
                        GroupId = process.GroupId,
                        ProcessOrder = process.ProcessOrder,
                        ProcessType = process.ProcessType,
                        OverallStatus = process.OverallStatus,
                        StartTime = process.StartTime,
                        EndTime = process.EndTime,
                        UpdatedUserId = process.UpdatedUserId,
                        UpdatedTime = process.UpdatedTime
                    };

                    // 5. 处理特殊状态流转逻辑
                    if (node.OverallStatus == ProcessStatus.Completed && processStatus == ProcessStatus.InProgress)
                    {
                        // 从已完成回退到进行中
                        await HandleRollbackToInProgressAsync(node, process, currUserId);
                    }
                    else
                    {
                        // 正常状态更新
                        await HandleNormalStatusUpdateAsync(node, process, processStatus, currUserId);
                    }

                    // 6. 记录日志
                    await LogNodeOpAsync(nodeBefore, node, "Update", currUserId);
                    await LogProcessOpAsync(processBefore, process, "Update", 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 HandleRollbackToInProgressAsync(Grp_ProcessNode node, Grp_ProcessOverview process, int currUserId)
        {
            // 1. 检查是否可以回退
            if (process.OverallStatus == ProcessStatus.Completed && process.ProcessType != GroupProcessType.Invitation)
            {
                throw new BusinessException("整个流程已完成，无法回退单个节点状态。");
            }

            // 2. 取消其他当前节点，设置当前节点为当前节点
            await ClearOtherCurrentNodesAsync(node.ProcessId, node.Id, currUserId);

            // 3. 更新节点状态
            node.OverallStatus = ProcessStatus.InProgress;
            node.Operator = currUserId;
            node.OperationTime = DateTime.Now;
            node.IsCurrent = true;

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

            // 4. 更新流程状态为进行中（如果已完成的流程回退）
            if (process.OverallStatus == ProcessStatus.Completed)
            {
                process.OverallStatus = ProcessStatus.InProgress;
                process.EndTime = null; // 清空完成时间
                process.UpdatedUserId = currUserId;
                process.UpdatedTime = DateTime.Now;

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

        /// <summary>
        /// 处理正常状态更新逻辑
        /// </summary>
        private async Task HandleNormalStatusUpdateAsync(Grp_ProcessNode node, Grp_ProcessOverview process, ProcessStatus newStatus, int currUserId)
        {
            // 1. 更新节点基础信息
            node.OverallStatus = newStatus;
            node.Operator = currUserId;
            node.OperationTime = DateTime.Now;

            // 2. 根据新状态处理节点和流程逻辑
            if (newStatus == ProcessStatus.InProgress)
            {
                // 设置为进行中：需要成为当前节点
                await ClearOtherCurrentNodesAsync(node.ProcessId, node.Id, currUserId);
                node.IsCurrent = true;

                // 更新流程状态为进行中
                process.OverallStatus = ProcessStatus.InProgress;
                process.UpdatedUserId = currUserId;
                process.UpdatedTime = DateTime.Now;
            }
            else if (newStatus == ProcessStatus.Completed)
            {
                // 设置为已完成：取消当前节点状态
                node.IsCurrent = false;

                // 如果是当前节点完成，需要处理流程流转
                if (node.IsCurrent || process.ProcessType == GroupProcessType.Invitation)
                {
                    await HandleNodeCompletionAsync(node, process, currUserId);
                }
                else
                {
                    // 非当前节点完成，检查流程状态
                    await CheckAndUpdateProcessStatusAsync(process, currUserId);
                }
            }
            else if (newStatus == ProcessStatus.UnStarted)
            {
                // 重置为未开始：取消当前节点状态
                node.IsCurrent = false;

                // 更新流程状态
                await CheckAndUpdateProcessStatusAsync(process, currUserId);
            }

            // 3. 保存节点更新
            await _sqlSugar.Updateable(node)
                .UpdateColumns(n => new
                {
                    n.OverallStatus,
                    n.Operator,
                    n.OperationTime,
                    n.IsCurrent
                })
                .ExecuteCommandAsync();

            // 4. 保存流程更新
            await _sqlSugar.Updateable(process)
                .UpdateColumns(p => new
                {
                    p.OverallStatus,
                    p.EndTime,
                    p.UpdatedUserId,
                    p.UpdatedTime
                })
                .ExecuteCommandAsync();
        }

        /// <summary>
        /// 处理节点完成后的流程流转（替代原来的 ProcessCurrentNodeCompletionAsync）
        /// </summary>
        private async Task HandleNodeCompletionAsync(Grp_ProcessNode currentNode, Grp_ProcessOverview process, int currUserId)
        {
            // 1. 获取所有节点
            var allNodes = await _sqlSugar.Queryable<Grp_ProcessNode>()
                .Where(x => x.IsDel == 0 && x.ProcessId == currentNode.ProcessId)
                .ToListAsync();

            // 2. 商邀流程特殊处理
            if (process.ProcessType == GroupProcessType.Invitation)
            {
                int completedCount = allNodes.Count(n => n.OverallStatus == ProcessStatus.Completed);
                int nodeCount = allNodes.Count;

                if (completedCount == nodeCount) // 所有节点完成
                {
                    process.OverallStatus = ProcessStatus.Completed;
                    process.EndTime = DateTime.Now;
                }
                else if (completedCount > 0)
                {
                    process.OverallStatus = ProcessStatus.InProgress;
                }
            }
            else
            {
                // 3. 普通流程：查找下一个节点
                var nextNode = allNodes
                    .Where(n => n.NodeOrder == currentNode.NodeOrder + 1)
                    .FirstOrDefault();

                if (nextNode != null)
                {
                    // 激活下一个节点
                    var nextNodeBefore = new Grp_ProcessNode()
                    {
                        Id = nextNode.Id,
                        ProcessId = nextNode.ProcessId,
                        NodeName = nextNode.NodeName,
                        NodeOrder = nextNode.NodeOrder,
                        OverallStatus = nextNode.OverallStatus,
                        Operator = nextNode.Operator,
                        OperationTime = nextNode.OperationTime,
                        IsCurrent = nextNode.IsCurrent,
                    };

                    nextNode.IsCurrent = true;
                    nextNode.OverallStatus = ProcessStatus.InProgress;
                    nextNode.Operator = currUserId;
                    nextNode.OperationTime = DateTime.Now;

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

                    await LogNodeOpAsync(nextNodeBefore, nextNode, "Start", currUserId);

                    process.OverallStatus = ProcessStatus.InProgress;
                }
                else
                {
                    // 没有下一个节点，流程完成
                    process.OverallStatus = ProcessStatus.Completed;
                    process.EndTime = DateTime.Now;
                }
            }

            process.UpdatedUserId = currUserId;
            process.UpdatedTime = DateTime.Now;
        }

        /// <summary>
        /// 清除其他当前节点
        /// </summary>
        private async Task ClearOtherCurrentNodesAsync(int processId, int currentNodeId, int currUserId)
        {
            var otherCurrentNodes = await _sqlSugar.Queryable<Grp_ProcessNode>()
                .Where(n => n.ProcessId == processId
                         && n.Id != currentNodeId
                         && n.IsCurrent
                         && n.IsDel == 0)
                .ToListAsync();

            foreach (var otherNode in otherCurrentNodes)
            {
                var before = new Grp_ProcessNode()
                {
                    Id = otherNode.Id,
                    ProcessId = otherNode.ProcessId,
                    NodeName = otherNode.NodeName,
                    NodeOrder = otherNode.NodeOrder,
                    OverallStatus = otherNode.OverallStatus,
                    Operator = otherNode.Operator,
                    OperationTime = otherNode.OperationTime,
                    IsCurrent = otherNode.IsCurrent,
                };

                otherNode.IsCurrent = false;

                await _sqlSugar.Updateable(otherNode)
                    .UpdateColumns(n => new { n.IsCurrent })
                    .ExecuteCommandAsync();

                await LogNodeOpAsync(before, otherNode, "Update", currUserId);
            }
        }

        /// <summary>
        /// 检查并更新流程状态
        /// </summary>
        private async Task CheckAndUpdateProcessStatusAsync(Grp_ProcessOverview process, int currUserId)
        {
            // 获取所有节点状态
            var allNodes = await _sqlSugar.Queryable<Grp_ProcessNode>()
                .Where(x => x.IsDel == 0 && x.ProcessId == process.Id)
                .ToListAsync();

            int totalCount = allNodes.Count;
            int completedCount = allNodes.Count(n => n.OverallStatus == ProcessStatus.Completed);
            int inProgressCount = allNodes.Count(n => n.OverallStatus == ProcessStatus.InProgress);

            // 更新流程状态
            if (completedCount == totalCount)
            {
                process.OverallStatus = ProcessStatus.Completed;
                process.EndTime = DateTime.Now;
            }
            else if (completedCount > 0 || inProgressCount > 0)
            {
                process.OverallStatus = ProcessStatus.InProgress;
                process.EndTime = null;
            }
            else
            {
                process.OverallStatus = ProcessStatus.UnStarted;
                process.EndTime = null;
            }

            process.UpdatedUserId = currUserId;
            process.UpdatedTime = DateTime.Now;
        }

        /// <summary>
        /// 验证节点操作权限
        /// </summary>
        private static void ValidateNodeOperation(Grp_ProcessNode node, ProcessStatus targetStatus)
        {
            // 验证状态流转是否合法
            if (node.OverallStatus == targetStatus)
            {
                throw new BusinessException($"当前节点已为{GetStatusDescription(targetStatus)}状态，无需重复操作。");
            }

            // 允许的流转规则：
            // 1. 未开始 → 进行中 → 已完成（正常流程）
            // 2. 已完成 → 进行中（回退操作）
            // 3. 进行中 → 未开始（重置操作）

            // 禁止的操作：已完成 → 未开始（需要先回到进行中）
            if (node.OverallStatus == ProcessStatus.Completed && targetStatus == ProcessStatus.UnStarted)
            {
                throw new BusinessException("已完成节点不可直接更改为未开始状态，请先更改为进行中状态。");
            }
        }

        private static string GetStatusDescription(ProcessStatus status)
        {
            return status switch
            {
                ProcessStatus.UnStarted => "未开始",
                ProcessStatus.InProgress => "进行中",
                ProcessStatus.Completed => "已完成",
                _ => "未知状态"
            };
        }

        #endregion

        /// <summary>
        /// 更新签证节点信息及状态
        /// </summary>
        /// <param name="dto">签证节点更新数据传输对象</param>
        /// <returns>操作结果</returns>
        public async Task<Result> UpdateVisaNodeDetailsAsync(GroupProcessUpdateVisaNodeDetailsDto dto)
        {
            // 1. 获取并验证节点和流程
            var node = await _sqlSugar.Queryable<Grp_ProcessNode>()
                .FirstAsync(n => n.Id == dto.NodeId && n.IsDel == 0)
                ?? throw new BusinessException("当前节点不存在或已被删除。");

            var process = await _sqlSugar.Queryable<Grp_ProcessOverview>()
                .FirstAsync(p => p.Id == node.ProcessId && p.IsDel == 0)
                ?? throw new BusinessException("当前流程不存在或已被删除。");

            if (process.ProcessType != GroupProcessType.Visa)
            {
                throw new BusinessException("当前流程节点不为签证流程，不可编辑。");
            }

            // 2. 检查签证子节点 字段信息是否全部填写
            var allSubNodesCompleted = dto.VisaSubNodes?.All(subNode => EntityExtensions.IsCompleted(subNode)) ?? false;

            // 2.1 存储更新前流程及节点信息
            var nodeBefore = new Grp_ProcessNode()
            {
                Id = node.Id,
                ProcessId = node.ProcessId,
                NodeName = node.NodeName,
                NodeOrder = node.NodeOrder,
                OverallStatus = node.OverallStatus,
                Operator = node.Operator,
                OperationTime = node.OperationTime,
                IsCurrent = node.IsCurrent,
            };

            var processBefore = new Grp_ProcessOverview()
            {
                Id = process.Id,
                GroupId = process.GroupId,
                ProcessOrder = process.ProcessOrder,
                ProcessType = process.ProcessType,
                OverallStatus = process.OverallStatus,
                StartTime = process.StartTime,
                EndTime = process.EndTime,
                UpdatedUserId = process.UpdatedUserId,
                UpdatedTime = process.UpdatedTime
            };

            // 3. 更新节点信息
            node.Remark = JsonConvert.SerializeObject(dto.VisaSubNodes);
            node.Operator = dto.CurrUserId;
            node.OperationTime = DateTime.Now;

            if (allSubNodesCompleted)
            {
                node.OverallStatus = ProcessStatus.Completed;
                process.OverallStatus = ProcessStatus.Completed;
                process.EndTime = DateTime.Now;
                process.UpdatedUserId = dto.CurrUserId;
                process.UpdatedTime = DateTime.Now;

                // 更新流程状态
                await _sqlSugar.Updateable(process)
                    .UpdateColumns(p => new
                    {
                        p.OverallStatus,
                        p.EndTime,
                        p.UpdatedUserId,
                        p.UpdatedTime
                    })
                    .ExecuteCommandAsync();
                //记录流程日志
                await LogProcessOpAsync(processBefore, process, "Update", dto.CurrUserId);
            }

            // 4. 保存节点更新
            await _sqlSugar.Updateable(node)
                .UpdateColumns(n => new
                {
                    n.Remark,
                    n.Operator,
                    n.OperationTime,
                    n.OverallStatus
                })
                .ExecuteCommandAsync();
            //记录节点日志
            await LogNodeOpAsync(nodeBefore, node, "Update", dto.CurrUserId);

            return new Result { Code = 200, Msg = "节点信息更新成功。" };
        }

        /// <summary>
        /// 更新节点信息及状态
        /// </summary>
        /// <param name="dto">更新节点信息及状态</param>
        /// <returns>操作结果</returns>
        public async Task<Result> SetActualDoneAsync(GroupProcessSetActualDoneDto dto)
        {
            int nodeId = dto.NodeId;
            var isDtNul = DateTime.TryParse(dto.ActualDone, out DateTime actualDone);
            int currUserId = dto.CurrUserId;
            bool isAssist = dto.IsAssist;
            bool isFileUp = dto.IsFileUp;
            bool isPart = dto.IsPart;

            // 1. 获取并验证节点和流程
            var node = await _sqlSugar.Queryable<Grp_ProcessNode>()
                .FirstAsync(n => n.Id == nodeId && n.IsDel == 0);

            if (node == null) return new Result { Code = 400, Msg = "当前节点不存在或已被删除。" };

            // 1.1. 用户权限验证
            if (!HasNodeOperationPermission(node, currUserId))
            {
                return new Result { Code = 400, Msg = "当前用户没有操作此节点的权限。" };
            }

            var process = await _sqlSugar.Queryable<Grp_ProcessOverview>()
                .FirstAsync(p => p.Id == node.ProcessId && p.IsDel == 0);

            if (process == null) return new Result { Code = 400, Msg = "当前流程不存在或已被删除。" };

            // 2.1 存储更新前流程及节点信息
            var nodeBefore = CloneNode(node);

            if (isDtNul)
            {
                node.ActualDone = actualDone;
            }
            else node.ActualDone = null;

            node.IsAssist = isAssist;
            node.IsFileUp = isFileUp;
            node.IsPart = isPart;
            node.Remark = dto.Remark;

            // 3. 保存节点更新
            await _sqlSugar.Updateable(node)
                .UpdateColumns(n => new
                {
                    n.ActualDone,
                    n.IsAssist,
                    n.IsFileUp,
                    n.IsPart,
                    n.Remark,
                })
                .ExecuteCommandAsync();
            //记录节点日志
            await LogNodeOpAsync(nodeBefore, node, "Update", currUserId);

            //当前节点未完成则更改节点状态为已完成
            if (node.OverallStatus == ProcessStatus.InProgress && isDtNul)
            {
                var statusResult = await UpdateNodeStatusSimpleAsync(node.Id,dto.CurrUserId);
                
                //日志记录执行结果
                _logger.LogInformation($"团组流程设置完成时间：调用更改状态接口(SetActualDoneAsync -> UpdateNodeStatusAsync):[状态变更：进行中 -> 已完成] result: Code={statusResult.Code}, Msg={statusResult.Msg}");

            }
            //当前节点 实际完成时间设置为空且当前状态为已完成 则更改当前节点状态为进行中
            else if (node.OverallStatus == ProcessStatus.Completed && !isDtNul)
            {
                var statusResult = await UpdateNodeStatusSimpleAsync(node.Id, dto.CurrUserId, ProcessStatus.InProgress);

                //日志记录执行结果
                _logger.LogInformation($"团组流程设置完成时间调：用更改状态接口(SetActualDoneAsync -> UpdateNodeStatusAsync):[状态变更：已完成 -> 进行中] result: Code={statusResult.Code}, Msg={statusResult.Msg}");

            }

            return new Result { Code = 200, Msg = "设置成功。" };
        }

        #endregion

        #region 会务流程

        /// <summary>
        /// 设置节点流程模板
        /// </summary>
        /// <param name="groupId"></param>
        /// <param name="currUserId"></param>
        /// <returns></returns>
        public async Task<List<Grp_ConfProcessOverview>> DefaultConfProcessTemps(int groupId, int currUserId)
        {
            var temps = new List<Grp_ConfProcessOverview>();

            //团组验证
            var groupInfo = await _sqlSugar.Queryable<Grp_DelegationInfo>().FirstAsync(g => g.Id == groupId);
            if (groupInfo == null) return temps;

            //// 检查是否已存在流程
            //var existingProcesses = await _sqlSugar.Queryable<Grp_ConfProcessOverview>()
            //    .Where(p => p.IsDel == 0 && p.GroupId == groupId)
            //    .ToListAsync();
            //if (existingProcesses.Any()) return temps;

            var users = await _sqlSugar.Queryable<Sys_Users>()
                .LeftJoin<Sys_Company>((u, c) => u.CompanyId == c.Id)
                .LeftJoin<Sys_Department>((u, c, d) => u.DepId == d.Id)
                .LeftJoin<Sys_JobPost>((u, c, d, jp) => u.JobPostId == jp.Id)
                .Where((u, c, d, jp) => u.IsDel == 0)
                .Select((u, c, d, jp) => new {
                    u.Id,
                    u.CnName,
                    u.CompanyId,
                    c.CompanyName,
                    u.DepId,
                    d.DepName,
                    u.JobPostId,
                    jp.JobName,
                })
                .ToListAsync();
            //节点可操作用户列表
            var nodeOpUsers = users.Where(u =>
                    u.JobName != null && u.DepName.Contains("策划部")
                ).Select(u => u.Id)
                .ToList();

            #region 会务流程
            //参与人 participators
            var defaultParticipators = new List<int>() 
            {
                213, //李新江
            };

            var defaultPorc1 = new List<Grp_ConfProcessNode>() {
                Grp_ConfProcessNode.Create(1,"方案/报价（含成本）","", ProcessStatus.InProgress,true,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(2,"项目前期比选/招投标相关文件","", ProcessStatus.InProgress,false,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(3,"参与投标","", ProcessStatus.InProgress,false,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(4,"拟定/签订合同","", ProcessStatus.InProgress,false,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(5,"场地预订/物料设计/对接活动所需的供应商/嘉宾邀约","", ProcessStatus.InProgress,false,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(6,"现场执行","", ProcessStatus.InProgress,false,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(7,"验收报告/决算表","", ProcessStatus.InProgress,false,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(8,"跟进项目收款","", ProcessStatus.InProgress,false,true, currUserId,defaultParticipators,nodeOpUsers),
                //Grp_ConfProcessNode.Create(9,"票据上传","该项目相关票据", ProcessStatus.InProgress,false,true, currUserId,defaultParticipators,nodeOpUsers),
            };

            temps.Add(Grp_ConfProcessOverview.Create(groupId, 1, ProcessStatus.InProgress, currUserId, defaultPorc1));

            var defaultPorc2 = new List<Grp_ConfProcessNode>() {
                Grp_ConfProcessNode.Create(1,"方案/报价（含成本）","", ProcessStatus.InProgress,true,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(2,"拟定/签订合同","", ProcessStatus.InProgress,false,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(3,"场地预订/物料设计/对接活动所需的供应商/嘉宾邀约","", ProcessStatus.InProgress,false,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(4,"现场执行","", ProcessStatus.InProgress,false,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(5,"验收报告/决算表","", ProcessStatus.InProgress,false,false, currUserId,defaultParticipators,nodeOpUsers),
                Grp_ConfProcessNode.Create(6,"跟进项目收款","", ProcessStatus.InProgress,false,true, currUserId,defaultParticipators,nodeOpUsers),
                //Grp_ConfProcessNode.Create(7,"票据上传","该项目相关票据", ProcessStatus.InProgress,false,true, currUserId,defaultParticipators,nodeOpUsers),
            };

            temps.Add(Grp_ConfProcessOverview.Create(groupId, 2, ProcessStatus.InProgress, currUserId, defaultPorc2));

            #endregion
            return temps;
        }

        /// <summary>
        /// 团组会务流程初始化
        /// </summary>
        /// <param name="groupId">团组Id</param>
        /// <param name="currUserId">当前用户Id</param>
        /// <param name="nodeTempId">节点模板Id</param>
        /// <returns>创建的流程信息</returns>
        public async Task<Result> ConfProcessInitAsync(int groupId, int currUserId,int nodeTempId = 1)
        {
            //团组验证
            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_ConfProcessOverview>()
                .Where(p => p.IsDel == 0 && p.GroupId == groupId)
                .ToListAsync();
            if (existingProcesses.Any())
            {
                return new Result { Code = 400, Msg = "团组会务流程已存在" };
            }

            // 定义默认的流程节点
            var temps = await DefaultConfProcessTemps(groupId, currUserId);
            if (temps == null || temps.Count < 1)
                return new Result { Code = 400, Msg = "团组会务默认流程不存在" };

            var process = temps.FirstOrDefault(x => x.ProcessOrder == nodeTempId);
            process.CreateUserId = currUserId;
            _sqlSugar.BeginTran();

            try
            {
                var processId = await _sqlSugar.Insertable(process).ExecuteReturnIdentityAsync();

                if (processId < 1)
                {
                    _sqlSugar.RollbackTran();
                    return new Result { Code = 400, Msg = "团组会务流程进度总览添加失败！" };
                }
                process.Id = processId;
                // 记录流程日志
                await LogConfProcessOpAsync(null, process, "Create", currUserId);

                var nodes = process.Nodes.Select((nodeDto, index) => new Grp_ConfProcessNode
                {
                    ProcessId = processId,
                    NodeName = nodeDto.NodeName,
                    NodeOrder = nodeDto.NodeOrder,
                    Participators = nodeDto.Participators,
                    OpUserList = nodeDto.OpUserList,
                    OverallStatus = nodeDto.OverallStatus,
                    NodeDescTips = nodeDto.NodeDescTips,
                    //Country = nodeDto.Country,
                    IsCurrent = nodeDto.IsCurrent,
                    IsFileUp = nodeDto.IsFileUp,
                    Remark = nodeDto.Remark,
                    CreateUserId = currUserId,
                }).ToList();

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

                //设置节点ID
                nodes = await _sqlSugar.Queryable<Grp_ConfProcessNode>().Where(x => x.IsDel == 0 && x.ProcessId == processId).ToListAsync();

                //记录节点日志
                foreach (var node in nodes)
                {
                    await LogConfNodeOpAsync(null, node, "Create", currUserId);
                }

                _sqlSugar.CommitTran();
                return new Result { Code = 200, Msg = "添加成功！" };
            }
            catch (Exception ex)
            {
                _sqlSugar.RollbackTran();
                return new Result { Code = 500, Msg = $"操作失败！msg：{ex.Message}" };
            }
        }

        /// <summary>
        /// 获取团组会务流程及节点详情
        /// </summary>
        /// <param name="groupId">团组Id</param>
        /// <param name="currUserId">当前用户Id</param>
        /// <returns></returns>
        public async Task<Result> ConfProcessesDetailsAsync(int groupId, int currUserId = 4)
        {
            //团组验证
            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_ConfProcessOverview>()
                .Where(p => p.IsDel == 0 && p.GroupId == groupId)
                .ToListAsync();
            if (!existingProcesses.Any())
            {
                //新建团组流程
                var res = await ConfProcessInitAsync(groupId, currUserId);
                if (res.Code != 200)
                {
                    return res;
                }
            }

            var users = await _sqlSugar.Queryable<Sys_Users>().Select(x => new { x.Id, x.CnName }).ToListAsync();

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

            // 预先构建用户字典，提升查询性能
            var userDict = users.ToDictionary(u => u.Id, u => u.CnName);
            bool isNodeTemplSwitchable = true;
            var processes = processData.Select(p =>
            {
                var orderedNodes = p.Nodes.OrderBy(n => n.NodeOrder).ToList();
                var totalNodes = orderedNodes.Count;
                isNodeTemplSwitchable = p.OverallStatus != ProcessStatus.Completed;
                return new ConfProcessOverInfoView()
                {
                    Id = p.Id,
                    GroupId = p.GroupId,
                    ProcessType = p.ProcessType,
                    ProcessName = p.ProcessType.GetEnumDescription(),
                    Nodes = orderedNodes.Select((n, index) =>
                    {
                        var isLastNode = index == totalNodes - 1;
                        // 文件上传按钮启用规则
                        bool isEnaFileUpBtn = false;
                        if (isLastNode)
                        {
                            isEnaFileUpBtn = true;
                        }

                        // 获取操作人姓名（使用字典提升性能）
                        string operatorName = "-";
                        if (n.Operator.HasValue && userDict.TryGetValue(n.Operator.Value, out var name))
                        {
                            operatorName = name;
                        }

                        return new ConfProcessNodeInfoView()
                        {
                            Id = n.Id,
                            ProcessId = n.ProcessId,
                            NodeOrder = n.NodeOrder,
                            NodeName = n.NodeName,
                            NodeDescTips = n.NodeDescTips,
                            OverallStatus = n.OverallStatus,
                            Participators = n.Participators,
                            OpUserList = n.OpUserList,
                            StatusText = n.OverallStatus.GetEnumDescription(),
                            Operator = operatorName,
                            OpeateTime = n.OperationTime?.ToString("yyyy-MM-dd HH:mm:ss") ?? "-",
                            ActualDone = n.ActualDone?.ToString("yyyy-MM-dd HH:mm:ss") ?? "",
                            IsEnaFileUpBtn = isEnaFileUpBtn,
                            IsFileUp = n.IsFileUp,      // 票据上传节点 存储值
                            Remark = n.Remark
                        };
                    }).ToList()
                };
            }).ToList();

            var view = new ConfProcessOverInfo()
            {
                IsNodeTemplSwitchable = isNodeTemplSwitchable,
                ConfProcess = processes
            };

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

        /// <summary>
        /// 更新节点模板
        /// </summary>
        /// <param name="groupId">团组Id</param>
        /// <param name="nodeTempId">节点模板Id</param>
        /// <param name="currUserId">当前用户Id</param>
        /// <returns></returns>
        public async Task<Result> ConfProcessChangeNodeTempSaveAsync(int groupId, int nodeTempId, int currUserId)
        {
            //节点模板id验证
            var nodeTempIds = new List<int>() { 1, 2 };
            if (!nodeTempIds.Contains(nodeTempId))
            {
                return new Result { Code = 400, Msg = "请传入有效的节点模板Id" };
            }

            //团组验证
            var groupInfo = await _sqlSugar.Queryable<Grp_DelegationInfo>().FirstAsync(g => g.Id == groupId);
            if (groupInfo == null)
            {
                return new Result { Code = 400, Msg = "团组不存在" };
            }

            _sqlSugar.BeginTran();
            try
            {
                // 检查是否已存在流程
                var existingProcesses = await _sqlSugar.Queryable<Grp_ConfProcessOverview>()
                    .Where(p => p.IsDel == 0 && p.GroupId == groupId)
                    .ToListAsync();
                if (existingProcesses.Any())
                {
                    // 用户权限验证
                    var firstNode = await _sqlSugar.Queryable<Grp_ConfProcessNode>().FirstAsync(x => x.IsDel == 0 && x.ProcessId == existingProcesses.FirstOrDefault().Id);
                    if (!HasConfNodeOperationPermission(firstNode, currUserId))
                    {
                        return new Result { Code = 400, Msg = "当前用户没有操作此节点的权限。" };
                    }

                    //团组会流程完成 不可切换模板
                    if (existingProcesses.Where(x => x.OverallStatus == ProcessStatus.Completed).ToList().Count > 0)
                    {
                        _sqlSugar.RollbackTran();
                        return new Result { Code = 400, Msg = $"当前团组会务流程已完成，不可切换节点模板。" };
                    }

                    //删除 原有的节点模板
                    var parentIds = existingProcesses.Select(x => x.Id).ToList();
                    var updProcesses = await _sqlSugar.Updateable<Grp_ConfProcessOverview>()
                        .SetColumns(x => x.DeleteUserId == currUserId)
                        .SetColumns(x => x.DeleteTime == DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"))
                        .SetColumns(x => x.IsDel == 1)
                        .Where(x => parentIds.Contains(x.Id))
                        .ExecuteCommandAsync();

                    var updProcessNodes = await _sqlSugar.Updateable<Grp_ConfProcessNode>()
                        .SetColumns(x => x.DeleteUserId == currUserId)
                        .SetColumns(x => x.DeleteTime == DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"))
                        .SetColumns(x => x.IsDel == 1)
                        .Where(x => parentIds.Contains(x.ProcessId))
                        .ExecuteCommandAsync();
                }

                //更新模板节点信息
                var result = await ConfProcessInitAsync(groupId,currUserId,nodeTempId);

                if (result.Code == 200)
                {
                    var infoResult = await ConfProcessesDetailsAsync(groupId, currUserId);

                    if (infoResult.Code == 200)
                    {
                        _sqlSugar.CommitTran();
                        return infoResult;
                    }

                }
                _sqlSugar.RollbackTran();
                return new Result { Code = 500, Msg = $"操作失败！Msg：{result.Msg}" };
            }
            catch (Exception ex)
            {
                _sqlSugar.RollbackTran();
                return new Result { Code = 500, Msg = $"操作失败！Msg：{ex.Message}" };
            }
        }

        #region 状态变更 可操作任意节点 进行中<-->已完成 双向变更

        /// <summary>
        /// 更新节点状态（支持任意节点状态变更，无需处理当前节点）
        /// </summary>
        /// <param name="nodeId"></param>
        /// <param name="currUserId"></param>
        /// <param name="targetStatus"></param>
        /// <returns></returns>
        public async Task<Result> UpdateConfNodeStatusSimpleAsync(int nodeId, int currUserId, ProcessStatus targetStatus = ProcessStatus.Completed)
        {
            try
            {
                var result = await _sqlSugar.Ado.UseTranAsync(async () =>
                {
                    // 1. 获取节点和流程信息
                    var node = await _sqlSugar.Queryable<Grp_ConfProcessNode>()
                        .FirstAsync(n => n.Id == nodeId && n.IsDel == 0);

                    if (node == null) return new Result { Code = StatusCodes.Status400BadRequest, Msg = "当前节点不存在或已被删除。" };

                    // 2. 用户权限验证
                    if (!HasConfNodeOperationPermission(node, currUserId))
                    {
                        return new Result { Code = StatusCodes.Status400BadRequest, Msg = "当前用户没有操作此节点的权限。" };
                    }

                    var process = await _sqlSugar.Queryable<Grp_ConfProcessOverview>()
                        .FirstAsync(p => p.Id == node.ProcessId && p.IsDel == 0);

                    if (process == null) return new Result { Code = StatusCodes.Status400BadRequest, Msg = "关联的流程不存在。" };

                    // 3. 检查是否重复操作
                    if (node.OverallStatus == targetStatus)
                    {
                        return new Result { Code = StatusCodes.Status400BadRequest, Msg = "当前节点已为{GetStatusDescription(targetStatus)}状态，无需重复操作。。" };
                    }

                    // 4. 存储更新前的值
                    var nodeBefore = CloneConfNode(node);
                    var processBefore = CloneConfProcess(process);

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

                    // 6. 保存节点更新
                    await _sqlSugar.Updateable(node)
                        .UpdateColumns(n => new
                        {
                            n.OverallStatus,
                            n.Operator,
                            n.OperationTime
                        })
                        .ExecuteCommandAsync();

                    // 7. 更新流程状态（基于所有节点的状态计算）
                    await UpdateConfProcessOverallStatusAsync(process, currUserId);

                    // 8. 记录日志
                    await LogConfNodeOpAsync(nodeBefore, node, "Update", currUserId);
                    await LogConfProcessOpAsync(processBefore, process, "Update", 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>
        /// <param name="process"></param>
        /// <param name="currUserId"></param>
        /// <returns></returns>
        private async Task UpdateConfProcessOverallStatusAsync(Grp_ConfProcessOverview process, int currUserId)
        {
            // 获取所有节点
            var allNodes = await _sqlSugar.Queryable<Grp_ConfProcessNode>()
                .Where(n => n.ProcessId == process.Id && n.IsDel == 0)
                .ToListAsync();

            // 统计节点状态
            int totalCount = allNodes.Count;
            int completedCount = allNodes.Count(n => n.OverallStatus == ProcessStatus.Completed);
            int inProgressCount = allNodes.Count(n => n.OverallStatus == ProcessStatus.InProgress);

            // 判断流程状态
            ProcessStatus newProcessStatus;

            if (completedCount == totalCount)
            {
                // 所有节点都已完成
                newProcessStatus = ProcessStatus.Completed;
                process.EndTime = DateTime.Now;
            }
            else if (inProgressCount > 0 || completedCount > 0)
            {
                // 有节点进行中或已完成
                newProcessStatus = ProcessStatus.InProgress;
                process.EndTime = null;
            }
            else
            {
                // 所有节点都未开始
                newProcessStatus = ProcessStatus.UnStarted;
                process.EndTime = null;
            }

            // 更新流程状态（只有状态变化时才更新）
            if (process.OverallStatus != newProcessStatus)
            {
                process.OverallStatus = newProcessStatus;
                process.UpdatedUserId = currUserId;
                process.UpdatedTime = DateTime.Now;

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

        /// <summary>
        /// 验证用户是否有操作节点的权限
        /// </summary>
        private static bool HasConfNodeOperationPermission(Grp_ConfProcessNode node, int userId)
        {
            // 如果 OpUserList 为空或 null，表示不限制权限
            if (node.OpUserList == null || node.OpUserList.Count == 0)
            {
                return true;
            }

            // 检查当前用户是否在权限列表中
            return node.OpUserList.Contains(userId);
        }

        /// <summary>
        /// 克隆节点对象
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        private static Grp_ConfProcessNode CloneConfNode(Grp_ConfProcessNode node)
        {
            return new Grp_ConfProcessNode()
            {
                Id = node.Id,
                ProcessId = node.ProcessId,
                NodeName = node.NodeName,
                NodeDescTips = node.NodeDescTips,
                NodeOrder = node.NodeOrder,
                OverallStatus = node.OverallStatus,
                Participators = node.Participators,
                Operator = node.Operator,
                OperationTime = node.OperationTime,
                IsCurrent = node.IsCurrent,
                ActualDone = node.ActualDone,
                IsFileUp = node.IsFileUp,
                OpUserList = node.OpUserList, 
            };
        }

        /// <summary>
        /// 克隆流程对象
        /// </summary>
        /// <param name="process"></param>
        /// <returns></returns>
        private static Grp_ConfProcessOverview CloneConfProcess(Grp_ConfProcessOverview process)
        {
            return new Grp_ConfProcessOverview()
            {
                Id = process.Id,
                GroupId = process.GroupId,
                ProcessOrder = process.ProcessOrder,
                ProcessType = process.ProcessType,
                OverallStatus = process.OverallStatus,
                StartTime = process.StartTime,
                EndTime = process.EndTime,
                UpdatedUserId = process.UpdatedUserId,
                UpdatedTime = process.UpdatedTime
            };
        }

        #endregion

        #region 更新节点状态 流程导向
        /// <summary>
        /// 更新团组会务流程节点状态
        /// </summary>
        /// <param name="nodeId">节点ID</param>
        /// <param name="currUserId">当前用户ID</param>
        /// <param name="processStatus">流程状态，默认为已完成</param>
        /// <returns>操作结果</returns>
        public async Task<Result> UpdateConfNodeStatusAsync(int nodeId, int currUserId, ProcessStatus processStatus = ProcessStatus.Completed)
        {
            try
            {
                // 使用事务确保数据一致性
                var result = await _sqlSugar.Ado.UseTranAsync(async () =>
                {
                    // 1. 获取并验证节点
                    var node = await _sqlSugar.Queryable<Grp_ConfProcessNode>()
                        .FirstAsync(n => n.Id == nodeId && n.IsDel == 0) ?? throw new BusinessException("当前节点不存在或已被删除。");

                    // 2. 获取流程信息，检查ProcessType
                    var process = await _sqlSugar.Queryable<Grp_ConfProcessOverview>()
                        .FirstAsync(p => p.Id == node.ProcessId && p.IsDel == 0) ?? throw new BusinessException("关联的流程不存在。");

                    // 3. 节点操作验证
                    ValidateConfNodeOperation(node, processStatus);

                    // 4. 存储更新前的值
                    var before = CloneConfNode(node);

                    // 5. 更新节点状态
                    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("节点状态更新失败。");
                    }

                    // 6. 记录节点日志
                    await LogConfNodeOpAsync(before, node, "Update", currUserId);

                    // 7. 如果是完成当前节点，处理流程流转
                    if (processStatus == ProcessStatus.Completed)
                    {
                        await ConfProcessCurrentNodeCompletionAsync(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>
        /// <param name="node">流程节点</param>
        /// <param name="targetStatus">目标状态</param>
        private static void ValidateConfNodeOperation(Grp_ConfProcessNode node, ProcessStatus targetStatus)
        {
            // 验证节点是否已完成
            if (node.OverallStatus == ProcessStatus.Completed)
            {
                throw new BusinessException("当前节点已完成，不可重复操作。");
            }

            // 验证状态流转是否合法（可选）
            //if (targetStatus != ProcessStatus.Completed)
            //{
            //    throw new BusinessException("未开始或者进行中的节点只能重新完成，不可进行其他操作。");
            //}

            // 验证是否尝试将已完成节点改为其他状态
            if (node.OverallStatus == ProcessStatus.Completed && targetStatus != ProcessStatus.Completed)
            {
                throw new BusinessException("已完成节点不可修改状态。");
            }
        }

        /// <summary>
        /// 处理当前会务流程节点完成后的流程流转
        /// </summary>
        private async Task ConfProcessCurrentNodeCompletionAsync(Grp_ConfProcessNode currentNode, int currUserId)
        {
            // 1. 获取流程信息
            var process = await _sqlSugar.Queryable<Grp_ConfProcessOverview>()
                .FirstAsync(p => p.Id == currentNode.ProcessId && p.IsDel == 0) ?? throw new BusinessException("关联的流程不存在。");

            var processBefore = new Grp_ConfProcessOverview()
            {
                Id = process.Id,
                GroupId = process.GroupId,
                ProcessOrder = process.ProcessOrder,
                ProcessType = process.ProcessType,
                OverallStatus = process.OverallStatus,
                StartTime = process.StartTime,
                EndTime = process.EndTime,
                UpdatedUserId = process.UpdatedUserId,
                UpdatedTime = process.UpdatedTime
            };

            // 2. 取消当前节点的当前状态
            var before = new Grp_ConfProcessNode()
            {
                Id = currentNode.Id,
                ProcessId = currentNode.ProcessId,
                NodeName = currentNode.NodeName,
                NodeOrder = currentNode.NodeOrder,
                OverallStatus = currentNode.OverallStatus,
                Operator = currentNode.Operator,
                OperationTime = currentNode.OperationTime,
                IsCurrent = currentNode.IsCurrent,
            };
            currentNode.IsCurrent = false;
            await _sqlSugar.Updateable(currentNode)
                .UpdateColumns(n => new { n.IsCurrent })
                .ExecuteCommandAsync();
            // 2.1 记录节点日志 取消当前节点状态
            await LogConfNodeOpAsync(before, currentNode, "Update", currUserId);

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

            if (nextNode != null)
            {
                var nextNodeBefore = new Grp_ConfProcessNode()
                {
                    Id = nextNode.Id,
                    ProcessId = nextNode.ProcessId,
                    NodeName = nextNode.NodeName,
                    NodeOrder = nextNode.NodeOrder,
                    OverallStatus = nextNode.OverallStatus,
                    Operator = nextNode.Operator,
                    OperationTime = nextNode.OperationTime,
                    IsCurrent = nextNode.IsCurrent,
                };

                // 激活下一个节点
                nextNode.IsCurrent = true;
                nextNode.OverallStatus = ProcessStatus.InProgress;

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

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

                // 1.1 记录节点日志 激活下一节点当前节点状态
                await LogConfNodeOpAsync(nextNodeBefore, nextNode, "Start", currUserId);

                // 更新流程状态为进行中
                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("流程状态更新失败。");
            }

            //记录流程日志
            await LogConfProcessOpAsync(processBefore, process, "Update", currUserId);
        }

        #endregion

        /// <summary>
        /// 更新节点信息
        /// </summary>
        /// <param name="dto">更新节点信息</param>
        /// <returns>操作结果</returns>
        public async Task<Result> SetNodeInfoAsync(ConfProcessSetActualDoneDto dto)
        {
            //参与人验证
            if (dto.Participators?.Any() != true) return new Result { Code = 400, Msg = "参与人不能为空。" };

            var isDtNul = DateTime.TryParse(dto.ActualDone, out DateTime actualDone);

            //if (!isDtNul) throw new BusinessException("实际操作时间为空或者格式不对。");

            int nodeId = dto.NodeId;
            int currUserId = dto.CurrUserId;
            bool isFileUp = dto.IsFileUp;

            // 1. 获取并验证节点和流程
            var node = await _sqlSugar.Queryable<Grp_ConfProcessNode>()
                .FirstAsync(n => n.Id == nodeId && n.IsDel == 0);

            if (node == null) return new Result { Code = 400, Msg = "当前节点不存在或已被删除。" };

            // 1.2. 用户权限验证
            if (!HasConfNodeOperationPermission(node, currUserId)) return new Result { Code = 400, Msg = "当前用户没有操作此节点的权限。" };

            var process = await _sqlSugar.Queryable<Grp_ConfProcessOverview>()
                .FirstAsync(p => p.Id == node.ProcessId && p.IsDel == 0);

            if (process == null) return new Result { Code = 400, Msg = "当前流程不存在或已被删除。" };

            // 2.1 存储更新前流程及节点信息
            var nodeBefore = CloneConfNode(node);

            if (isDtNul) node.ActualDone = actualDone;
            else node.ActualDone = null;

            node.IsFileUp = isFileUp;
            node.Participators = dto.Participators;
            node.Remark = dto.Remark;

            // 3. 保存节点更新
            await _sqlSugar.Updateable(node)
                .UpdateColumns(n => new
                {
                    n.ActualDone,
                    n.Participators,
                    n.IsFileUp,
                    n.Remark
                })
                .ExecuteCommandAsync();
            //记录节点日志
            await LogConfNodeOpAsync(nodeBefore, node, "Update", currUserId);

            //当前节点未完成则更改节点状态为已完成
            if (node.OverallStatus == ProcessStatus.InProgress && isDtNul)
            {
                var statusResult = await UpdateConfNodeStatusSimpleAsync(node.Id, dto.CurrUserId);

                //日志记录执行结果
                _logger.LogInformation($"团组流程设置完成时间：调用更改状态接口(SetActualDoneAsync -> UpdateNodeStatusAsync):[状态变更：进行中 -> 已完成] result: Code={statusResult.Code}, Msg={statusResult.Msg}");

            }
            //当前节点 实际完成时间设置为空且当前状态为已完成 则更改当前节点状态为进行中
            else if (node.OverallStatus == ProcessStatus.Completed && !isDtNul)
            {
                var statusResult = await UpdateConfNodeStatusSimpleAsync(node.Id, dto.CurrUserId, ProcessStatus.InProgress);

                //日志记录执行结果
                _logger.LogInformation($"团组流程设置完成时间调：用更改状态接口(SetActualDoneAsync -> UpdateNodeStatusAsync):[状态变更：已完成 -> 进行中] result: Code={statusResult.Code}, Msg={statusResult.Msg}");

            }

            return new Result { Code = 200, Msg = "设置成功。" };
        }

        #endregion

        #region 操作日志

        #region 团组流程

        /// <summary>
        /// 记录流程操作日志
        /// </summary>
        /// <param name="before">操作前</param>
        /// <param name="after">操作后</param>
        /// <param name="opType">操作类型（Create - 创建、Update - 更新、Complete - 完成）</param>
        /// <param name="operId">操作人ID</param>
        /// <returns>异步任务</returns>
        public async Task LogProcessOpAsync(Grp_ProcessOverview? before, Grp_ProcessOverview? after, string opType, int operId)
        {
            var chgDetails = GetProcessChgDetails(before, after);

            var log = new Grp_ProcessLog
            {
                ProcessId = after?.Id ?? before?.Id,
                GroupId = after?.GroupId ?? before?.GroupId ?? 0,
                OpType = opType,
                OpDesc = GenerateProcessOpDesc(opType, before, after, chgDetails),
                BeforeData = before != null ? JsonConvert.SerializeObject(before, GetJsonSettings()) : null,
                AfterData = after != null ? JsonConvert.SerializeObject(after, GetJsonSettings()) : null,
                ChgFields = string.Join(",", chgDetails.Select(x => x.FieldName)),
                CreateUserId = operId
            };

            await _sqlSugar.Insertable(log).ExecuteCommandAsync();
        }

        /// <summary>
        /// 记录节点操作日志
        /// </summary>
        /// <param name="before">操作前</param>
        /// <param name="after">操作后</param>
        /// <param name="opType">操作类型（Create - 创建、Update - 更新、Start - 启动、Complete - 完成）</param>
        /// <param name="operId">操作人ID</param>
        /// <returns>异步任务</returns>
        public async Task LogNodeOpAsync(Grp_ProcessNode? before, Grp_ProcessNode? after, string opType, int operId)
        {
            var chgDetails = GetNodeChgDetails(before, after);

            var log = new Grp_ProcessLog
            {
                NodeId = after?.Id ?? before?.Id,
                ProcessId = after?.ProcessId ?? before?.ProcessId,
                GroupId = 0, // 通过流程ID关联获取
                OpType = opType,
                OpDesc = GenerateNodeOpDesc(opType, before, after, chgDetails),
                BeforeData = before != null ? JsonConvert.SerializeObject(before, GetJsonSettings()) : null,
                AfterData = after != null ? JsonConvert.SerializeObject(before, GetJsonSettings()) : null,
                ChgFields = string.Join(",", chgDetails.Select(x => x.FieldName)),
                CreateUserId = operId
            };

            await _sqlSugar.Insertable(log).ExecuteCommandAsync();
        }

        /// <summary>
        /// 获取流程变更详情
        /// </summary>
        /// <param name="before">变更前</param>
        /// <param name="after">变更后</param>
        /// <returns>变更详情</returns>
        private List<FieldChgDetail> GetProcessChgDetails(Grp_ProcessOverview before, Grp_ProcessOverview after)
        {
            var chgDetails = new List<FieldChgDetail>();

            if (before == null || after == null) return chgDetails;

            var props = typeof(Grp_ProcessOverview).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                .Where(p => p.CanRead && p.CanWrite && !IsExclField(p.Name));

            foreach (var prop in props)
            {
                var beforeVal = prop.GetValue(before);
                var afterVal = prop.GetValue(after);

                if (!Equals(beforeVal, afterVal))
                {
                    chgDetails.Add(new FieldChgDetail
                    {
                        FieldName = prop.Name,
                        BeforeValue = FormatVal(beforeVal),
                        AfterValue = FormatVal(afterVal)
                    });
                }
            }

            return chgDetails;
        }

        /// <summary>
        /// 获取节点变更详情
        /// </summary>
        /// <param name="before">变更前</param>
        /// <param name="after">变更后</param>
        /// <returns>变更详情</returns>
        private List<FieldChgDetail> GetNodeChgDetails(Grp_ProcessNode before, Grp_ProcessNode after)
        {
            var chgDetails = new List<FieldChgDetail>();

            if (before == null || after == null) return chgDetails;

            var props = typeof(Grp_ProcessNode).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                .Where(p => p.CanRead && p.CanWrite && !IsExclField(p.Name));

            foreach (var prop in props)
            {
                var beforeVal = prop.GetValue(before);
                var afterVal = prop.GetValue(after);

                if (!Equals(beforeVal, afterVal))
                {
                    chgDetails.Add(new FieldChgDetail
                    {
                        FieldName = prop.Name,
                        BeforeValue = FormatVal(beforeVal),
                        AfterValue = FormatVal(afterVal)
                    });
                }
            }

            return chgDetails;
        }

        /// <summary>
        /// 生成流程操作描述
        /// </summary>
        /// <param name="opType">操作类型</param>
        /// <param name="before">操作前</param>
        /// <param name="after">操作后</param>
        /// <param name="chgDetails">变更详情</param>
        /// <returns>操作描述</returns>
        private string GenerateProcessOpDesc(string opType, Grp_ProcessOverview before,
            Grp_ProcessOverview after, List<FieldChgDetail> chgDetails)
        {
            var processType = after?.ProcessType ?? before?.ProcessType;
            var processName = GetProcessTypeName(processType);

            if (!chgDetails.Any())
            {
                return opType switch
                {
                    "Create" => $"创建流程：{processName}",
                    "Update" => $"更新流程：{processName} - 无变更",
                    "Start" => $"启动流程：{processName}",
                    "Complete" => $"完成流程：{processName}",
                    "Delete" => $"删除流程：{processName}",
                    _ => $"{opType}：{processName}"
                };
            }

            var chgDesc = string.Join("; ", chgDetails.Select(x =>
                $"{GetFieldDisplayName(x.FieldName)} ({x.BeforeValue} -> {x.AfterValue})"));

            return $"{GetOpTypeDisplay(opType)}：{processName} - {chgDesc}";
        }

        /// <summary>
        /// 生成节点操作描述
        /// </summary>
        /// <param name="opType">操作类型</param>
        /// <param name="before">操作前</param>
        /// <param name="after">操作后</param>
        /// <param name="chgDetails">变更详情</param>
        /// <returns>操作描述</returns>
        private string GenerateNodeOpDesc(string opType, Grp_ProcessNode before,
            Grp_ProcessNode after, List<FieldChgDetail> chgDetails)
        {
            var nodeName = after?.NodeName ?? before?.NodeName;

            if (!chgDetails.Any())
            {
                return opType switch
                {
                    "Create" => $"创建节点：{nodeName}",
                    "Update" => $"更新节点：{nodeName} - 无变更",
                    "Start" => $"启动节点：{nodeName}",
                    "Complete" => $"完成节点：{nodeName}",
                    //"Delete" => $"删除节点：{nodeName}",
                    _ => $"{opType}：{nodeName}"
                };
            }

            var chgDesc = string.Join("; ", chgDetails.Select(x =>
                $"{GetFieldDisplayName(x.FieldName)} ({x.BeforeValue} -> {x.AfterValue})"));

            return $"{GetOpTypeDisplay(opType)}：{nodeName} - {chgDesc}";
        }

        /// <summary>
        /// 获取流程类型名称
        /// </summary>
        /// <param name="processType">流程类型</param>
        /// <returns>流程名称</returns>
        private static string GetProcessTypeName(GroupProcessType? processType)
        {
            return processType switch
            {
                GroupProcessType.Invitation => "商邀报批",
                GroupProcessType.Visa => "签证",
                GroupProcessType.AirTicket => "机票",
                GroupProcessType.Hotel => "酒店",
                GroupProcessType.LocalGuide => "地接",
                GroupProcessType.FeeSettle => "费用结算",
                _ => "未知流程"
            };
        }

        /// <summary>
        /// 获取流程日志
        /// </summary>
        /// <param name="processId">流程ID</param>
        /// <returns>日志列表</returns>
        public async Task<List<Grp_ProcessLog>> GetProcessLogsAsync(int processId)
        {
            return await _sqlSugar.Queryable<Grp_ProcessLog>()
                .Where(x => x.ProcessId == processId)
                .OrderByDescending(x => x.CreateTime)
                .ToListAsync();
        }

        /// <summary>
        /// 获取团组流程日志
        /// </summary>
        /// <param name="groupId">团组ID</param>
        /// <returns>日志列表</returns>
        public async Task<List<Grp_ProcessLog>> GetGroupLogsAsync(int groupId)
        {
            return await _sqlSugar.Queryable<Grp_ProcessLog>()
                .Where(x => x.GroupId == groupId)
                .OrderByDescending(x => x.CreateTime)
                .ToListAsync();
        }

        #endregion

        #region 会务流程

        /// <summary>
        /// 记录会务流程操作日志
        /// </summary>
        /// <param name="before">操作前</param>
        /// <param name="after">操作后</param>
        /// <param name="opType">操作类型（Create - 创建、Update - 更新、Complete - 完成）</param>
        /// <param name="operId">操作人ID</param>
        /// <returns>异步任务</returns>
        public async Task LogConfProcessOpAsync(Grp_ConfProcessOverview? before, Grp_ConfProcessOverview? after, string opType, int operId)
        {
            var chgDetails = GetConfProcessChgDetails(before, after);

            var log = new Grp_ConfProcessLog
            {
                ProcessId = after?.Id ?? before?.Id,
                GroupId = after?.GroupId ?? before?.GroupId ?? 0,
                OpType = opType,
                OpDesc = GenerateConfProcessOpDesc(opType, before, after, chgDetails),
                BeforeData = before != null ? JsonConvert.SerializeObject(before, GetJsonSettings()) : null,
                AfterData = after != null ? JsonConvert.SerializeObject(after, GetJsonSettings()) : null,
                ChgFields = string.Join(",", chgDetails.Select(x => x.FieldName)),
                CreateUserId = operId
            };

            await _sqlSugar.Insertable(log).ExecuteCommandAsync();
        }

        /// <summary>
        /// 记录会务节点操作日志
        /// </summary>
        /// <param name="before">操作前</param>
        /// <param name="after">操作后</param>
        /// <param name="opType">操作类型（Create - 创建、Update - 更新、Start - 启动、Complete - 完成）</param>
        /// <param name="operId">操作人ID</param>
        /// <returns>异步任务</returns>
        public async Task LogConfNodeOpAsync(Grp_ConfProcessNode? before, Grp_ConfProcessNode? after, string opType, int operId)
        {
            var chgDetails = GetConfNodeChgDetails(before, after);

            var log = new Grp_ConfProcessLog
            {
                NodeId = after?.Id ?? before?.Id,
                ProcessId = after?.ProcessId ?? before?.ProcessId,
                GroupId = 0, // 通过流程ID关联获取
                OpType = opType,
                OpDesc = GenerateConfNodeOpDesc(opType, before, after, chgDetails),
                BeforeData = before != null ? JsonConvert.SerializeObject(before, GetJsonSettings()) : null,
                AfterData = after != null ? JsonConvert.SerializeObject(before, GetJsonSettings()) : null,
                ChgFields = string.Join(",", chgDetails.Select(x => x.FieldName)),
                CreateUserId = operId
            };

            await _sqlSugar.Insertable(log).ExecuteCommandAsync();
        }

        /// <summary>
        /// 获取流程变更详情
        /// </summary>
        /// <param name="before">变更前</param>
        /// <param name="after">变更后</param>
        /// <returns>变更详情</returns>
        private static List<FieldChgDetail> GetConfProcessChgDetails(Grp_ConfProcessOverview before, Grp_ConfProcessOverview after)
        {
            var chgDetails = new List<FieldChgDetail>();

            if (before == null || after == null) return chgDetails;

            var props = typeof(Grp_ConfProcessOverview).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                .Where(p => p.CanRead && p.CanWrite && !IsExclField(p.Name));

            foreach (var prop in props)
            {
                var beforeVal = prop.GetValue(before);
                var afterVal = prop.GetValue(after);

                if (!Equals(beforeVal, afterVal))
                {
                    chgDetails.Add(new FieldChgDetail
                    {
                        FieldName = prop.Name,
                        BeforeValue = FormatVal(beforeVal),
                        AfterValue = FormatVal(afterVal)
                    });
                }
            }

            return chgDetails;
        }

        /// <summary>
        /// 获取节点变更详情
        /// </summary>
        /// <param name="before">变更前</param>
        /// <param name="after">变更后</param>
        /// <returns>变更详情</returns>
        private static List<FieldChgDetail> GetConfNodeChgDetails(Grp_ConfProcessNode before, Grp_ConfProcessNode after)
        {
            var chgDetails = new List<FieldChgDetail>();

            if (before == null || after == null) return chgDetails;

            var props = typeof(Grp_ConfProcessNode).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                .Where(p => p.CanRead && p.CanWrite && !IsExclField(p.Name));

            foreach (var prop in props)
            {
                var beforeVal = prop.GetValue(before);
                var afterVal = prop.GetValue(after);

                if (!Equals(beforeVal, afterVal))
                {
                    chgDetails.Add(new FieldChgDetail
                    {
                        FieldName = prop.Name,
                        BeforeValue = FormatVal(beforeVal),
                        AfterValue = FormatVal(afterVal)
                    });
                }
            }

            return chgDetails;
        }

        /// <summary>
        /// 生成流程操作描述
        /// </summary>
        /// <param name="opType">操作类型</param>
        /// <param name="before">操作前</param>
        /// <param name="after">操作后</param>
        /// <param name="chgDetails">变更详情</param>
        /// <returns>操作描述</returns>
        private static string GenerateConfProcessOpDesc(string opType, Grp_ConfProcessOverview before,
            Grp_ConfProcessOverview after, List<FieldChgDetail> chgDetails)
        {
            var processType = after?.ProcessType ?? before?.ProcessType;
            var processName = GetConfProcessTypeName(processType);

            if (!chgDetails.Any())
            {
                return opType switch
                {
                    "Create" => $"创建流程：{processName}",
                    "Update" => $"更新流程：{processName} - 无变更",
                    "Start" => $"启动流程：{processName}",
                    "Complete" => $"完成流程：{processName}",
                    "Delete" => $"删除流程：{processName}",
                    _ => $"{opType}：{processName}"
                };
            }

            var chgDesc = string.Join("; ", chgDetails.Select(x =>
                $"{GetFieldDisplayName(x.FieldName)} ({x.BeforeValue} -> {x.AfterValue})"));

            return $"{GetOpTypeDisplay(opType)}：{processName} - {chgDesc}";
        }

        /// <summary>
        /// 生成节点操作描述
        /// </summary>
        /// <param name="opType">操作类型</param>
        /// <param name="before">操作前</param>
        /// <param name="after">操作后</param>
        /// <param name="chgDetails">变更详情</param>
        /// <returns>操作描述</returns>
        private static string GenerateConfNodeOpDesc(string opType, Grp_ConfProcessNode before,
            Grp_ConfProcessNode after, List<FieldChgDetail> chgDetails)
        {
            var nodeName = after?.NodeName ?? before?.NodeName;

            if (!chgDetails.Any())
            {
                return opType switch
                {
                    "Create" => $"创建节点：{nodeName}",
                    "Update" => $"更新节点：{nodeName} - 无变更",
                    "Start" => $"启动节点：{nodeName}",
                    "Complete" => $"完成节点：{nodeName}",
                    //"Delete" => $"删除节点：{nodeName}",
                    _ => $"{opType}：{nodeName}"
                };
            }

            var chgDesc = string.Join("; ", chgDetails.Select(x =>
                $"{GetFieldDisplayName(x.FieldName)} ({x.BeforeValue} -> {x.AfterValue})"));

            return $"{GetOpTypeDisplay(opType)}：{nodeName} - {chgDesc}";
        }

        /// <summary>
        /// 获取流程类型名称
        /// </summary>
        /// <param name="processType">流程类型</param>
        /// <returns>流程名称</returns>
        private static string GetConfProcessTypeName(ConfProcessType? processType)
        {
            return processType switch
            {
                ConfProcessType.Conference => "会务",
                _ => "未知流程"
            };
        }

        /// <summary>
        /// 获取会务流程日志
        /// </summary>
        /// <param name="processId">流程ID</param>
        /// <returns>日志列表</returns>
        public async Task<List<Grp_ConfProcessLog>> GetConfProcessLogsAsync(int processId)
        {
            return await _sqlSugar.Queryable<Grp_ConfProcessLog>()
                .Where(x => x.ProcessId == processId)
                .OrderByDescending(x => x.CreateTime)
                .ToListAsync();
        }

        /// <summary>
        /// 获取团组会务流程日志
        /// </summary>
        /// <param name="groupId">团组ID</param>
        /// <returns>日志列表</returns>
        public async Task<List<Grp_ConfProcessLog>> GetGroupConfLogsAsync(int groupId)
        {
            return await _sqlSugar.Queryable<Grp_ConfProcessLog>()
                .Where(x => x.GroupId == groupId)
                .OrderByDescending(x => x.CreateTime)
                .ToListAsync();
        }

        #endregion

        #region 日志私有方法

        /// <summary>
        /// 获取JSON序列化设置
        /// </summary>
        /// <returns>JSON设置</returns>
        private static JsonSerializerSettings GetJsonSettings()
        {
            return new JsonSerializerSettings
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
                NullValueHandling = NullValueHandling.Ignore,
                DateFormatString = "yyyy-MM-dd HH:mm:ss",
                Formatting = Formatting.None
            };
        }

        /// <summary>
        /// 获取操作类型显示
        /// </summary>
        /// <param name="opType">操作类型</param>
        /// <returns>显示名称</returns>
        private static string GetOpTypeDisplay(string opType)
        {
            return opType switch
            {
                "Create" => "创建",
                "Update" => "更新",
                "Start" => "启动",
                "Complete" => "完成",
                "Delete" => "删除",
                "StatusChg" => "状态变更",
                _ => opType
            };
        }

        /// <summary>
        /// 获取字段显示名称
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <returns>显示名称</returns>
        private static string GetFieldDisplayName(string fieldName)
        {
            return fieldName switch
            {
                "OverallStatus" => "状态",
                "ProcessOrder" => "流程顺序",
                "StartTime" => "开始时间",
                "EndTime" => "结束时间",
                "UpdatedUserId" => "更新人",
                "UpdatedTime" => "更新时间",
                "NodeOrder" => "节点顺序",
                "NodeName" => "节点名称",
                "NodeDescTips" => "节点描述提示",
                "IsCurrent" => "当前节点",
                "Participator" => "参与人",
                "Operator" => "操作人",
                "OperationTime" => "操作时间",
                "ActualDone" => "实际完成时间",
                "IsFileUp" => "是否上传文件(签证、机票、酒店、地接 流程结尾节点使用)",
                "IsAssist" => "是否协助(财务流程首节点使用)",
                "IsPart" => "是否参与(商邀 第五步使用)",
                _ => fieldName
            };
        }

        /// <summary>
        /// 格式化值显示
        /// </summary>
        /// <param name="value">值</param>
        /// <returns>格式化值</returns>
        private static string FormatVal(object value)
        {
            if (value == null) return "空";

            if (value is ProcessStatus status)
            {
                return status switch
                {
                    ProcessStatus.UnStarted => "未开始",
                    ProcessStatus.InProgress => "进行中",
                    ProcessStatus.Completed => "已完成",
                    _ => status.ToString()
                };
            }

            if (value is bool boolVal) return boolVal ? "是" : "否";
            if (value is DateTime dateVal) return dateVal.ToString("yyyy-MM-dd HH:mm");

            var strVal = value.ToString();
            return string.IsNullOrEmpty(strVal) ? "空" : strVal;
        }

        /// <summary>
        /// 检查是否排除字段
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <returns>是否排除</returns>
        private static bool IsExclField(string fieldName)
        {
            var exclFields = new List<string>
            {
                "Id", "CreateTime", "CreateUserId", "Nodes", "Process" // 导航属性
            };
            return exclFields.Contains(fieldName);
        }

        #endregion

        #endregion
    }
}