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
{
///
/// 团组流程总览表仓储
///
public class ProcessOverviewRepository : BaseRepository
{
private readonly IMapper _mapper;
private readonly DelegationInfoRepository _groupRep;
private readonly ILogger _logger;
public ProcessOverviewRepository(SqlSugarClient sqlSugar, IMapper mapper, ILogger logger, DelegationInfoRepository groupRep) : base(sqlSugar)
{
_mapper = mapper;
_groupRep = groupRep;
_logger = logger;
}
#region 团组流程
///
/// 基础数据初始化-团组流程
///
///
///
///
public async Task> ProcessDataInitAsync(int groupId, int currUserId, List visaCountries)
{
var processs = new List();
// 团组验证
var groupInfo = await _sqlSugar.Queryable().FirstAsync(g => g.Id == groupId);
if (groupInfo == null) return processs;
// 流程验证
var existingProcesses = await _sqlSugar.Queryable()
.Where(p => p.IsDel == 0 && p.GroupId == groupId)
.ToListAsync();
if (existingProcesses.Any()) return processs;
var users = await _sqlSugar.Queryable()
.LeftJoin((u, c) => u.CompanyId == c.Id)
.LeftJoin((u, c, d) => u.DepId == d.Id)
.LeftJoin((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();
#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 oaNodeOpUsers = users.Where(u =>
u.JobName != null && u.JobName.Contains("商邀主管")
).Select(u => u.Id).ToList();
processs.Add(
Grp_ProcessOverview.Create(groupId, 1, GroupProcessType.Invitation, ProcessStatus.InProgress, currUserId,
new List()
{
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,false, 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();
if (visaCountries != null && visaCountries.Count > 0)
{
var visaDefualtNodes = new List();
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 airNodeOpUsers = users.Where(u =>
u.JobName != null && u.JobName.Contains("机票")
).Select(u => u.Id).ToList();
processs.Add(
Grp_ProcessOverview.Create(groupId, 3, GroupProcessType.AirTicket, ProcessStatus.InProgress, currUserId,
new List()
{
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 hotelNodeOpUsers = users.Where(u =>
u.JobName != null && u.JobName.Contains("酒店")
).Select(u => u.Id).ToList();
processs.Add(
Grp_ProcessOverview.Create(groupId, 4, GroupProcessType.Hotel, ProcessStatus.InProgress, currUserId,
new List()
{
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 opNodeOpUsers = users.Where(u =>
u.JobName != null && u.JobName.Equals("OP")
).Select(u => u.Id).ToList();
processs.Add(
Grp_ProcessOverview.Create(groupId, 5, GroupProcessType.LocalGuide, ProcessStatus.InProgress, currUserId,
new List()
{
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.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;
}
///
/// 团组流程初始化
///
/// 创建流程请求参数
/// 创建的流程信息
public async Task ProcessInitAsync(int groupId, int currUserId)
{
//团组验证
var groupInfo = await _sqlSugar.Queryable().FirstAsync(g => g.Id == groupId);
if (groupInfo == null)
{
return new Result { Code = 400, Msg = "团组不存在" };
}
// 检查是否已存在流程
var existingProcesses = await _sqlSugar.Queryable()
.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().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 = "添加成功！" }; ;
}
///
/// 获取团组的所有流程及节点详情
///
/// 创建流程请求参数
/// 创建的流程信息
public async Task ProcessesDetailsAsync(int groupId)
{
//团组验证
var groupInfo = await _sqlSugar.Queryable().FirstAsync(g => g.Id == groupId);
if (groupInfo == null)
{
return new Result { Code = 400, Msg = "团组不存在" };
}
// 检查是否已存在流程
var existingProcesses = await _sqlSugar.Queryable().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().Select(x => new { x.Id, x.CnName }).ToListAsync();
var processData = await _sqlSugar.Queryable()
.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.OrderBy(n => n.NodeOrder).ToList();
var totalNodes = orderedNodes.Count;
return new
{
p.Id,
p.GroupId,
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 visaSubNodes = new();
if (p.ProcessType == GroupProcessType.Visa && n.NodeOrder == 1)
{
visaSubNodes = JsonConvert.DeserializeObject>(n.Remark ?? "[]")
?? new List();
}
// 获取操作人姓名（使用字典提升性能）
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
{
n.Id,
n.ProcessId,
n.NodeOrder,
n.NodeName,
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") ?? "",
n.OpUserList, //可操作用户列表
NodeDescTips = nodeTipsMsg,
isEnaAssistBtn, // 是否启用财务流程首节点协助按钮
n.IsAssist, // 财务流程首节点 存储值
isEnaFileUpBtn, // 是否启用上传文件按钮
n.IsFileUp, // 票据上传节点 存储值
isEnaPartBtn, // 是否启用参与按钮
n.IsPart, // 参与按钮 存储值
visaSubNodes // 签证节点类型使用
};
}).ToList()
};
}).ToList();
return new Result { Code = 200, Data = processes, Msg = "查询成功！" };
}
///
/// 节点提示消息
///
///
///
///
///
private string NodeTipsMsg(Grp_DelegationInfo groupInfo, GroupProcessType procType, int nodeOrder)
{
string msg = string.Empty;
int groupId = groupInfo.Id;
switch (procType)
{
case GroupProcessType.Invitation:
switch (nodeOrder)
{
case 1:
msg = "更新报批行程和请示，提供其他报批所需材料，4个工作日内完成。";
break;
case 2:
var custInfo = _sqlSugar.Queryable()
.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 3:
msg = "提供完整的报批全套资源。";
break;
case 4:
msg = $"请于{groupInfo.VisitDate.AddDays(-5):yyyy年MM月dd日}内完成该项工作(按进度实际公务活动落实情况，出发前5日落实公务)";
break;
case 5:
break;
case 6:
break;
case 7:
//msg = $"请于{groupInfo.VisitEndDate.AddDays(-5):yyyy年MM月dd日}内完成该项工作(团组结束前完成)";
msg = $"请于{groupInfo.VisitEndDate.AddDays(-5):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 = $"请于{groupInfo.VisitDate.AddDays(-5):yyyy年MM月dd日}内完成该项工作(团组出发前5日)";
break;
case 6:
break;
case 7:
msg = $"请于{groupInfo.VisitEndDate.AddDays(5):yyyy年MM月dd日}内完成该项工作(机票蓝联打票及上传机票超支费用账单,团组归国后5个工作日内)";
break;
case 8:
msg = $"1. 票据上传(机票报销蓝联、行程单及机票说明) \r\n 2. 请于{groupInfo.VisitEndDate.AddDays(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 = $"请于{groupInfo.StepOperationTime.Value.AddDays(2):yyyy年MM月dd日}内完成该项工作(建团后打勾确认出团的时候开始2个工作日)";
}
}
break;
case 2:
break;
case 3:
break;
case 4:
msg = $"1.行前再次确认酒店订单、付款状态及入住安排 \r\n 2.请于{groupInfo.VisitDate.AddDays(-5):yyyy年MM月dd日}内完成该项工作(团组出发前5天)";
break;
case 5:
msg = $"1.行程结束后整理酒店发票(含超支费用发票)与结算 \r\n 2.请于{groupInfo.VisitEndDate.AddDays(5):yyyy年MM月dd日}内完成该项工作(团组结束后5天内)";
break;
}
break;
case GroupProcessType.LocalGuide:
switch (nodeOrder)
{
case 1:
var airTripCodeInfo = _sqlSugar.Queryable()
.Where(x => x.IsDel == 0 && x.DiId == groupId)
.OrderByDescending(x => x.CreateTime)
.First();
msg = $"机票行程代码最后一段录入后1个工作日内。";
if (airTripCodeInfo != null)
{
msg = $"请于{airTripCodeInfo.CreateTime.AddDays(1):yyyy年MM月dd日}内完成该项工作(机票行程代码最后一段录入后1个工作日内)";
}
break;
case 2:
msg = $"1.联系并询价地接、餐厅、用车、景点等供应商 \r\n 2. 请于{groupInfo.CreateTime.AddDays(7):yyyy年MM月dd日}内完成该项工作(建团完成后7个工作日内)";
break;
case 3:
msg = $"请于{groupInfo.CreateTime.AddDays(10):yyyy年MM月dd日}内完成该项工作(上一步往后3个工作日内)";
break;
case 4:
msg = $"请于{groupInfo.CreateTime.AddDays(12):yyyy年MM月dd日}内完成该项工作(上一步往后2个工作日内)";
break;
case 5:
var backListInfo = _sqlSugar.Queryable().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 = $"请于{groupInfo.VisitEndDate.AddDays(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. 请于{groupInfo.VisitEndDate.AddDays(12):yyyy年MM月dd日}内完成该项工作(团组归国后12个工作日内)";
break;
case 4:
break;
}
break;
}
return msg;
}
#region 状态变更 可操作任意节点 进行中<-->已完成 双向变更
///
/// 更新节点状态（支持任意节点状态变更，无需处理当前节点）
///
///
///
///
///
public async Task UpdateNodeStatusSimpleAsync(int nodeId, int currUserId, ProcessStatus targetStatus = ProcessStatus.Completed)
{
try
{
var result = await _sqlSugar.Ado.UseTranAsync(async () =>
{
// 1. 获取节点和流程信息
var node = await _sqlSugar.Queryable()
.FirstAsync(n => n.Id == nodeId && n.IsDel == 0)
?? throw new BusinessException("当前节点不存在或已被删除。");
// 2. 用户权限验证
if (!HasNodeOperationPermission(node, currUserId))
{
throw new BusinessException("当前用户没有操作此节点的权限。");
}
var process = await _sqlSugar.Queryable()
.FirstAsync(p => p.Id == node.ProcessId && p.IsDel == 0)
?? throw new BusinessException("关联的流程不存在。");
// 3. 检查是否重复操作
if (node.OverallStatus == targetStatus)
{
throw new BusinessException($"当前节点已为{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 = "系统错误，请稍后重试" };
}
}
///
/// 更新流程整体状态（根据所有节点状态计算）
///
///
///
///
private async Task UpdateProcessOverallStatusAsync(Grp_ProcessOverview process, int currUserId)
{
// 获取所有节点
var allNodes = await _sqlSugar.Queryable()
.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();
}
}
///
/// 验证用户是否有操作节点的权限
///
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);
}
///
/// 克隆节点对象
///
///
///
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,
};
}
///
/// 克隆流程对象
///
///
///
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 状态变更 流程导向
///
/// 更新节点状态
///
public async Task UpdateNodeStatusAsync(int nodeId, int currUserId, ProcessStatus processStatus = ProcessStatus.Completed)
{
try
{
// 使用事务确保数据一致性
var result = await _sqlSugar.Ado.UseTranAsync(async () =>
{
// 1. 获取并验证节点
var node = await _sqlSugar.Queryable()
.FirstAsync(n => n.Id == nodeId && n.IsDel == 0)
?? throw new BusinessException("当前节点不存在或已被删除。");
// 2. 获取流程信息
var process = await _sqlSugar.Queryable()
.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 = "系统错误，请稍后重试" };
}
}
///
/// 处理从已完成回退到进行中的逻辑
///
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();
}
}
///
/// 处理正常状态更新逻辑
///
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();
}
///
/// 处理节点完成后的流程流转（替代原来的 ProcessCurrentNodeCompletionAsync）
///
private async Task HandleNodeCompletionAsync(Grp_ProcessNode currentNode, Grp_ProcessOverview process, int currUserId)
{
// 1. 获取所有节点
var allNodes = await _sqlSugar.Queryable()
.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;
}
///
/// 清除其他当前节点
///
private async Task ClearOtherCurrentNodesAsync(int processId, int currentNodeId, int currUserId)
{
var otherCurrentNodes = await _sqlSugar.Queryable()
.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);
}
}
///
/// 检查并更新流程状态
///
private async Task CheckAndUpdateProcessStatusAsync(Grp_ProcessOverview process, int currUserId)
{
// 获取所有节点状态
var allNodes = await _sqlSugar.Queryable()
.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;
}
///
/// 验证节点操作权限
///
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
///
/// 更新签证节点信息及状态
///
/// 签证节点更新数据传输对象
/// 操作结果
public async Task UpdateVisaNodeDetailsAsync(GroupProcessUpdateVisaNodeDetailsDto dto)
{
// 1. 获取并验证节点和流程
var node = await _sqlSugar.Queryable()
.FirstAsync(n => n.Id == dto.NodeId && n.IsDel == 0)
?? throw new BusinessException("当前节点不存在或已被删除。");
var process = await _sqlSugar.Queryable()
.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 = "节点信息更新成功。" };
}
///
/// 更新节点信息及状态
///
/// 更新节点信息及状态
/// 操作结果
public async Task 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()
.FirstAsync(n => n.Id == nodeId && n.IsDel == 0)
?? throw new BusinessException("当前节点不存在或已被删除。");
// 1.1. 用户权限验证
if (!HasNodeOperationPermission(node, currUserId))
{
throw new BusinessException("当前用户没有操作此节点的权限。");
}
var process = await _sqlSugar.Queryable()
.FirstAsync(p => p.Id == node.ProcessId && p.IsDel == 0)
?? throw new BusinessException("当前流程不存在或已被删除。");
// 2.1 存储更新前流程及节点信息
var nodeBefore = CloneNode(node);
if (isDtNul)
{
node.ActualDone = actualDone;
}
else node.ActualDone = null;
node.IsAssist = isAssist;
node.IsFileUp = isFileUp;
node.IsPart = isPart;
// 3. 保存节点更新
await _sqlSugar.Updateable(node)
.UpdateColumns(n => new
{
n.ActualDone,
n.IsAssist,
n.IsFileUp,
n.IsPart,
})
.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 会务流程
///
/// 设置节点流程模板
///
///
///
///
public async Task> DefaultConfProcessTemps(int groupId, int currUserId)
{
var temps = new List();
//团组验证
var groupInfo = await _sqlSugar.Queryable().FirstAsync(g => g.Id == groupId);
if (groupInfo == null) return temps;
//// 检查是否已存在流程
//var existingProcesses = await _sqlSugar.Queryable()
// .Where(p => p.IsDel == 0 && p.GroupId == groupId)
// .ToListAsync();
//if (existingProcesses.Any()) return temps;
var users = await _sqlSugar.Queryable()
.LeftJoin((u, c) => u.CompanyId == c.Id)
.LeftJoin((u, c, d) => u.DepId == d.Id)
.LeftJoin((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()
{
213, //李新江
};
var defaultPorc1 = new List() {
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.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;
}
///
/// 团组会务流程初始化
///
/// 团组Id
/// 当前用户Id
/// 节点模板Id
/// 创建的流程信息
public async Task ConfProcessInitAsync(int groupId, int currUserId,int nodeTempId = 1)
{
//团组验证
var groupInfo = await _sqlSugar.Queryable().FirstAsync(g => g.Id == groupId);
if (groupInfo == null)
{
return new Result { Code = 400, Msg = "团组不存在" };
}
// 检查是否已存在流程
var existingProcesses = await _sqlSugar.Queryable()
.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().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}" };
}
}
///
/// 获取团组会务流程及节点详情
///
/// 团组Id
/// 当前用户Id
///
public async Task ConfProcessesDetailsAsync(int groupId, int currUserId = 4)
{
//团组验证
var groupInfo = await _sqlSugar.Queryable().FirstAsync(g => g.Id == groupId);
if (groupInfo == null)
{
return new Result { Code = 400, Msg = "团组不存在" };
}
// 检查是否已存在流程
var existingProcesses = await _sqlSugar.Queryable()
.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().Select(x => new { x.Id, x.CnName }).ToListAsync();
var processData = await _sqlSugar.Queryable()
.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, // 票据上传节点 存储值
};
}).ToList()
};
}).ToList();
var view = new ConfProcessOverInfo()
{
IsNodeTemplSwitchable = isNodeTemplSwitchable,
ConfProcess = processes
};
return new Result { Code = 200, Data = view, Msg = "查询成功！" };
}
///
/// 更新节点模板
///
/// 团组Id
/// 节点模板Id
/// 当前用户Id
///
public async Task ConfProcessChangeNodeTempSaveAsync(int groupId, int nodeTempId, int currUserId)
{
//节点模板id验证
var nodeTempIds = new List() { 1, 2 };
if (!nodeTempIds.Contains(nodeTempId))
{
return new Result { Code = 400, Msg = "请传入有效的节点模板Id" };
}
//团组验证
var groupInfo = await _sqlSugar.Queryable().FirstAsync(g => g.Id == groupId);
if (groupInfo == null)
{
return new Result { Code = 400, Msg = "团组不存在" };
}
_sqlSugar.BeginTran();
try
{
// 检查是否已存在流程
var existingProcesses = await _sqlSugar.Queryable()
.Where(p => p.IsDel == 0 && p.GroupId == groupId)
.ToListAsync();
if (existingProcesses.Any())
{
// 用户权限验证
var firstNode = await _sqlSugar.Queryable().FirstAsync(x => x.IsDel == 0 && x.ProcessId == existingProcesses.FirstOrDefault().Id);
if (!HasConfNodeOperationPermission(firstNode, currUserId))
{
throw new BusinessException("当前用户没有操作此节点的权限。");
}
//团组会流程完成 不可切换模板
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()
.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()
.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 状态变更 可操作任意节点 进行中<-->已完成 双向变更
///
/// 更新节点状态（支持任意节点状态变更，无需处理当前节点）
///
///
///
///
///
public async Task UpdateConfNodeStatusSimpleAsync(int nodeId, int currUserId, ProcessStatus targetStatus = ProcessStatus.Completed)
{
try
{
var result = await _sqlSugar.Ado.UseTranAsync(async () =>
{
// 1. 获取节点和流程信息
var node = await _sqlSugar.Queryable()
.FirstAsync(n => n.Id == nodeId && n.IsDel == 0)
?? throw new BusinessException("当前节点不存在或已被删除。");
// 2. 用户权限验证
if (!HasConfNodeOperationPermission(node, currUserId))
{
throw new BusinessException("当前用户没有操作此节点的权限。");
}
var process = await _sqlSugar.Queryable()
.FirstAsync(p => p.Id == node.ProcessId && p.IsDel == 0)
?? throw new BusinessException("关联的流程不存在。");
// 3. 检查是否重复操作
if (node.OverallStatus == targetStatus)
{
throw new BusinessException($"当前节点已为{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 = "系统错误，请稍后重试" };
}
}
///
/// 更新流程整体状态（根据所有节点状态计算）
///
///
///
///
private async Task UpdateConfProcessOverallStatusAsync(Grp_ConfProcessOverview process, int currUserId)
{
// 获取所有节点
var allNodes = await _sqlSugar.Queryable()
.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();
}
}
///
/// 验证用户是否有操作节点的权限
///
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);
}
///
/// 克隆节点对象
///
///
///
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,
};
}
///
/// 克隆流程对象
///
///
///
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 更新节点状态 流程导向
///
/// 更新团组会务流程节点状态
///
/// 节点ID
/// 当前用户ID
/// 流程状态，默认为已完成
/// 操作结果
public async Task UpdateConfNodeStatusAsync(int nodeId, int currUserId, ProcessStatus processStatus = ProcessStatus.Completed)
{
try
{
// 使用事务确保数据一致性
var result = await _sqlSugar.Ado.UseTranAsync(async () =>
{
// 1. 获取并验证节点
var node = await _sqlSugar.Queryable()
.FirstAsync(n => n.Id == nodeId && n.IsDel == 0) ?? throw new BusinessException("当前节点不存在或已被删除。");
// 2. 获取流程信息，检查ProcessType
var process = await _sqlSugar.Queryable()
.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 = "系统错误，请稍后重试" };
}
}
///
/// 验证会务流程节点操作权限
///
/// 流程节点
/// 目标状态
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("已完成节点不可修改状态。");
}
}
///
/// 处理当前会务流程节点完成后的流程流转
///
private async Task ConfProcessCurrentNodeCompletionAsync(Grp_ConfProcessNode currentNode, int currUserId)
{
// 1. 获取流程信息
var process = await _sqlSugar.Queryable()
.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()
.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
///
/// 更新节点信息
///
/// 更新节点信息
/// 操作结果
public async Task SetNodeInfoAsync(ConfProcessSetActualDoneDto dto)
{
//参与人验证
if (dto.Participators?.Any() != true) throw new BusinessException("参与人不能为空。");
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()
.FirstAsync(n => n.Id == nodeId && n.IsDel == 0)
?? throw new BusinessException("当前节点不存在或已被删除。");
// 1.2. 用户权限验证
if (!HasConfNodeOperationPermission(node, currUserId))
{
throw new BusinessException("当前用户没有操作此节点的权限。");
}
var process = await _sqlSugar.Queryable()
.FirstAsync(p => p.Id == node.ProcessId && p.IsDel == 0)
?? throw new BusinessException("当前流程不存在或已被删除。");
// 2.1 存储更新前流程及节点信息
var nodeBefore = CloneConfNode(node);
if (isDtNul) node.ActualDone = actualDone;
else node.ActualDone = null;
node.IsFileUp = isFileUp;
node.Participators = dto.Participators;
// 3. 保存节点更新
await _sqlSugar.Updateable(node)
.UpdateColumns(n => new
{
n.ActualDone,
n.Participators,
n.IsFileUp,
})
.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 团组流程
///
/// 记录流程操作日志
///
/// 操作前
/// 操作后
/// 操作类型（Create - 创建、Update - 更新、Complete - 完成）
/// 操作人ID
/// 异步任务
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();
}
///
/// 记录节点操作日志
///
/// 操作前
/// 操作后
/// 操作类型（Create - 创建、Update - 更新、Start - 启动、Complete - 完成）
/// 操作人ID
/// 异步任务
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();
}
///
/// 获取流程变更详情
///
/// 变更前
/// 变更后
/// 变更详情
private List GetProcessChgDetails(Grp_ProcessOverview before, Grp_ProcessOverview after)
{
var chgDetails = new List();
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;
}
///
/// 获取节点变更详情
///
/// 变更前
/// 变更后
/// 变更详情
private List GetNodeChgDetails(Grp_ProcessNode before, Grp_ProcessNode after)
{
var chgDetails = new List();
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;
}
///
/// 生成流程操作描述
///
/// 操作类型
/// 操作前
/// 操作后
/// 变更详情
/// 操作描述
private string GenerateProcessOpDesc(string opType, Grp_ProcessOverview before,
Grp_ProcessOverview after, List 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}";
}
///
/// 生成节点操作描述
///
/// 操作类型
/// 操作前
/// 操作后
/// 变更详情
/// 操作描述
private string GenerateNodeOpDesc(string opType, Grp_ProcessNode before,
Grp_ProcessNode after, List 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}";
}
///
/// 获取流程类型名称
///
/// 流程类型
/// 流程名称
private static string GetProcessTypeName(GroupProcessType? processType)
{
return processType switch
{
GroupProcessType.Invitation => "商邀报批",
GroupProcessType.Visa => "签证",
GroupProcessType.AirTicket => "机票",
GroupProcessType.Hotel => "酒店",
GroupProcessType.LocalGuide => "地接",
GroupProcessType.FeeSettle => "费用结算",
_ => "未知流程"
};
}
///
/// 获取流程日志
///
/// 流程ID
/// 日志列表
public async Task> GetProcessLogsAsync(int processId)
{
return await _sqlSugar.Queryable()
.Where(x => x.ProcessId == processId)
.OrderByDescending(x => x.CreateTime)
.ToListAsync();
}
///
/// 获取团组流程日志
///
/// 团组ID
/// 日志列表
public async Task> GetGroupLogsAsync(int groupId)
{
return await _sqlSugar.Queryable()
.Where(x => x.GroupId == groupId)
.OrderByDescending(x => x.CreateTime)
.ToListAsync();
}
#endregion
#region 会务流程
///
/// 记录会务流程操作日志
///
/// 操作前
/// 操作后
/// 操作类型（Create - 创建、Update - 更新、Complete - 完成）
/// 操作人ID
/// 异步任务
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();
}
///
/// 记录会务节点操作日志
///
/// 操作前
/// 操作后
/// 操作类型（Create - 创建、Update - 更新、Start - 启动、Complete - 完成）
/// 操作人ID
/// 异步任务
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();
}
///
/// 获取流程变更详情
///
/// 变更前
/// 变更后
/// 变更详情
private static List GetConfProcessChgDetails(Grp_ConfProcessOverview before, Grp_ConfProcessOverview after)
{
var chgDetails = new List();
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;
}
///
/// 获取节点变更详情
///
/// 变更前
/// 变更后
/// 变更详情
private static List GetConfNodeChgDetails(Grp_ConfProcessNode before, Grp_ConfProcessNode after)
{
var chgDetails = new List();
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;
}
///
/// 生成流程操作描述
///
/// 操作类型
/// 操作前
/// 操作后
/// 变更详情
/// 操作描述
private static string GenerateConfProcessOpDesc(string opType, Grp_ConfProcessOverview before,
Grp_ConfProcessOverview after, List 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}";
}
///
/// 生成节点操作描述
///
/// 操作类型
/// 操作前
/// 操作后
/// 变更详情
/// 操作描述
private static string GenerateConfNodeOpDesc(string opType, Grp_ConfProcessNode before,
Grp_ConfProcessNode after, List 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}";
}
///
/// 获取流程类型名称
///
/// 流程类型
/// 流程名称
private static string GetConfProcessTypeName(ConfProcessType? processType)
{
return processType switch
{
ConfProcessType.Conference => "会务",
_ => "未知流程"
};
}
///
/// 获取会务流程日志
///
/// 流程ID
/// 日志列表
public async Task> GetConfProcessLogsAsync(int processId)
{
return await _sqlSugar.Queryable()
.Where(x => x.ProcessId == processId)
.OrderByDescending(x => x.CreateTime)
.ToListAsync();
}
///
/// 获取团组会务流程日志
///
/// 团组ID
/// 日志列表
public async Task> GetGroupConfLogsAsync(int groupId)
{
return await _sqlSugar.Queryable()
.Where(x => x.GroupId == groupId)
.OrderByDescending(x => x.CreateTime)
.ToListAsync();
}
#endregion
#region 日志私有方法
///
/// 获取JSON序列化设置
///
/// JSON设置
private static JsonSerializerSettings GetJsonSettings()
{
return new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
NullValueHandling = NullValueHandling.Ignore,
DateFormatString = "yyyy-MM-dd HH:mm:ss",
Formatting = Formatting.None
};
}
///
/// 获取操作类型显示
///
/// 操作类型
/// 显示名称
private static string GetOpTypeDisplay(string opType)
{
return opType switch
{
"Create" => "创建",
"Update" => "更新",
"Start" => "启动",
"Complete" => "完成",
"Delete" => "删除",
"StatusChg" => "状态变更",
_ => opType
};
}
///
/// 获取字段显示名称
///
/// 字段名
/// 显示名称
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
};
}
///
/// 格式化值显示
///
/// 值
/// 格式化值
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;
}
///
/// 检查是否排除字段
///
/// 字段名
/// 是否排除
private static bool IsExclField(string fieldName)
{
var exclFields = new List
{
"Id", "CreateTime", "CreateUserId", "Nodes", "Process" // 导航属性
};
return exclFields.Contains(fieldName);
}
#endregion
#endregion
}
}