|
|
using DS.Module.Core.Extensions;
|
|
|
using DS.Module.UserModule;
|
|
|
using DS.WMS.Core.Flow.Dtos;
|
|
|
using DS.WMS.Core.Flow.Entity;
|
|
|
using Mapster;
|
|
|
using Newtonsoft.Json;
|
|
|
using SqlSugar;
|
|
|
|
|
|
namespace DS.WMS.Core.Flow.Method;
|
|
|
|
|
|
/// <summary>
|
|
|
///
|
|
|
/// </summary>
|
|
|
public class FlowRuntime
|
|
|
{
|
|
|
public FlowRuntime(FlowInstance instance, ISqlSugarClient _db) : this(instance, _db, null, null)
|
|
|
{
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 构造函数
|
|
|
/// </summary>
|
|
|
public FlowRuntime(FlowInstance instance, ISqlSugarClient _db, ISqlSugarClient tenantDb, IUser user)
|
|
|
{
|
|
|
db = _db;
|
|
|
BusinessId = instance.BusinessId;
|
|
|
ColumnView = instance.ColumnView;
|
|
|
this.tenantDb = tenantDb;
|
|
|
this.user = user;
|
|
|
|
|
|
InitNodes(instance.Content); //获取工作流模板内容的json对象;
|
|
|
|
|
|
CurrentNodeId = instance.ActivityId == "" ? StartNodeId : instance.ActivityId;
|
|
|
CurrentNodeType = GetNodeType(CurrentNodeId);
|
|
|
PreviousId = instance.PreviousId;
|
|
|
FlowInstanceId = instance.Id;
|
|
|
|
|
|
//会签开始节点和流程结束节点没有下一步
|
|
|
if (CurrentNodeType == 0 || CurrentNodeType == 4)
|
|
|
{
|
|
|
NextNodeId = "-1";
|
|
|
NextNodeType = -1;
|
|
|
}
|
|
|
else if (CurrentNodeType == 5)
|
|
|
{
|
|
|
NextNodeId = GetNextConditionNodeId(CurrentNode); //下一个节点
|
|
|
NextNodeType = GetNodeType(NextNodeId);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
NextNodeId = GetNextNodeId(CurrentNodeId); //下一个节点
|
|
|
NextNodeType = GetNodeType(NextNodeId);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public long BusinessId { get; set; }
|
|
|
public string ColumnView { get; set; }
|
|
|
|
|
|
ISqlSugarClient db { get; set; }
|
|
|
ISqlSugarClient tenantDb { get; set; }
|
|
|
IUser user { get; set; }
|
|
|
|
|
|
/// <summary>
|
|
|
/// 运行实例的Id
|
|
|
/// </summary>
|
|
|
public long FlowInstanceId { get; set; }
|
|
|
|
|
|
/// <summary>
|
|
|
/// 开始节点的ID
|
|
|
/// </summary>
|
|
|
public string StartNodeId { get; set; }
|
|
|
|
|
|
/// <summary>
|
|
|
/// 当前节点的ID
|
|
|
/// </summary>
|
|
|
public string CurrentNodeId { get; set; }
|
|
|
|
|
|
/// <summary>
|
|
|
/// 当前节点类型 0会签开始,1会签结束,2一般节点,开始节点,4流程运行结束
|
|
|
/// </summary>
|
|
|
public int CurrentNodeType { get; set; }
|
|
|
|
|
|
/// <summary>
|
|
|
/// 当前节点的对象
|
|
|
/// </summary>
|
|
|
public FlowChild CurrentNode => ChildNodes.First(x => x.Id == CurrentNodeId);
|
|
|
|
|
|
/// <summary>
|
|
|
/// 下一个节点
|
|
|
/// </summary>
|
|
|
public string NextNodeId { get; set; }
|
|
|
|
|
|
/// <summary>
|
|
|
/// 下一个节点类型 -1无法运行,0会签开始,1会签结束,2一般节点,4流程运行结束,5同级审批
|
|
|
/// </summary>
|
|
|
public int NextNodeType { get; set; }
|
|
|
|
|
|
/// <summary>
|
|
|
/// 下一个节点对象
|
|
|
/// </summary>
|
|
|
public FlowChild? NextNode => NextNodeId != "-1" ? ChildNodes.First(x => x.Id == NextNodeId) : null;
|
|
|
|
|
|
/// <summary>
|
|
|
/// 上一个节点
|
|
|
/// </summary>
|
|
|
public string PreviousId { get; set; }
|
|
|
|
|
|
/// <summary>
|
|
|
/// 实例节点集合
|
|
|
/// </summary>
|
|
|
public List<FlowChild> ChildNodes { get; set; }
|
|
|
|
|
|
public string? Note { get; set; }
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取工作流节点的字典列表:key节点id
|
|
|
/// </summary>
|
|
|
/// <param name="schemeContentJson"></param>
|
|
|
/// <returns></returns>
|
|
|
private void InitNodes(string schemeContentJson)
|
|
|
{
|
|
|
ChildNodes = new List<FlowChild>();
|
|
|
|
|
|
var root = JsonConvert.DeserializeObject<FlowRoot>(schemeContentJson);
|
|
|
if (root.Type == FlowChild.START)
|
|
|
{
|
|
|
StartNodeId = root.Id;
|
|
|
}
|
|
|
|
|
|
if (root.Child.IsNotNull())
|
|
|
{
|
|
|
var parent = root.Adapt<FlowChild>();
|
|
|
ChildNodes.Add(parent);
|
|
|
GetFlowChildsByParent(parent.Id, parent);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 撤销流程，清空所有节点
|
|
|
/// </summary>
|
|
|
public void Cancel()
|
|
|
{
|
|
|
foreach (var item in ChildNodes)
|
|
|
{
|
|
|
item.SetInfo = null;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private void GetFlowChildsByParent(string nodeId, FlowChild parent)
|
|
|
{
|
|
|
if (parent.Type == FlowChild.Exclusive && parent.Children.IsNotNull() && parent.Children.Count > 0)
|
|
|
{
|
|
|
foreach (var item in parent.Children)
|
|
|
{
|
|
|
ChildNodes.Add(item);
|
|
|
GetFlowChildsByParent(nodeId, item);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (parent.Child.IsNotNull())
|
|
|
{
|
|
|
ChildNodes.Add(parent.Child);
|
|
|
GetFlowChildsByParent(parent.Child.Id, parent.Child);
|
|
|
}
|
|
|
// var childs = new List<FlowChild>();
|
|
|
}
|
|
|
|
|
|
|
|
|
private List<FlowChild> GetFlowConditions(FlowChild parent)
|
|
|
{
|
|
|
var conditionNodes = new List<FlowChild>();
|
|
|
if (parent.Children != null)
|
|
|
{
|
|
|
foreach (var item in parent.Children)
|
|
|
{
|
|
|
conditionNodes.Add(item);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return conditionNodes;
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取下一个节点
|
|
|
/// <param name="nodeId"></param>
|
|
|
/// </summary>
|
|
|
private string GetNextNodeId(string nodeId = null)
|
|
|
{
|
|
|
if (nodeId == null)
|
|
|
{
|
|
|
return ChildNodes.Where(x => x.Pid == "root").First().Id;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (ChildNodes.Exists(x => x.Pid == nodeId))
|
|
|
{
|
|
|
var nextChild = ChildNodes.Where(x => x.Pid == nodeId).First();
|
|
|
if (nextChild.Type == FlowChild.Exclusive) //互斥条件
|
|
|
{
|
|
|
return GetNextConditionNodeId(nextChild); //下一个节点
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return nextChild.Id;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return ChildNodes.Where(x => x.Id == "end").First().Id;
|
|
|
}
|
|
|
// return ChildNodes.Where(x => x.Pid == nodeId).First().Id;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取下一个条件节点
|
|
|
/// </summary>
|
|
|
/// <param name="parent"></param>
|
|
|
/// <returns></returns>
|
|
|
public string GetNextConditionNodeId(FlowChild parent)
|
|
|
{
|
|
|
var conditionNodes = GetFlowConditions(parent);
|
|
|
var conditionId = string.Empty;
|
|
|
for (int i = 0; i < conditionNodes.Count; i++)
|
|
|
{
|
|
|
if (i == conditionNodes.Count - 1)
|
|
|
{
|
|
|
// return ChildNodes.Where(x => x.Pid == conditionNodes[i].Id).First().Id;
|
|
|
conditionId = conditionNodes[i].Id;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
var nodeSection = conditionNodes[i].Conditions;
|
|
|
var list = new List<ConditionalCollections>();
|
|
|
var conditionList = new List<KeyValuePair<WhereType, ConditionalModel>>(nodeSection.Conditions.Count);
|
|
|
|
|
|
var whereType = Enum.Parse<WhereType>(nodeSection.LogicalOperator, true);
|
|
|
foreach (var item in nodeSection.Conditions)
|
|
|
{
|
|
|
conditionList.Add(new KeyValuePair<WhereType, ConditionalModel>
|
|
|
(whereType,
|
|
|
new ConditionalModel
|
|
|
{
|
|
|
FieldName = item.Field,
|
|
|
ConditionalType = GetConditionalType(item.Operator),
|
|
|
FieldValue = item.Value
|
|
|
})
|
|
|
);
|
|
|
}
|
|
|
|
|
|
if (conditionList.Count > 0)
|
|
|
{
|
|
|
list.Add(new ConditionalCollections
|
|
|
{
|
|
|
ConditionalList = conditionList
|
|
|
});
|
|
|
}
|
|
|
|
|
|
var groupList = new List<KeyValuePair<WhereType, ConditionalModel>>();
|
|
|
foreach (var group in nodeSection.Groups)
|
|
|
{
|
|
|
WhereType whereType2 = Enum.Parse<WhereType>(group.LogicalOperator, true);
|
|
|
for (int j = 0; j < group.Conditions.Count; j++)
|
|
|
{
|
|
|
var item1 = group.Conditions[j];
|
|
|
groupList.Add(new KeyValuePair<WhereType, ConditionalModel>
|
|
|
(j == 0 ? whereType : whereType2,
|
|
|
new ConditionalModel
|
|
|
{
|
|
|
FieldName = item1.Field,
|
|
|
ConditionalType = GetConditionalType(item1.Operator),
|
|
|
FieldValue = item1.Value
|
|
|
})
|
|
|
);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (groupList.Count > 0)
|
|
|
{
|
|
|
list.Add(new ConditionalCollections
|
|
|
{
|
|
|
ConditionalList = groupList
|
|
|
});
|
|
|
}
|
|
|
|
|
|
if (list.Count == 0) //跳过默认条件
|
|
|
continue;
|
|
|
|
|
|
//string json = JsonConvert.SerializeObject(list);
|
|
|
//db.Utilities.JsonToConditionalModels(json);
|
|
|
List<IConditionalModel> conditionalModels = [.. list];
|
|
|
|
|
|
ISqlSugarClient sugarClient = tenantDb ?? db;
|
|
|
var exists = sugarClient.Queryable<object>().AS(ColumnView).Where("Id=@Id", new { Id = BusinessId }).Where(conditionalModels).Any();
|
|
|
if (exists)
|
|
|
{
|
|
|
conditionId = conditionNodes[i].Id;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return ChildNodes.Where(x => x.Pid == conditionId).FirstOrDefault()?.Id;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取下一个节点
|
|
|
/// </summary>
|
|
|
/// <param name="nodeId"></param>
|
|
|
/// <returns></returns>
|
|
|
public FlowChild GetNextNode(string? nodeId = null)
|
|
|
{
|
|
|
if (nodeId == null)
|
|
|
return ChildNodes.Where(x => x.Pid == "root").First();
|
|
|
|
|
|
if (ChildNodes.Exists(x => x.Pid == nodeId))
|
|
|
{
|
|
|
var nextChild = ChildNodes.Where(x => x.Pid == nodeId).First();
|
|
|
if (nextChild.Type == FlowChild.Exclusive)
|
|
|
{
|
|
|
var childId = GetNextConditionNodeId(nextChild);
|
|
|
return ChildNodes.Where(x => x.Id == childId).First(); //下一个节点
|
|
|
}
|
|
|
//todo:前端组织JSON结构有误，加入临时修复代码，待前端改正后移除
|
|
|
else if (nextChild.Type == null)
|
|
|
{
|
|
|
nextChild.Id = nextChild.Type = FlowChild.END;
|
|
|
nextChild.Name = "结束";
|
|
|
Note = "JSON结构有误，检测到没有指定类型的节点";
|
|
|
return nextChild;
|
|
|
}
|
|
|
|
|
|
return nextChild;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return ChildNodes.Where(x => x.Id == "end").First();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 转换FlowRoot
|
|
|
/// </summary>
|
|
|
/// <returns></returns>
|
|
|
public FlowRoot ToFlowRoot()
|
|
|
{
|
|
|
var root = ChildNodes.First(x => x.Id == "root");
|
|
|
|
|
|
var list = ChildNodes.Where(x => x.Id != "root").ToList();
|
|
|
var info = root.Adapt<FlowRoot>();
|
|
|
info.Child = list.First(x => x.Pid == "root");
|
|
|
UpdateChild(info.Child);
|
|
|
|
|
|
return info;
|
|
|
}
|
|
|
|
|
|
private void UpdateChild(FlowChild parent)
|
|
|
{
|
|
|
if (parent.Type == FlowChild.Exclusive)
|
|
|
{
|
|
|
if (ChildNodes.Exists(x => x.Pid == parent.Id && x.Type != "condition"))
|
|
|
{
|
|
|
var child = ChildNodes.Where(x => x.Pid == parent.Id && x.Type != "condition").First();
|
|
|
parent.Child = child;
|
|
|
UpdateChild(child);
|
|
|
}
|
|
|
|
|
|
var childs = ChildNodes.Where(x => x.Pid == parent.Id && x.Type == "condition").ToList();
|
|
|
parent.Children = childs;
|
|
|
foreach (var item in childs)
|
|
|
{
|
|
|
UpdateChild(item);
|
|
|
}
|
|
|
}
|
|
|
else if (parent.Type != FlowChild.Exclusive && ChildNodes.Exists(x => x.Pid == parent.Id))
|
|
|
{
|
|
|
var child = ChildNodes.Where(x => x.Pid == parent.Id).First();
|
|
|
parent.Child = child;
|
|
|
UpdateChild(parent.Child);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private void UpdateFlowChild(string nodeId, FlowChild parent)
|
|
|
{
|
|
|
// var childs = new List<FlowChild>();
|
|
|
if (parent.Type == FlowChild.Exclusive && parent.Children.IsNotNull() && parent.Children.Count > 0)
|
|
|
{
|
|
|
for (int i = 0; i < parent.Children.Count; i++)
|
|
|
{
|
|
|
if (parent.Children[0].Id == nodeId)
|
|
|
{
|
|
|
var newNode = ChildNodes.First(x => x.Id == nodeId);
|
|
|
parent.Children[0] = newNode;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (parent.Child.IsNotNull())
|
|
|
{
|
|
|
if (parent.Child.Id == nodeId)
|
|
|
{
|
|
|
var newNode = ChildNodes.First(x => x.Id == nodeId);
|
|
|
parent.Child = newNode;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取实例接下来运行的状态
|
|
|
/// </summary>
|
|
|
/// <returns>-1无法运行,0开始,1结束,2一般节点,4流程运行结束</returns>
|
|
|
public int GetNextNodeType()
|
|
|
{
|
|
|
if (NextNodeId != "-1")
|
|
|
{
|
|
|
return GetNodeType(NextNodeId);
|
|
|
}
|
|
|
|
|
|
return -1;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 转换SqlSugar 条件操作符
|
|
|
/// </summary>
|
|
|
/// <param name="conditionalType"></param>
|
|
|
/// <returns></returns>
|
|
|
private static ConditionalType GetConditionalType(string conditionalType)
|
|
|
{
|
|
|
switch (conditionalType)
|
|
|
{
|
|
|
//等于
|
|
|
case "equal":
|
|
|
return ConditionalType.Equal;
|
|
|
//不等于
|
|
|
case "not_equal":
|
|
|
return ConditionalType.NoEqual;
|
|
|
//大于
|
|
|
case "GreaterThan":
|
|
|
return ConditionalType.GreaterThan;
|
|
|
//大于等于
|
|
|
case "GreaterThanOrEqual":
|
|
|
return ConditionalType.GreaterThanOrEqual;
|
|
|
//小于
|
|
|
case "LessThan":
|
|
|
return ConditionalType.LessThan;
|
|
|
//小于等于
|
|
|
case "LessThanOrEqual":
|
|
|
return ConditionalType.GreaterThanOrEqual;
|
|
|
//包含
|
|
|
case "contains":
|
|
|
return ConditionalType.In;
|
|
|
//不包含
|
|
|
case "not_contain":
|
|
|
return ConditionalType.NotIn;
|
|
|
//默认
|
|
|
default:
|
|
|
return ConditionalType.Equal;
|
|
|
}
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 获取节点类型 0会签开始,1会签结束,2一般节点,3开始节点,4流程运行结束
|
|
|
/// </summary>
|
|
|
/// <param name="nodeId"></param>
|
|
|
/// <returns></returns>
|
|
|
public int GetNodeType(string nodeId)
|
|
|
{
|
|
|
switch (ChildNodes.Where(x => x.Id == nodeId).First().Type)
|
|
|
{
|
|
|
//会签开始节点
|
|
|
case FlowChild.Approval:
|
|
|
return 0;
|
|
|
//会签结束节点
|
|
|
case FlowChild.JOIN:
|
|
|
return 1;
|
|
|
//结束节点
|
|
|
case FlowChild.END:
|
|
|
return 4;
|
|
|
//开始节点
|
|
|
case FlowChild.START:
|
|
|
return 3;
|
|
|
//互斥条件
|
|
|
case FlowChild.Exclusive:
|
|
|
return 5;
|
|
|
//一般节点
|
|
|
default:
|
|
|
return 2;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//获取上一个节点
|
|
|
private FlowChild GetPreNode(string nodeId = null)
|
|
|
{
|
|
|
var child = ChildNodes.Where(x => x.Pid == nodeId).First();
|
|
|
if (child.IsNull())
|
|
|
{
|
|
|
throw new Exception("无法找到上一个点");
|
|
|
}
|
|
|
|
|
|
return child;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 驳回
|
|
|
/// </summary>
|
|
|
/// <param name="rejectType">驳回类型。null:使用节点配置的驳回类型/0:前一步/1:第一步/2：指定节点，使用NodeRejectStep</param>
|
|
|
/// <returns></returns>
|
|
|
public string RejectNode(string rejectType)
|
|
|
{
|
|
|
var node = ChildNodes.Where(x => x.Id == CurrentNodeId).First();
|
|
|
if (node.SetInfo != null && string.IsNullOrEmpty(rejectType))
|
|
|
{
|
|
|
rejectType = node.SetInfo.NodeRejectType;
|
|
|
}
|
|
|
|
|
|
if (rejectType == "0")
|
|
|
{
|
|
|
return PreviousId;
|
|
|
}
|
|
|
|
|
|
if (rejectType == "1")
|
|
|
{
|
|
|
return GetNextNodeId(StartNodeId);
|
|
|
}
|
|
|
|
|
|
return PreviousId;
|
|
|
}
|
|
|
|
|
|
///<summary>
|
|
|
/// 标记节点 1通过，2不通过，3驳回
|
|
|
/// </summary>
|
|
|
/// <param name="nodeId"></param>
|
|
|
public void MakeTagNode(string nodeId, FlowTag tag)
|
|
|
{
|
|
|
// var node = ChildNodes.First(x => x.Id == nodeId);
|
|
|
foreach (var item in ChildNodes)
|
|
|
{
|
|
|
if (item.Id == nodeId)
|
|
|
{
|
|
|
if (item.SetInfo == null)
|
|
|
{
|
|
|
item.SetInfo = new Setinfo();
|
|
|
}
|
|
|
|
|
|
item.SetInfo.Taged = tag.Taged;
|
|
|
item.SetInfo.UserId = tag.UserId;
|
|
|
item.SetInfo.UserName = tag.UserName;
|
|
|
item.SetInfo.Description = tag.Description;
|
|
|
item.SetInfo.TagedTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm");
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 节点审核
|
|
|
/// </summary>
|
|
|
/// <param name="nodeId">会签时，currentNodeId是会签开始节点。这个表示当前正在处理的节点</param>
|
|
|
/// <param name="tag">节点标签</param>
|
|
|
/// <returns>-1不通过,1等待,其它通过</returns>
|
|
|
public string NodeConfluence(string nodeId, FlowTag tag)
|
|
|
{
|
|
|
var forkNode = ChildNodes.First(x => x.Id == CurrentNodeId); //会签开始节点
|
|
|
FlowChild nextNode = GetNextNode(nodeId); //获取当前处理的下一个节点
|
|
|
|
|
|
int forkNumber = 0;
|
|
|
if (forkNode.AssigneeType == "user")
|
|
|
{
|
|
|
forkNumber = forkNode.Users.Count;
|
|
|
}
|
|
|
else if (forkNode.AssigneeType == "role")
|
|
|
{
|
|
|
forkNumber = forkNode.Roles.Count;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
forkNumber = 0;
|
|
|
}
|
|
|
|
|
|
// int forkNumber = FromNodeLines[currentNodeId].Count; //直接与会签节点连接的点，即会签分支数目
|
|
|
string res = string.Empty; //记录会签的结果,默认正在会签
|
|
|
//或签
|
|
|
if (forkNode.Multi == "single") //有一个步骤通过即可
|
|
|
{
|
|
|
if (tag.Taged == (int)TagState.Ok)
|
|
|
{
|
|
|
res = nextNode.Id;
|
|
|
}
|
|
|
else if (tag.Taged == (int)TagState.No)
|
|
|
{
|
|
|
if (forkNode.SetInfo.ConfluenceNo == null)
|
|
|
{
|
|
|
forkNode.SetInfo.ConfluenceNo = 1;
|
|
|
if (forkNode.SetInfo.ConfluenceNo == forkNumber)
|
|
|
{
|
|
|
res = TagState.No.ToString("D");
|
|
|
}
|
|
|
}
|
|
|
else if (forkNode.SetInfo.ConfluenceNo == (forkNumber - 1))
|
|
|
{
|
|
|
res = TagState.No.ToString("D");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
forkNode.SetInfo.ConfluenceNo++;
|
|
|
// bool isFirst = true; //是不是从会签开始到现在第一个
|
|
|
// var preNode = GetPreNode(nodeId);
|
|
|
// while (preNode.id != forkNode.id) //反向一直到会签开始节点
|
|
|
// {
|
|
|
// if (preNode.setInfo != null && preNode.setInfo.Taged == (int) TagState.No)
|
|
|
// {
|
|
|
// isFirst = false;
|
|
|
// break;
|
|
|
// }
|
|
|
// }
|
|
|
//
|
|
|
// if (isFirst)
|
|
|
// {
|
|
|
// forkNode.SetInfo.ConfluenceNo++;
|
|
|
// }
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
//会签
|
|
|
else //默认所有步骤通过
|
|
|
{
|
|
|
if (tag.Taged == (int)TagState.No) //只要有一个不同意，那么流程就结束
|
|
|
{
|
|
|
res = TagState.No.ToString("D");
|
|
|
}
|
|
|
else if (tag.Taged == (int)TagState.Ok)
|
|
|
{
|
|
|
//这种模式下只有坚持到【会签结束】节点之前才有意义，是否需要判定这条线所有的节点都通过，不然直接执行这个节点？？
|
|
|
if (forkNode.SetInfo.ConfluenceOk == null)
|
|
|
{
|
|
|
forkNode.SetInfo.ConfluenceOk = 1;
|
|
|
|
|
|
if (forkNode.SetInfo.ConfluenceOk == forkNumber)
|
|
|
{
|
|
|
res = nextNode.Id;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
//同一节点的会签，未达到所有审核人同意时，节点类型设置为5
|
|
|
NextNodeType = 5;
|
|
|
res = nodeId;
|
|
|
return res;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
forkNode.SetInfo.ConfluenceOk++;
|
|
|
|
|
|
if (forkNode.SetInfo.ConfluenceOk == forkNumber) //会签成功
|
|
|
{
|
|
|
res = nextNode.Id;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
//同一节点的会签，未达到所有审核人同意时，节点类型设置为5
|
|
|
NextNodeType = 5;
|
|
|
res = nodeId;
|
|
|
return res;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (res == TagState.No.ToString("D"))
|
|
|
{
|
|
|
tag.Taged = (int)TagState.No;
|
|
|
MakeTagNode(nextNode.Id, tag);
|
|
|
NextNodeId = nextNode.Id;
|
|
|
NextNodeType = GetNodeType(nextNode.Id);
|
|
|
}
|
|
|
else if (!string.IsNullOrEmpty(res)) //会签结束，标记合流节点
|
|
|
{
|
|
|
tag.Taged = (int)TagState.Ok;
|
|
|
// MakeTagNode(nextNode.Id, tag);
|
|
|
NextNodeId = res;
|
|
|
NextNodeType = GetNodeType(res);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
NextNodeId = nextNode.Id;
|
|
|
NextNodeType = GetNodeType(nextNode.Id);
|
|
|
}
|
|
|
|
|
|
return res;
|
|
|
}
|
|
|
|
|
|
internal string GetOtherUsers(FlowTag tag)
|
|
|
{
|
|
|
var forkNode = ChildNodes.First(x => x.Id == CurrentNodeId);
|
|
|
//int index = forkNode.Users.IndexOf(tag.UserId);
|
|
|
//if (index > -1 && index <= forkNode.Users.Count - 2)
|
|
|
// return forkNode.Users[index + 1];
|
|
|
|
|
|
if (!forkNode.Users.IsNullOrEmpty())
|
|
|
{
|
|
|
return string.Join(',',
|
|
|
forkNode.Users.Except([tag.UserId]));
|
|
|
}
|
|
|
|
|
|
return string.Empty;
|
|
|
}
|
|
|
} |