wenkai.chen/tnb.server
Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加项目文件。

Browse Source
This commit is contained in:
潘飞
2023-03-13 15:00:34 +08:00
parent 42bf06ca3e
commit 1d73df3235
1205 changed files with 185078 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

387
workflow/Tnb.WorkFlow/Manager/FlowTaskNodeUtil.cs Normal file
View File

@@ -0,0 +1,387 @@
using JNPF.Common.Enums;
using JNPF.Common.Extension;
using JNPF.Common.Security;
using JNPF.FriendlyException;
using JNPF.WorkFlow.Entitys.Entity;
using JNPF.WorkFlow.Entitys.Enum;
using JNPF.WorkFlow.Entitys.Model;
using JNPF.WorkFlow.Interfaces.Repository;
namespace JNPF.WorkFlow.Manager;
public class FlowTaskNodeUtil
{
private readonly IFlowTaskRepository _flowTaskRepository;
public FlowTaskNodeUtil(IFlowTaskRepository flowTaskRepository)
{
_flowTaskRepository = flowTaskRepository;
}
#region 节点处理
/// <summary>
/// 判断分流节点是否完成
/// (因为分流节点最终只能是一个 所以只需判断下一节点中的其中一个的上节点完成情况).
/// </summary>
/// <param name="flowTaskNodeEntityList">所有节点.</param>
/// <param name="nextNodeCode">下一个节点编码.</param>
/// <param name="flowTaskNodeEntity">当前节点.</param>
/// <returns></returns>
public bool IsShuntNodeCompletion(List<FlowTaskNodeEntity> flowTaskNodeEntityList, string nextNodeCode, FlowTaskNodeEntity flowTaskNodeEntity)
{
var shuntNodeCodeList = flowTaskNodeEntityList.FindAll(x => x.NodeNext.IsNotEmptyOrNull() &&
x.NodeCode != flowTaskNodeEntity.NodeCode && x.NodeNext.Contains(nextNodeCode) && x.Completion == 0);
return shuntNodeCodeList.Count == 0;
}
/// <summary>
/// 替换审批同意任务当前节点.
/// </summary>
/// <param name="flowTaskNodeEntityList">所有节点.</param>
/// <param name="nextNodeCodeList">替换数据.</param>
/// <param name="thisStepId">源数据.</param>
/// <returns></returns>
public string GetThisStepId(List<FlowTaskNodeEntity> flowTaskNodeEntityList, List<string> nextNodeCodeList, string thisStepId)
{
var replaceNodeCodeList = new List<string>();
nextNodeCodeList.ForEach(item =>
{
var nodeCode = new List<string>();
var nodeEntityList = flowTaskNodeEntityList.FindAll(x => x.NodeNext.IsNotEmptyOrNull() && x.NodeNext.Contains(item));
nodeCode = nodeEntityList.Select(x => x.NodeCode).ToList();
replaceNodeCodeList = replaceNodeCodeList.Union(nodeCode).ToList();
});
var thisNodeList = new List<string>();
if (thisStepId.IsNotEmptyOrNull())
{
thisNodeList = thisStepId.Split(",").ToList();
}
//去除当前审批节点并添加下个节点
var list = thisNodeList.Except(replaceNodeCodeList).Union(nextNodeCodeList);
return string.Join(",", list.ToArray());
}
/// <summary>
/// 替换审批撤回当前任务节点.
/// </summary>
/// <param name="nextNodeCodeList">下一节点编码.</param>
/// <param name="thisStepId">当前待处理节点.</param>
/// <returns></returns>
public string GetRecallThisStepId(List<FlowTaskNodeEntity> nextNodeCodeList, string thisStepId)
{
var replaceNodeCodeList = new List<string>();
foreach (var item in nextNodeCodeList)
{
var nodeCode = item.NodeNext.Split(",").ToList();
replaceNodeCodeList = replaceNodeCodeList.Union(nodeCode).ToList();
}
var thisNodeList = new List<string>();
if (thisStepId.IsNotEmptyOrNull())
{
thisNodeList = thisStepId.Split(",").ToList();
}
//去除当前审批节点并添加下个节点
var list = thisNodeList.Except(replaceNodeCodeList).Union(nextNodeCodeList.Select(x => x.NodeCode));
return string.Join(",", list.ToArray());
}
/// <summary>
/// 驳回替换任务当前节点.
/// </summary>
/// <param name="flowTaskNodeEntityList">驳回节点下所有节点.</param>
/// <param name="upNodeCodes">当前节点.</param>
/// <param name="thisStepId">当前待处理节点.</param>
/// <returns></returns>
public string GetRejectThisStepId(List<FlowTaskNodeEntity> flowTaskNodeEntityList, List<string> upNodeCodes, string thisStepId)
{
// 驳回节点下所有节点编码
var removeNodeCodeList = flowTaskNodeEntityList.Select(x => x.NodeCode).ToList();
var ids = thisStepId.Split(",").ToList();
var thisNodes = ids.Except(removeNodeCodeList).Union(upNodeCodes).ToList();
return string.Join(",", thisNodes);
}
/// <summary>
/// 根据当前节点编码获取节点名称.
/// </summary>
/// <param name="flowTaskNodeEntityList">所有节点.</param>
/// <param name="thisStepId">当前待处理节点.</param>
/// <returns></returns>
public string GetThisStep(List<FlowTaskNodeEntity> flowTaskNodeEntityList, string thisStepId)
{
var ids = thisStepId.Split(",").ToList();
var nextNodeNameList = new List<string>();
foreach (var item in ids)
{
var name = flowTaskNodeEntityList.Find(x => x.NodeCode.Equals(item)).NodeName;
nextNodeNameList.Add(name);
}
return string.Join(",", nextNodeNameList);
}
/// <summary>
/// 获取驳回节点.
/// </summary>
/// <param name="flowTaskParamter">任务参数.</param>
/// <returns></returns>
public List<FlowTaskNodeEntity> GetRejectNode(FlowTaskParamter flowTaskParamter)
{
//驳回节点(除了上一节点，所有驳回节点都是单节点)
var upflowTaskNodeEntityList = new List<FlowTaskNodeEntity>();
if (flowTaskParamter.flowTaskNodeEntity.NodeUp == "1")
{
upflowTaskNodeEntityList = flowTaskParamter.flowTaskNodeEntityList.FindAll(x => x.NodeNext.IsNotEmptyOrNull() && x.NodeNext.Contains(flowTaskParamter.flowTaskNodeEntity.NodeCode));
}
else
{
var upflowTaskNodeEntity = flowTaskParamter.flowTaskNodeEntityList.Find(x => x.NodeCode == flowTaskParamter.rejectStep);
upflowTaskNodeEntityList.Add(upflowTaskNodeEntity);
}
return upflowTaskNodeEntityList;
}
/// <summary>
/// 修改节点完成状态.
/// </summary>
/// <param name="taskNodeList">修改节点.</param>
/// <param name="state">状态.</param>
/// <returns></returns>
public async Task RejectUpdateTaskNode(List<FlowTaskNodeEntity> taskNodeList, int state)
{
foreach (var item in taskNodeList)
{
item.Completion = state;
await _flowTaskRepository.UpdateTaskNode(item);
}
}
/// <summary>
/// 处理并保存节点.
/// </summary>
/// <param name="entitys">节点list.</param>
public void UpdateNodeSort(List<FlowTaskNodeEntity> entitys)
{
var startNodes = entitys.FindAll(x => x.NodeType.Equals("start"));
if (startNodes.Count > 0)
{
var startNode = startNodes[0].NodeCode;
long num = 0L;
long maxNum = 0L;
var max = new List<long>();
var _treeList = new List<FlowTaskNodeEntity>();
NodeList(entitys, startNode, _treeList, num, max);
max.Sort();
if (max.Count > 0)
{
maxNum = max[max.Count - 1];
}
var nodeNext = "end";
foreach (var item in entitys)
{
var type = item.NodeType;
var node = _treeList.Find(x => x.NodeCode.Equals(item.NodeCode));
if (item.NodeNext.IsEmpty())
{
item.NodeNext = nodeNext;
}
if (node.IsNotEmptyOrNull())
{
item.SortCode = node.SortCode;
item.State = "0";
if (item.NodeNext.IsEmpty())
{
item.NodeNext = nodeNext;
}
}
}
entitys.Add(new FlowTaskNodeEntity()
{
Id = SnowflakeIdHelper.NextId(),
NodeCode = nodeNext,
NodeName = "结束",
Completion = 0,
CreatorTime = DateTime.Now,
SortCode = maxNum + 1,
TaskId = _treeList[0].TaskId,
NodePropertyJson = startNodes[0].NodePropertyJson,
NodeType = "endround",
State = "0"
});
}
}
/// <summary>
/// 递归获取经过的节点.
/// </summary>
/// <param name="dataAll">所有节点.</param>
/// <param name="nodeCode">节点编码.</param>
/// <param name="_treeList">节点集合(容器).</param>
/// <param name="num">递归次数.</param>
/// <param name="max">递归次数值.</param>
public void NodeList(List<FlowTaskNodeEntity> dataAll, string nodeCode, List<FlowTaskNodeEntity> _treeList, long num, List<long> max)
{
num++;
max.Add(num);
foreach (var item in dataAll)
{
if (item.NodeCode.Contains(nodeCode))
{
item.SortCode = num;
item.State = "0";
_treeList.Add(item);
foreach (var nodeNext in item.NodeNext.Split(","))
{
long nums = _treeList.FindAll(x => x.NodeCode.Equals(nodeNext)).Count;
if (nodeNext.IsNotEmptyOrNull() && nums == 0)
{
NodeList(dataAll, nodeNext, _treeList, num, max);
}
}
}
}
}
/// <summary>
/// 递归节点下所有节点.
/// </summary>
/// <param name="flowTaskNodeList">所有节点.</param>
/// <param name="nodeNext">下一节点.</param>
/// <param name="flowTaskNodeEntities">指定节点下所有节点.</param>
public async Task GetAllNextNode(List<FlowTaskNodeEntity> flowTaskNodeList, string nodeNext, List<FlowTaskNodeEntity> flowTaskNodeEntities)
{
var nextNodes = nodeNext.Split(",").ToList();
var flowTaskNodeEntityList = flowTaskNodeList.FindAll(x => nextNodes.Contains(x.NodeCode));
flowTaskNodeEntities.AddRange(flowTaskNodeEntityList);
foreach (var item in flowTaskNodeEntityList)
{
if (!FlowTaskNodeTypeEnum.end.ParseToString().Equals(item.NodeCode))
{
await GetAllNextNode(flowTaskNodeList, item.NodeNext, flowTaskNodeEntities);
}
}
}
/// <summary>
/// 递归节点.
/// </summary>
/// <param name="flowTaskNodeList">所有节点.</param>
/// <param name="nodeCode">当前节点.</param>
/// <param name="flowTaskNodeEntities">指定节点下所有节点.</param>
/// <param name="isUp">向上递归.</param>
public async Task RecursiveNode(List<FlowTaskNodeEntity> flowTaskNodeList, string nodeCode, List<FlowTaskNodeEntity> flowTaskNodeEntities, bool isUp = false)
{
var thisNodeEntity = flowTaskNodeList.Find(x => x.NodeCode == nodeCode);
var flowTaskNodeEntityList = new List<FlowTaskNodeEntity>();
var nodeType = string.Empty;
if (isUp)
{
flowTaskNodeEntityList = flowTaskNodeList.FindAll(x => !FlowTaskNodeTypeEnum.end.ParseToString().Equals(x.NodeCode) && x.NodeNext.Contains(nodeCode));
nodeType = FlowTaskNodeTypeEnum.start.ParseToString();
}
else
{
var nextNodes = thisNodeEntity.NodeNext.Split(",").ToList();
flowTaskNodeEntityList = flowTaskNodeList.FindAll(x => nextNodes.Contains(x.NodeCode));
nodeType = FlowTaskNodeTypeEnum.end.ParseToString();
}
foreach (var item in flowTaskNodeEntityList)
{
if (!flowTaskNodeEntities.Any(x => x.Id == item.Id))
{
flowTaskNodeEntities.Add(item);
}
if (!nodeType.Equals(item.NodeCode))
{
await RecursiveNode(flowTaskNodeList, item.NodeCode, flowTaskNodeEntities, isUp);
}
}
}
/// <summary>
/// 根据选择分支变更节点.
/// </summary>
/// <param name="flowTaskParamter">任务参数.</param>
public async Task ChangeNodeListByBranch(FlowTaskParamter flowTaskParamter)
{
if (flowTaskParamter.branchList.IsNotEmptyOrNull() && flowTaskParamter.branchList.Count > 0)
{
flowTaskParamter.flowTaskNodeEntityList.RemoveAll(x => FlowTaskNodeTypeEnum.end.ParseToString().Equals(x.NodeCode));
foreach (var item in flowTaskParamter.flowTaskNodeEntityList)
{
if (flowTaskParamter.flowTaskNodeEntity.Id.IsNotEmptyOrNull() && flowTaskParamter.flowTaskNodeEntity.Id.Equals(item.Id))
{
item.NodeNext = string.Join(",", flowTaskParamter.branchList);
}
item.State = "1";
item.SortCode = null;
}
UpdateNodeSort(flowTaskParamter.flowTaskNodeEntityList);
await _flowTaskRepository.UpdateTaskNode(flowTaskParamter.flowTaskNodeEntityList);
//重新获取当前节点
flowTaskParamter.flowTaskNodeEntity = flowTaskParamter.flowTaskNodeEntityList.Find(x => x.Id == flowTaskParamter.flowTaskNodeEntity.Id);
}
}
/// <summary>
/// 驳回处理.
/// </summary>
/// <param name="flowTaskParamter">任务参数.</param>
/// <param name="rejectNodeList">驳回节点.</param>
/// <param name="rejectNodeCodeList">驳回节点编码.</param>
/// <param name="rejectNodeCompletion">驳回节点完成度.</param>
/// <returns></returns>
public async Task<List<FlowTaskNodeEntity>> RejectManager(FlowTaskParamter flowTaskParamter, List<FlowTaskNodeEntity> rejectNodeList, List<string> rejectNodeCodeList, List<int> rejectNodeCompletion)
{
if (!rejectNodeList.Any()) throw Oops.Oh(ErrorCode.WF0032);
// 保存驳回现有数据.
if (flowTaskParamter.approversProperties.rejectType == 2)
{
flowTaskParamter.flowTaskEntity.RejectDataId = await _flowTaskRepository.CreateRejectData(flowTaskParamter.flowTaskEntity.Id, flowTaskParamter.flowTaskEntity.ThisStepId);
}
// 驳回节点下所有节点.
var rejectNodeNextAllList = new List<FlowTaskNodeEntity>();
await GetAllNextNode(flowTaskParamter.flowTaskNodeEntityList, rejectNodeList.FirstOrDefault().NodeNext, rejectNodeNextAllList);
// 驳回到发起
if (rejectNodeList.Any(x => FlowTaskNodeTypeEnum.start.ParseToString().Equals(x.NodeType)))
{
flowTaskParamter.flowTaskEntity.ThisStepId = rejectNodeList.FirstOrDefault().NodeCode;
flowTaskParamter.flowTaskEntity.ThisStep = "开始";
flowTaskParamter.flowTaskEntity.Completion = 0;
flowTaskParamter.flowTaskEntity.FlowUrgent = 0;
flowTaskParamter.flowTaskEntity.Status = FlowTaskStatusEnum.Reject.ParseToInt();
}
else
{
// 清空驳回节点下所有节点候选人/异常节点处理人
if (flowTaskParamter.approversProperties.rejectType == 1)
{
_flowTaskRepository.DeleteFlowCandidates(x => rejectNodeNextAllList.Select(x => x.Id).Contains(x.TaskNodeId));
}
flowTaskParamter.flowTaskEntity.Completion = rejectNodeCompletion.Min();
if (flowTaskParamter.flowTaskNodeEntity.NodeUp == "1")
{
flowTaskParamter.flowTaskEntity.ThisStepId = GetRejectThisStepId(rejectNodeNextAllList, rejectNodeCodeList, flowTaskParamter.flowTaskEntity.ThisStepId);
flowTaskParamter.flowTaskEntity.ThisStep = GetThisStep(flowTaskParamter.flowTaskNodeEntityList, flowTaskParamter.flowTaskEntity.ThisStepId);
}
else
{
flowTaskParamter.flowTaskEntity.ThisStep = string.Join(",", rejectNodeCodeList);
flowTaskParamter.flowTaskEntity.ThisStepId = string.Join(",", rejectNodeList.Select(x => x.NodeCode).ToArray());
}
var rejectNodeIds = rejectNodeList.Union(rejectNodeNextAllList).ToList().Select(x => x.Id).ToList();
await RejectUpdateTaskNode(rejectNodeList.Union(rejectNodeNextAllList).ToList(), 0);
// 删除驳回节点下所有经办
var rejectList = (await _flowTaskRepository.GetTaskOperatorList(x => x.TaskId == flowTaskParamter.flowTaskEntity.Id && rejectNodeIds.Contains(x.TaskNodeId))).OrderBy(x => x.HandleTime).Select(x => x.Id).ToList();
await _flowTaskRepository.DeleteTaskOperator(rejectList);
//删除驳回节点经办记录
var rejectRecodeList = (await _flowTaskRepository.GetTaskOperatorRecordList(x => x.TaskId == flowTaskParamter.flowTaskEntity.Id && rejectNodeIds.Contains(x.TaskNodeId))).OrderBy(x => x.HandleTime).Select(x => x.Id).ToList();
await _flowTaskRepository.DeleteTaskOperatorRecord(rejectRecodeList);
}
return rejectNodeNextAllList.FindAll(x => FlowTaskNodeTypeEnum.subFlow.Equals(x.NodeType));
}
#endregion
}