lsm/OpenAuth.Net
1
0
Fork 0
mirror of https://gitee.com/dotnetchina/OpenAuth.Net.git synced 2025-09-18 17:48:01 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor: 将会签->网关

Browse Source
This commit is contained in:
wintel
2025-04-17 21:47:28 +08:00
parent b5bb518bd2
commit 1b0a9193d1
4 changed files with 47 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Infrastructure/Define.cs
View File

@@ -50,7 +50,7 @@
public const string NODE_TYPE_TASK = "node"; //任务节点 public const string NODE_TYPE_TASK = "node"; //任务节点
public const string NODE_TYPE_FORK = "fork"; //网关开始 public const string NODE_TYPE_FORK = "fork"; //网关开始
public const string NODE_TYPE_JOIN = "join"; //网关结束 public const string NODE_TYPE_JOIN = "join"; //网关结束
public const string NODE_TYPE_MULTI_INSTANCE = "multiInstance"; //多实例/会签节点 public const string NODE_TYPE_MULTI_INSTANCE = "multiInstance"; //多实例、会签节点
//流程实例知会用户 //流程实例知会用户
public const string INSTANCE_NOTICE_USER = "INSTANCE_NOTICE_USER"; public const string INSTANCE_NOTICE_USER = "INSTANCE_NOTICE_USER";

6
OpenAuth.App/Flow/FlowNode.cs
View File

@@ -53,18 +53,18 @@
public string Description { get; set; } public string Description { get; set; }
public string TagedTime { get; set; } public string TagedTime { get; set; }
//节点会签方式， //网关审批通过的方式，
//all/空：默认为全部通过 //all/空：默认为全部通过
//one ：至少有一个通过 //one ：至少有一个通过
public string NodeConfluenceType { get; set; } public string NodeConfluenceType { get; set; }
/// <summary> /// <summary>
/// 会签通过的个数 /// 网关通过的个数
/// </summary> /// </summary>
public int? ConfluenceOk { get; set; } public int? ConfluenceOk { get; set; }
/// <summary> /// <summary>
/// 会签拒绝的个数 /// 网关拒绝的个数
/// </summary> /// </summary>
public int? ConfluenceNo { get; set; } public int? ConfluenceNo { get; set; }

73
OpenAuth.App/Flow/FlowRuntime.cs
View File

@@ -39,7 +39,7 @@ namespace OpenAuth.App.Flow
previousId = instance.PreviousId; previousId = instance.PreviousId;
flowInstanceId = instance.Id; flowInstanceId = instance.Id;
//会签开始节点和流程结束节点没有下一步 //网关开始节点和流程结束节点没有下一步
if (GetCurrentNodeType() == Define.NODE_TYPE_FORK || GetCurrentNodeType() == Define.NODE_TYPE_END) if (GetCurrentNodeType() == Define.NODE_TYPE_FORK || GetCurrentNodeType() == Define.NODE_TYPE_END)
{ {
nextNodeId = "-1"; nextNodeId = "-1";
@@ -156,9 +156,8 @@ namespace OpenAuth.App.Flow
} }
/// <summary> /// <summary>
/// 获取实例接下来运行的状态 /// 获取实例接下来运行的节点类型
/// </summary> /// </summary>
/// <returns>-1无法运行,0会签开始,1会签结束,2一般节点,4流程运行结束</returns>
public string GetNextNodeType() public string GetNextNodeType()
{ {
if (nextNodeId != "-1") if (nextNodeId != "-1")
@@ -169,7 +168,7 @@ namespace OpenAuth.App.Flow
} }
/// <summary> /// <summary>
/// 获取节点类型 0会签开始,1会签结束,2一般节点,开始节点,4流程运行结束 /// 获取节点类型
/// </summary> /// </summary>
/// <param name="nodeId"></param> /// <param name="nodeId"></param>
/// <returns></returns> /// <returns></returns>
@@ -188,23 +187,23 @@ namespace OpenAuth.App.Flow
} }
/// <summary> /// <summary>
/// 节点会签审核 /// 审批网关开始节点
/// </summary> /// </summary>
/// <param name="nodeId">会签时，currentNodeId是会签开始节点。这个表示当前正在处理的节点</param> /// <param name="nodeId">currentNodeId是网关开始节点。这个表示当前正在处理的节点</param>
/// <param name="tag"></param> /// <param name="tag"></param>
/// <returns>-1不通过,1等待,其它通过</returns> /// <returns>-1不通过,1等待,其它通过</returns>
public string NodeConfluence(HttpClient httpClient, Tag tag) public string VerifyGatewayStart(HttpClient httpClient, Tag tag)
{ {
var user = AutofacContainerModule.GetService<IAuth>().GetCurrentUser().User; var user = AutofacContainerModule.GetService<IAuth>().GetCurrentUser().User;
//会签时的【当前节点】一直是会签开始节点 //审批网关时的【当前节点】一直是网关开始节点
//TODO: 标记会签节点的状态，这个地方感觉怪怪的 //TODO: 标记网关节点的状态，这个地方感觉怪怪的
MakeTagNode(currentNodeId, tag); MakeTagNode(currentNodeId, tag);
string canCheckId = ""; //寻找当前登录用户可审核的节点Id string canCheckId = ""; //寻找当前登录用户可审核的节点Id
foreach (string fromForkStartNodeId in FromNodeLines[currentNodeId] foreach (string fromForkStartNodeId in FromNodeLines[currentNodeId]
.Select(u => u.to)) .Select(u => u.to))
{ {
var fromForkStartNode = Nodes[fromForkStartNodeId]; //与会前开始节点直接连接的节点 var fromForkStartNode = Nodes[fromForkStartNodeId]; //与网关开始节点直接连接的节点
canCheckId = GetOneForkLineCanCheckNodeId(fromForkStartNode, tag); canCheckId = GetOneForkLineCanCheckNodeId(fromForkStartNode, tag);
if (!string.IsNullOrEmpty(canCheckId)) break; if (!string.IsNullOrEmpty(canCheckId)) break;
} }
@@ -221,18 +220,18 @@ namespace OpenAuth.App.Flow
MakeTagNode(canCheckId, tag); //标记审核节点状态 MakeTagNode(canCheckId, tag); //标记审核节点状态
var forkNode = Nodes[currentNodeId]; //会签开始节点 var forkNode = Nodes[currentNodeId]; //网关开始节点
FlowNode nextNode = GetNextNode(canCheckId); //获取当前处理的下一个节点 FlowNode nextNode = GetNextNode(canCheckId); //获取当前处理的下一个节点
int forkNumber = FromNodeLines[currentNodeId].Count; //直接与会签节点连接的点，即会签分支数目 int forkNumber = FromNodeLines[currentNodeId].Count; //直接与网关节点连接的点，即网关分支数目
string res = string.Empty; //记录会签的结果,默认正在会签 string gatewayResult = string.Empty; //记录网关审批的的结果,为空表示仍然在网关内部处理
if (forkNode.setInfo.NodeConfluenceType == "one") //有一个步骤通过即可 if (forkNode.setInfo.NodeConfluenceType == "one") //有一个步骤通过即可
{ {
if (tag.Taged == (int)TagState.Ok) if (tag.Taged == (int)TagState.Ok)
{ {
if (nextNode.type == Define.NODE_TYPE_JOIN) //下一个节点是会签结束，则该线路结束 if (nextNode.type == Define.NODE_TYPE_JOIN) //下一个节点是网关结束，则该线路结束
{ {
res = GetNextNodeId(nextNode.id); gatewayResult = GetNextNodeId(nextNode.id);
} }
} }
else if (tag.Taged == (int)TagState.No) else if (tag.Taged == (int)TagState.No)
@@ -243,13 +242,13 @@ namespace OpenAuth.App.Flow
} }
else if (forkNode.setInfo.ConfluenceNo == (forkNumber - 1)) else if (forkNode.setInfo.ConfluenceNo == (forkNumber - 1))
{ {
res = TagState.No.ToString("D"); gatewayResult = TagState.No.ToString("D");
} }
else else
{ {
bool isFirst = true; //是不是从会签开始到现在第一个 bool isFirst = true; //是不是从网关开始到现在第一个
var preNode = GetPreNode(canCheckId); var preNode = GetPreNode(canCheckId);
while (preNode.id != forkNode.id) //反向一直到会签开始节点 while (preNode.id != forkNode.id) //反向一直到网关开始节点
{ {
if (preNode.setInfo != null && preNode.setInfo.Taged == (int)TagState.No) if (preNode.setInfo != null && preNode.setInfo.Taged == (int)TagState.No)
{ {
@@ -265,23 +264,23 @@ namespace OpenAuth.App.Flow
} }
} }
} }
else //默认所有步骤通过 else //所有步骤通过
{ {
if (tag.Taged == (int)TagState.No) //只要有一个不同意，那么流程就结束 if (tag.Taged == (int)TagState.No) //只要有一个不同意，那么流程就结束
{ {
res = TagState.No.ToString("D"); gatewayResult = TagState.No.ToString("D");
} }
else if (tag.Taged == (int)TagState.Ok) else if (tag.Taged == (int)TagState.Ok)
{ {
if (nextNode.type == Define.NODE_TYPE_JOIN) //这种模式下只有坚持到【会签结束】节点之前才有意义，是否需要判定这条线所有的节点都通过，不然直接执行这个节点？？ if (nextNode.type == Define.NODE_TYPE_JOIN) //这种模式下只有坚持到【网关结束】节点之前才有意义，是否需要判定这条线所有的节点都通过，不然直接执行这个节点？？
{ {
if (forkNode.setInfo.ConfluenceOk == null) if (forkNode.setInfo.ConfluenceOk == null)
{ {
forkNode.setInfo.ConfluenceOk = 1; forkNode.setInfo.ConfluenceOk = 1;
} }
else if (forkNode.setInfo.ConfluenceOk == (forkNumber - 1)) //会签成功 else if (forkNode.setInfo.ConfluenceOk == (forkNumber - 1)) //网关成功
{ {
res = GetNextNodeId(nextNode.id); gatewayResult = GetNextNodeId(nextNode.id);
} }
else else
{ {
@@ -291,28 +290,28 @@ namespace OpenAuth.App.Flow
} }
} }
if (res == TagState.No.ToString("D")) if (gatewayResult == TagState.No.ToString("D"))
{ {
tag.Taged = (int)TagState.No; tag.Taged = (int)TagState.No;
MakeTagNode(nextNode.id, tag); MakeTagNode(nextNode.id, tag);
} }
else if (!string.IsNullOrEmpty(res)) //会签结束，标记合流节点 else if (!string.IsNullOrEmpty(gatewayResult)) //网关结束，标记合流节点
{ {
tag.Taged = (int)TagState.Ok; tag.Taged = (int)TagState.Ok;
MakeTagNode(nextNode.id, tag); MakeTagNode(nextNode.id, tag);
nextNodeId = res; nextNodeId = gatewayResult;
} }
else else
{ {
nextNodeId = nextNode.id; nextNodeId = nextNode.id;
} }
if (!string.IsNullOrEmpty(res)) //会签结束节点配置了回调，则发起通知 if (!string.IsNullOrEmpty(gatewayResult)) //网关结束节点配置了回调，则发起通知
{ {
NotifyThirdParty(httpClient, nextNode, tag); NotifyThirdParty(httpClient, nextNode, tag);
} }
return res; return gatewayResult;
} }
//获取上一个节点 //获取上一个节点
@@ -615,7 +614,7 @@ namespace OpenAuth.App.Flow
throw new Exception("无法寻找到下一个节点"); throw new Exception("无法寻找到下一个节点");
} }
if (GetNextNodeType() == Define.NODE_TYPE_FORK) //如果是会签节点 if (GetNextNodeType() == Define.NODE_TYPE_FORK) //如果是网关节点
{ {
makerList = GetForkNodeMakers(nextNodeId); makerList = GetForkNodeMakers(nextNodeId);
} }
@@ -768,7 +767,7 @@ namespace OpenAuth.App.Flow
} }
/// <summary> /// <summary>
/// 会签时，获取一条会签分支上面是否有用户可审核的节点 /// 网关时，获取一条网关分支上面是否有用户可审核的节点
/// </summary> /// </summary>
/// <param name="fromForkStartNode"></param> /// <param name="fromForkStartNode"></param>
/// <param name="tag"></param> /// <param name="tag"></param>
@@ -777,7 +776,7 @@ namespace OpenAuth.App.Flow
{ {
string canCheckId = ""; string canCheckId = "";
var node = fromForkStartNode; var node = fromForkStartNode;
do //沿一条分支线路执行，直到遇到会签结束节点 do //沿一条分支线路执行，直到遇到网关结束节点
{ {
var makerList = GetNodeMarkers(node); var makerList = GetNodeMarkers(node);
@@ -795,16 +794,16 @@ namespace OpenAuth.App.Flow
} }
/// <summary> /// <summary>
/// 获取会签开始节点的所有可执行者 /// 获取网关开始节点的所有可执行者
/// </summary> /// </summary>
/// <param name="forkNodeId">会签开始节点</param> /// <param name="forkNodeId">网关开始节点</param>
/// <returns></returns> /// <returns></returns>
public string GetForkNodeMakers(string forkNodeId) public string GetForkNodeMakers(string forkNodeId)
{ {
string makerList = ""; string makerList = "";
foreach (string fromForkStartNodeId in FromNodeLines[forkNodeId].Select(u => u.to)) foreach (string fromForkStartNodeId in FromNodeLines[forkNodeId].Select(u => u.to))
{ {
var fromForkStartNode = Nodes[fromForkStartNodeId]; //与会签开始节点直接连接的节点 var fromForkStartNode = Nodes[fromForkStartNodeId]; //与网关开始节点直接连接的节点
if (makerList != "") if (makerList != "")
{ {
makerList += ","; makerList += ",";
@@ -817,9 +816,9 @@ namespace OpenAuth.App.Flow
} }
/// <summary> /// <summary>
/// 获取会签一条线上的审核者,该审核者应该是已审核过的节点的下一个人 /// 获取网关一条线上的审核者,该审核者应该是已审核过的节点的下一个人
/// </summary> /// </summary>
/// <param name="fromForkStartNode">与会签开始节点直接连接的节点</param> /// <param name="fromForkStartNode">与网关开始节点直接连接的节点</param>
private string GetOneForkLineMakers(FlowNode fromForkStartNode) private string GetOneForkLineMakers(FlowNode fromForkStartNode)
{ {
string markers = ""; string markers = "";
@@ -845,7 +844,7 @@ namespace OpenAuth.App.Flow
if (marker == "1") if (marker == "1")
{ {
throw new Exception($"节点{node.name}是会签节点，不能用所有人,请检查!"); throw new Exception($"节点{node.name}是网关节点，不能用所有人,请检查!");
} }
if (markers != "") if (markers != "")

14
OpenAuth.App/FlowInstance/FlowInstanceApp.cs
View File

@@ -2,7 +2,7 @@
* @Author: yubaolee <yubaolee@163.com> | ahfu~ <954478625@qq.com> * @Author: yubaolee <yubaolee@163.com> | ahfu~ <954478625@qq.com>
* @Date: 2024-12-13 16:55:17 * @Date: 2024-12-13 16:55:17
* @Description: 工作流实例表操作 * @Description: 工作流实例表操作
* @LastEditTime: 2025-04-10 00:02:15 * @LastEditTime: 2025-04-17 21:37:03
* Copyright (c) 2024 by yubaolee | ahfu~ , All Rights Reserved. * Copyright (c) 2024 by yubaolee | ahfu~ , All Rights Reserved.
*/ */
@@ -330,7 +330,7 @@ namespace OpenAuth.App
if (wfruntime.GetCurrentNodeType() == Define.NODE_TYPE_FORK) //当前节点是网关开始节点 if (wfruntime.GetCurrentNodeType() == Define.NODE_TYPE_FORK) //当前节点是网关开始节点
{ {
CounterSign(wfruntime, tag, flowInstance); VerifyGatewayStart(wfruntime, tag, flowInstance);
} }
else else
{ {
@@ -388,17 +388,17 @@ namespace OpenAuth.App
} }
/// <summary> /// <summary>
/// 会签 /// 网关
/// </summary> /// </summary>
private void CounterSign(FlowRuntime wfruntime, Tag tag, FlowInstance flowInstance) private void VerifyGatewayStart(FlowRuntime wfruntime, Tag tag, FlowInstance flowInstance)
{ {
string res = wfruntime.NodeConfluence(_httpClientFactory.CreateClient(), tag); string res = wfruntime.VerifyGatewayStart(_httpClientFactory.CreateClient(), tag);
if (res == TagState.No.ToString("D")) if (res == TagState.No.ToString("D"))
{ {
flowInstance.IsFinish = FlowInstanceStatus.Disagree; flowInstance.IsFinish = FlowInstanceStatus.Disagree;
} }
else if (!string.IsNullOrEmpty(res)) //会签结束，当前活动节点变为会签结束节点的下一个节点 else if (!string.IsNullOrEmpty(res)) //网关结束，当前活动节点变为网关结束节点的下一个节点
{ {
flowInstance.PreviousId = flowInstance.ActivityId; flowInstance.PreviousId = flowInstance.ActivityId;
flowInstance.ActivityId = wfruntime.nextNodeId; flowInstance.ActivityId = wfruntime.nextNodeId;
@@ -413,7 +413,7 @@ namespace OpenAuth.App
} }
else else
{ {
//会签过程中，需要更新用户 //网关过程中，需要更新用户
flowInstance.MakerList = wfruntime.GetForkNodeMakers(wfruntime.currentNodeId); flowInstance.MakerList = wfruntime.GetForkNodeMakers(wfruntime.currentNodeId);
wfruntime.SaveTransitionHis(); wfruntime.SaveTransitionHis();
} }