mh_lcmk_sms_service/APT.BaseData.Domain/ApiModel/Platform/Flow/FlowRuntime.cs

534 lines
19 KiB
C#
Raw Permalink Normal View History

2024-07-12 16:37:09 +08:00
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using APT.BaseData.Domain.Entities;
using APT.Infrastructure.Core;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
namespace APT.BaseData.Domain.ApiModel
{
public class FlowRuntime
{
private FlowRuntimeModel _runtimeModel = null;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="currentNodeId">当前节点</param>
/// <param name="frmData">表单数据</param>
/// <param name="instance"></param>
public FlowRuntime(T_PF_FLOW_INSTANCE instance, object entity)
{
_runtimeModel = new FlowRuntimeModel();
dynamic schemeContentJson = JsonConvert.DeserializeObject(instance.SchemeContent);//获取工作流模板内容的json对象;
_runtimeModel.frmData = string.Empty;
_runtimeModel.schemeContentJson = schemeContentJson;//模板流程json对象
_runtimeModel.nodes = GetNodes(schemeContentJson);//节点集合
_runtimeModel.lines = GetFromLines(schemeContentJson);//线条集合
_runtimeModel.currentNodeId = (instance.ActivityId == "" ? _runtimeModel.startNodeId : instance.ActivityId);
_runtimeModel.currentNodeType = GetNodeType(_runtimeModel.currentNodeId);
//会签开始节点和流程结束节点没有下一步
if (_runtimeModel.currentNodeType == 0 || _runtimeModel.currentNodeType == 4)
{
_runtimeModel.nextNodeId = "-1";
_runtimeModel.nextNodeType = -1;
}
else
{
_runtimeModel.nextNodeId = GetNextNodeId(_runtimeModel.frmData, entity);//下一个节点
_runtimeModel.nextNodeType = GetNodeType(_runtimeModel.nextNodeId);
}
_runtimeModel.previousId = instance.PreviousId;
_runtimeModel.flowInstanceId = instance.ID.ToString();
}
#region
/// <summary>
/// 获取工作流节点的字典列表:key节点id
/// </summary>
/// <param name="schemeContentJson"></param>
/// <returns></returns>
private Dictionary<string, FlowNode> GetNodes(dynamic schemeContentJson)
{
Dictionary<string, FlowNode> nodes = new Dictionary<string, FlowNode>();
foreach (JObject item in schemeContentJson.nodes)
{
var node = item.ToObject<FlowNode>();
if (!nodes.ContainsKey(node.id))
{
nodes.Add(node.id, node);
}
if (node.type == FlowNode.START)
{
this._runtimeModel.startNodeId = node.id;
}
}
return nodes;
}
/// <summary>
/// 获取工作流节点及以节点为出发点的流程
/// </summary>
/// <param name="schemeContentJson"></param>
/// <returns></returns>
private Dictionary<string, List<FlowLine>> GetFromLines(dynamic schemeContentJson)
{
Dictionary<string, List<FlowLine>> lines = new Dictionary<string, List<FlowLine>>();
foreach (JObject item in schemeContentJson.lines)
{
var line = JsonConvert.DeserializeObject<FlowLine>(item.ToString());
if (!lines.ContainsKey(line.from))
{
List<FlowLine> d = new List<FlowLine> { line };
lines.Add(line.from, d);
}
else
{
lines[line.from].Add(line);
}
}
return lines;
}
/// <summary>
/// 获取工作流节点的入口流程列表
/// </summary>
/// <param name="schemeContentJson"></param>
/// <returns></returns>
private Dictionary<string, List<FlowLine>> GetToLines(dynamic schemeContentJson)
{
Dictionary<string, List<FlowLine>> lines = new Dictionary<string, List<FlowLine>>();
foreach (JObject item in schemeContentJson.lines)
{
var line = item.ToObject<FlowLine>();
if (!lines.ContainsKey(line.to))
{
List<FlowLine> d = new List<FlowLine> { line };
lines.Add(line.to, d);
}
else
{
lines[line.to].Add(line);
}
}
return lines;
}
/// <summary>
/// 获取下一个节点
/// </summary>
private string GetNextNodeId(string frmData, object entity, string nodeId = null)
{
List<FlowLine> LineList = null;
if (nodeId == null)
{
LineList = runtimeModel.lines[runtimeModel.currentNodeId];
}
else
{
LineList = runtimeModel.lines[nodeId];
}
if (LineList.Count == 1) //只有一条流程
{
return LineList[0].to;
}
else if (LineList.Count > 1)
{
foreach (var line in LineList)
{
bool isMarch = true;
if (line.setInfo == null || line.setInfo.Rules == null)
return line.to;
foreach (var rule in line.setInfo.Rules)
{
var type = entity.GetType();
var field = type.GetProperty(rule.Field);
var value = field.GetValue(entity).ToString();
if (rule.Operate == FilterOperate.Equal)
{
if (value != rule.Value.ToString())
{
isMarch = false;
break;
}
}
else if (rule.Operate == FilterOperate.NotEqual)
{
if (value == rule.Value.ToString())
{
isMarch = false;
break;
}
}
else if (rule.Operate == FilterOperate.GreaterThan)
{
var dVal = double.Parse(value);
var rVal = double.Parse(rule.Value.ToString());
if (dVal <= rVal)
{
isMarch = false;
break;
}
}
else if (rule.Operate == FilterOperate.GreaterThanOrEqual)
{
var dVal = double.Parse(value);
var rVal = double.Parse(rule.Value.ToString());
if (dVal < rVal)
{
isMarch = false;
break;
}
}
else if (rule.Operate == FilterOperate.LessThan)
{
var dVal = double.Parse(value);
var rVal = double.Parse(rule.Value.ToString());
if (dVal >= rVal)
{
isMarch = false;
break;
}
}
else if (rule.Operate == FilterOperate.LessThanOrEqual)
{
var dVal = double.Parse(value);
var rVal = double.Parse(rule.Value.ToString());
if (dVal > rVal)
{
isMarch = false;
break;
}
}
else if (rule.Operate == FilterOperate.StartsWith)
{
if (!value.StartsWith(rule.Value.ToString()))
{
isMarch = false;
break;
}
}
else if (rule.Operate == FilterOperate.EndsWith)
{
if (!value.EndsWith(rule.Value.ToString()))
{
isMarch = false;
break;
}
}
else if (rule.Operate == FilterOperate.Contains)
{
if (!value.Contains(rule.Value.ToString()))
{
isMarch = false;
break;
}
}
}
if (isMarch)
{
return line.to;
}
}
}
if (frmData != "") //有分支的情况
{
frmData = frmData.ToLower();//统一转小写
foreach (var item in LineList)//轮训该节点所有连接的线路
{
return item.to;
}
}
return "-1";//表示寻找不到节点
}
/// <summary>
/// 通过节点Id获取下一个节点Id
/// </summary>
/// <param name="nodeId"></param>
/// <returns></returns>
public string GetNextNode(string nodeId)
{
string frmData = "";
// frmData = GetNodeFrmData(_getFrmData, nodeId);
return GetNextNodeId(frmData,null, nodeId);
}
#endregion
#region API
/// <summary>
/// 工作流实例运行信息
/// </summary>
/// <returns></returns>
public FlowRuntimeModel runtimeModel
{
get { return _runtimeModel; }
}
/// <summary>
/// 获取实例接下来运行的状态
/// </summary>
/// <returns>-1无法运行,0会签开始,1会签结束,2一般节点,4流程运行结束</returns>
public int GetNextNodeType()
{
if (_runtimeModel.nextNodeId != "-1")
{
return GetNodeType(_runtimeModel.nextNodeId);
}
return -1;
}
/// <summary>
/// 获取节点类型 0会签开始,1会签结束,2一般节点,开始节点,4流程运行结束
/// </summary>
/// <param name="nodeId"></param>
/// <returns></returns>
public int GetNodeType(string nodeId)
{
if (_runtimeModel.nodes[nodeId].type == FlowNode.FORK)//会签开始节点
{
return 0;
}
else if (_runtimeModel.nodes[nodeId].type == FlowNode.JOIN)//会签结束节点
{
return 1;
}
else if (_runtimeModel.nodes[nodeId].type == FlowNode.END)//结束节点
{
return 4;
}
else if (_runtimeModel.nodes[nodeId].type == FlowNode.START)//开始节点
{
return 3;
}
else
{
return 2;
}
}
/// <summary>
/// 获取会签下面需要审核的ID列表
/// </summary>
/// <param name="forknodeId">会签开始节点</param>
/// <returns></returns>
public List<string> GetCountersigningNodeIdList(string forknodeId)
{
return _runtimeModel.lines[forknodeId].Select(item => item.to).ToList();
}
/// <summary>
/// 节点会签审核
/// </summary>
/// <param name="nodeId"></param>
/// <param name="tag"></param>
/// <returns>-1不通过,1等待,其它通过</returns>
public string NodeConfluence(string nodeId, Tag tag)
{
string res = "-1";
string joinNodeId = GetNextNode(nodeId); //获取回签的合流节点
if (joinNodeId == "-1")
{
throw (new Exception("寻找不到会签下合流节点"));
}
Dictionary<string, List<FlowLine>> toLines = GetToLines(_runtimeModel.schemeContentJson);
int allnum = toLines[joinNodeId].Count; //总会签数量
int i = 0;
foreach (var item in _runtimeModel.schemeContentJson.nodes)
{
if (item.id != joinNodeId)
{
i++;
continue;
}
if (string.IsNullOrEmpty(item.setInfo.NodeConfluenceType)) //默认所有步骤通过
{
if (tag.Taged == 1)
{
if (item.setInfo.ConfluenceOk == null)
{
_runtimeModel.schemeContentJson.nodes[i].setInfo.ConfluenceOk = 1;
res = "1";
}
else if (item.setInfo.ConfluenceOk == (allnum - 1)) //会签成功
{
res = GetNextNode(joinNodeId);
if (res == "-1")
{
throw (new Exception("会签成功寻找不到下一个节点"));
}
}
else
{
_runtimeModel.schemeContentJson.nodes[i].setInfo.ConfluenceOk = int.Parse(_runtimeModel.schemeContentJson.nodes[i].setInfo.ConfluenceOk) + 1;
res = "1";
}
}
}
//else if (item.setInfo.NodeConfluenceType == "1") //1一个步骤通过即可
//{
// if (tag.Taged == 1)
// {
// res = GetNextNodeId(nextNodeId);
// if (res == "-1")
// {
// throw (new Exception("会签成功寻找不到下一个节点"));
// }
// }
// else
// {
// if (item.setInfo.ConfluenceNo == null)
// {
// _runtimeModel.schemeContentJson.nodes[i].setInfo.ConfluenceNo = 1;
// res = "1";
// }
// else if (item.setInfo.ConfluenceNo == (allnum - 1))
// {
// res = "-1";
// }
// else
// {
// _runtimeModel.schemeContentJson.nodes[i].setInfo.ConfluenceNo++;
// res = "1";
// }
// }
//}
}
if (res == "-1")
{
tag.Taged = -1;
MakeTagNode(joinNodeId, tag);
}
else if (res != "1") //这时res是会签结束节点后面的一个节点
{
tag.Taged = 1;
MakeTagNode(joinNodeId, tag);
_runtimeModel.nextNodeId = res;
_runtimeModel.nextNodeType = GetNodeType(res);
}
else
{
_runtimeModel.nextNodeId = joinNodeId;
_runtimeModel.nextNodeType = GetNodeType(joinNodeId);
}
return res;
}
/// <summary>
/// 驳回节点0"前一步"1"第一步"2"某一步" 3"不处理"
/// </summary>
/// <returns></returns>
public string RejectNode()
{
return RejectNode(_runtimeModel.currentNodeId);
}
public string RejectNode(string nodeId)
{
dynamic node = _runtimeModel.nodes[nodeId];
if (node.setInfo != null)
{
if (node.setInfo.NodeRejectType == "0")
{
return _runtimeModel.previousId;
}
if (node.setInfo.NodeRejectType == "1")
{
return _runtimeModel.startNodeId;
}
if (node.setInfo.NodeRejectType == "2")
{
return node.setInfo.NodeRejectStep;
}
return "";
}
return _runtimeModel.previousId;
}
///<summary>
/// 标记节点1通过-1不通过0驳回
/// </summary>
/// <param name="nodeId"></param>
public void MakeTagNode(string nodeId, Tag tag)
{
int i = 0;
foreach (var item in _runtimeModel.schemeContentJson.nodes)
{
if (item.id == nodeId)
{
var setInfo = _runtimeModel.schemeContentJson.nodes[i].setInfo;
if (setInfo != null)
{
setInfo.Taged = tag.Taged;
setInfo.UserId = tag.UserId;
setInfo.UserName = tag.UserName;
setInfo.Description = tag.Description;
setInfo.TagedTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm");
}
break;
}
i++;
}
}
///<summary>
/// 清空节点状态
/// </summary>
/// <param name="nodeId"></param>
public void ClearTagNode(string nodeId)
{
int i = 0;
foreach (var item in _runtimeModel.schemeContentJson.nodes)
{
if (item.id == nodeId)
{
var setInfo = _runtimeModel.schemeContentJson.nodes[i].setInfo;
if (setInfo != null)
{
setInfo.Taged ="";
setInfo.UserId = "";
setInfo.UserName = "";
setInfo.Description = "";
setInfo.TagedTime = "";
}
break;
}
i++;
}
}
/// <summary>
/// 获取节点是否允许修改
///
/// </summary>
/// <returns>0-不可编辑 1-可编辑</returns>
public int GetNodePermitEditable(string nodeId)
{
if (string.IsNullOrEmpty(nodeId)) return 0;
FlowNode node = null;
if (_runtimeModel.nodes.TryGetValue(nodeId, out node))
{
if (node.setInfo != null)
{
if (!string.IsNullOrEmpty(node.setInfo.NodeEditable))
return Convert.ToInt32(node.setInfo.NodeEditable);
}
}
return 0;
}
}
#endregion
}