添加项目文件。

workflow/Tnb.WorkFlow/Manager/FlowTaskMsgUtil.cs

@@ -0,0 +1,218 @@
+using JNPF.Common.Core.Manager;
+using JNPF.Common.Dtos.Message;
+using JNPF.Common.Extension;
+using JNPF.Common.Security;
+using JNPF.Message.Interfaces.Message;
+using JNPF.Systems.Interfaces.Permission;
+using JNPF.Systems.Interfaces.System;
+using JNPF.WorkFlow.Entitys.Entity;
+using JNPF.WorkFlow.Entitys.Model;
+using JNPF.WorkFlow.Entitys.Model.Conifg;
+using JNPF.WorkFlow.Interfaces.Repository;
+using Newtonsoft.Json.Linq;
+
+namespace JNPF.WorkFlow.Manager;
+
+public class FlowTaskMsgUtil
+{
+    private readonly ISendMessageService _sendMessageService;
+
+    private readonly IDataInterfaceService _dataInterfaceService;
+
+    public readonly IFlowTaskRepository _flowTaskRepository;
+
+    public readonly IUserManager _userManager;
+
+    public readonly IUsersService _usersService;
+
+    public FlowTaskMsgUtil(ISendMessageService sendMessageService, IFlowTaskRepository flowTaskRepository, IUserManager userManager, IUsersService usersService, IDataInterfaceService dataInterfaceService)
+    {
+        _sendMessageService = sendMessageService;
+        _flowTaskRepository = flowTaskRepository;
+        _userManager = userManager;
+        _usersService = usersService;
+        _dataInterfaceService = dataInterfaceService;
+    }
+
+    #region 消息推送
+
+    /// <summary>
+    /// 通过消息模板获取消息通知.
+    /// </summary>
+    /// <param name="msgConfig">消息配置.</param>
+    /// <param name="users">通知人员.</param>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    /// <param name="enCode">默认站内信编码.</param>
+    /// <param name="bodyDic">跳转数据.</param>
+    /// <returns></returns>
+    public async Task Alerts(MsgConfig msgConfig, List<string> users, FlowTaskParamter flowTaskParamter, string enCode, Dictionary<string, object> bodyDic = null)
+    {
+        //自定义消息
+        if (msgConfig.on == 1 || msgConfig.on == 2)
+        {
+            foreach (var item in msgConfig.templateJson)
+            {
+                item.toUser = users;
+                GetMsgContent(item.paramJson, flowTaskParamter);
+                await _sendMessageService.SendMessage(item, bodyDic);
+            }
+        }
+
+        //默认消息
+        if (msgConfig.on == 3)
+        {
+            await _sendMessageService.SendMessageDefult(enCode, users, flowTaskParamter.flowTaskEntity.FullName, bodyDic);
+        }
+    }
+
+    /// <summary>
+    /// 获取消息模板内容.
+    /// </summary>
+    /// <param name="templateJsonItems">消息模板json.</param>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    public Dictionary<string, string> GetMsgContent(List<MessageSendParam> templateJsonItems, FlowTaskParamter flowTaskParamter)
+    {
+        var jObj = flowTaskParamter.flowTaskEntity.FlowFormContentJson.ToObject<JObject>();
+        var dic = new Dictionary<string, string>();
+        foreach (var item in templateJsonItems)
+        {
+            var value = string.Empty;
+            if (item.relationField.Equals("@flowOperatorUserId"))
+            {
+                value = _userManager.UserId;
+            }
+            else if (item.relationField.Equals("@taskId"))
+            {
+                value = flowTaskParamter.flowTaskEntity.Id;
+            }
+            else if (item.relationField.Equals("@taskNodeId"))
+            {
+                value = flowTaskParamter.flowTaskNodeEntity.Id;
+            }
+            else if (item.relationField.Equals("@taskFullName"))
+            {
+                value = flowTaskParamter.flowTaskEntity.FullName;
+            }
+            else if (item.relationField.Equals("@launchUserId"))
+            {
+                value = flowTaskParamter.flowTaskEntity.CreatorUserId;
+            }
+            else if (item.relationField.Equals("@launchUserName"))
+            {
+                value = _usersService.GetInfoByUserId(flowTaskParamter.flowTaskEntity.CreatorUserId).RealName;
+            }
+            else if (item.relationField.Equals("@flowOperatorUserName"))
+            {
+                value = _userManager.User.RealName;
+            }
+            else if (item.relationField.Equals("@flowId"))
+            {
+                value = flowTaskParamter.flowTaskEntity.FlowId;
+            }
+            else if (item.relationField.Equals("@flowFullName"))
+            {
+                value = flowTaskParamter.flowTaskEntity.FlowName;
+            }
+            else
+            {
+                if (item.isSubTable)
+                {
+                    var fields = item.relationField.Split("-").ToList();
+                    // 子表键值
+                    var tableField = fields[0];
+                    // 子表字段键值
+                    var keyField = fields[1];
+                    if (jObj.ContainsKey(tableField) && jObj[tableField] is JArray)
+                    {
+                        var jar = jObj[tableField] as JArray;
+
+                        value = jar.Where(x => x.ToObject<JObject>().ContainsKey(keyField)).Select(x => x.ToObject<JObject>()[keyField]).ToJsonString();
+                    }
+                }
+                else
+                {
+                    value = jObj.ContainsKey(item.relationField) ? jObj[item.relationField].ToString() : string.Empty;
+                }
+            }
+            item.value = value;
+            dic.Add(item.field, value);
+        }
+        templateJsonItems.Add(new MessageSendParam
+        {
+            field = "@taskFullName",
+            value = flowTaskParamter.flowTaskEntity.FullName
+        });
+        return dic;
+    }
+
+    /// <summary>
+    /// 组装消息跳转详情参数.
+    /// </summary>
+    /// <param name="flowEngineEntity">流程实例</param>
+    /// <param name="taskNodeId">节点id.</param>
+    /// <param name="userList">通知人员.</param>
+    /// <param name="flowTaskOperatorEntities">经办实例.</param>
+    /// <param name="type">1:发起，2：待办，3：抄送</param>
+    /// <param name="taskOperatorId"></param>
+    /// <returns></returns>
+    public Dictionary<string, object> GetMesBodyText(FlowTaskParamter flowTaskParamter, List<string> userList, List<FlowTaskOperatorEntity> flowTaskOperatorEntities, int type, string remark = "")
+    {
+        var dic = new Dictionary<string, object>();
+        if (flowTaskOperatorEntities.IsNotEmptyOrNull() && flowTaskOperatorEntities.Count > 0)
+        {
+            foreach (var item in flowTaskOperatorEntities)
+            {
+                var value = new
+                {
+                    enCode = flowTaskParamter.flowTaskEntity.FlowCode,
+                    flowId = flowTaskParamter.flowTaskEntity.FlowId,
+                    status = type == 1 ? 0 : 1,
+                    processId = item.TaskId,
+                    taskNodeId = item.TaskNodeId,
+                    taskOperatorId = item.Id,
+                    type = type,
+                    remark = remark
+                };
+                dic.Add(item.HandleId, value);
+                if (type == 2)
+                {
+                    var toUserId = _flowTaskRepository.GetToUserId(item.HandleId, flowTaskParamter.flowTaskEntity.TemplateId);
+                    toUserId.ForEach(u => dic[u + "-delegate"] = value);
+                }
+            }
+        }
+        else
+        {
+            var value = new
+            {
+                enCode = flowTaskParamter.flowTaskEntity.FlowCode,
+                flowId = flowTaskParamter.flowTaskEntity.FlowId,
+                status = type == 1 ? 0 : 1,
+                processId = flowTaskParamter.flowTaskEntity.Id,
+                taskNodeId = flowTaskParamter.flowTaskNodeEntity?.Id,
+                taskOperatorId = flowTaskParamter.flowTaskOperatorEntity?.Id,
+                type = type,
+                remark = remark
+            };
+            userList.ForEach(u => dic.Add(u, value));
+        }
+        return dic;
+    }
+
+    /// <summary>
+    /// 事件请求.
+    /// </summary>
+    /// <param name="funcConfig">事件配置.</param>
+    /// <param name="formdata">表单数据.</param>
+    /// <returns></returns>
+    public async Task RequestEvents(FuncConfig funcConfig, FlowTaskParamter flowTaskParamter)
+    {
+        if (funcConfig.IsNotEmptyOrNull() && funcConfig.on && funcConfig.interfaceId.IsNotEmptyOrNull())
+        {
+            var parameters = GetMsgContent(funcConfig.templateJson, flowTaskParamter);
+            await _dataInterfaceService.GetResponseByType(funcConfig.interfaceId, 3, _userManager.TenantId, null, parameters);
+        }
+    }
+
+    #endregion
+}

workflow/Tnb.WorkFlow/Manager/FlowTaskNodeUtil.cs

@@ -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
+}

workflow/Tnb.WorkFlow/Manager/FlowTaskOtherUtil.cs

@@ -0,0 +1,494 @@
+using JNPF.Common.Core.Manager;
+using JNPF.Common.Extension;
+using JNPF.Common.Models.WorkFlow;
+using JNPF.Common.Security;
+using JNPF.Systems.Interfaces.Permission;
+using JNPF.TaskScheduler;
+using JNPF.VisualDev.Interfaces;
+using JNPF.WorkFlow.Entitys.Entity;
+using JNPF.WorkFlow.Entitys.Enum;
+using JNPF.WorkFlow.Entitys.Model;
+using JNPF.WorkFlow.Entitys.Model.Conifg;
+using JNPF.WorkFlow.Entitys.Model.Item;
+using JNPF.WorkFlow.Entitys.Model.Properties;
+using JNPF.WorkFlow.Interfaces.Repository;
+
+namespace JNPF.WorkFlow.Manager;
+
+public class FlowTaskOtherUtil
+{
+    private readonly IFlowTaskRepository _flowTaskRepository;
+    private readonly IUsersService _usersService;
+    private readonly IRunService _runService;
+    private readonly IUserManager _userManager;
+
+    public FlowTaskOtherUtil(IFlowTaskRepository flowTaskRepository, IUsersService usersService, IRunService runService, IUserManager userManager)
+    {
+        _flowTaskRepository = flowTaskRepository;
+        _usersService = usersService;
+        _runService = runService;
+        _userManager = userManager;
+    }
+
+    /// <summary>
+    /// 修改当前节点经办数据.
+    /// </summary>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    /// <param name="handleStatus">审批类型（0：拒绝，1：同意）.</param>
+    /// <returns></returns>
+    public async Task UpdateFlowTaskOperator(FlowTaskParamter flowTaskParamter, int handleStatus)
+    {
+        var updateOperatorList = new List<FlowTaskOperatorEntity>();// 要修改的经办
+        // 加签
+        if (flowTaskParamter.freeApproverUserId.IsNotEmptyOrNull())
+        {
+            #region 添加加签经办
+            var freeApproverOperatorEntity = flowTaskParamter.flowTaskOperatorEntity.Copy();
+            freeApproverOperatorEntity.Id = SnowflakeIdHelper.NextId();
+            freeApproverOperatorEntity.ParentId = flowTaskParamter.flowTaskOperatorEntity.Id;
+            freeApproverOperatorEntity.HandleType = flowTaskParamter.flowTaskOperatorEntity.Id;
+            freeApproverOperatorEntity.HandleId = flowTaskParamter.freeApproverUserId;
+            freeApproverOperatorEntity.CreatorTime = DateTime.Now;
+            freeApproverOperatorEntity.Completion = 0;
+            freeApproverOperatorEntity.RollbackId = flowTaskParamter.freeApproverType == "1" ? flowTaskParamter.flowTaskOperatorEntity.Id : flowTaskParamter.flowTaskOperatorEntity.RollbackId;
+            await _flowTaskRepository.CreateTaskOperator(freeApproverOperatorEntity);
+            flowTaskParamter.flowTaskOperatorEntityList.Add(freeApproverOperatorEntity);
+            #endregion
+
+            flowTaskParamter.flowTaskOperatorEntity.State = "1";
+            flowTaskParamter.flowTaskOperatorEntity.HandleStatus = handleStatus;
+            flowTaskParamter.flowTaskOperatorEntity.Completion = 1;
+            flowTaskParamter.flowTaskOperatorEntity.HandleTime = DateTime.Now;
+            if (flowTaskParamter.freeApproverType == "1")
+            {
+                handleStatus = 10;
+            }
+            else
+            {
+                #region 加签记录
+                await CreateOperatorRecode(flowTaskParamter, 6);
+                #endregion
+            }
+        }
+        else
+        {
+            // 当前经办非加签经办或不存在前签
+            if (flowTaskParamter.flowTaskOperatorEntity.ParentId.IsNullOrEmpty() || flowTaskParamter.flowTaskOperatorEntity.RollbackId.IsNullOrEmpty() || handleStatus == 0)
+            {
+                if (flowTaskParamter.approversProperties.counterSign == 0 || IsAchievebilProportion(flowTaskParamter, handleStatus))
+                {
+                    //未审批经办
+                    updateOperatorList = GetNotCompletion(flowTaskParamter.thisFlowTaskOperatorEntityList);
+                }
+            }
+            else
+            {
+                flowTaskParamter.flowTaskOperatorEntity.State = "1";
+                // 前签发起人是否为初始经办人
+                var rollBackOprtator = await _flowTaskRepository.GetTaskOperatorInfo(flowTaskParamter.flowTaskOperatorEntity.RollbackId);
+                if (rollBackOprtator.IsNotEmptyOrNull())
+                {
+                    //rollBackOprtator.State = "0";
+                    //await _flowTaskRepository.UpdateTaskOperator(rollBackOprtator);
+                    rollBackOprtator.Id = SnowflakeIdHelper.NextId();
+                    rollBackOprtator.State = "0";
+                    rollBackOprtator.Completion = 0;
+                    rollBackOprtator.HandleStatus = 0;
+                    rollBackOprtator.HandleType = flowTaskParamter.flowTaskOperatorEntity.Id;
+                    rollBackOprtator.HandleTime = null;
+                    await _flowTaskRepository.CreateTaskOperator(rollBackOprtator);
+                }
+                //else
+                //{
+                //    rollBackOprtator.Id = SnowflakeIdHelper.NextId();
+                //    rollBackOprtator.State = "0";
+                //    rollBackOprtator.Completion = 0;
+                //    rollBackOprtator.HandleStatus = 0;
+                //    rollBackOprtator.HandleTime = null;
+                //    await _flowTaskRepository.CreateTaskOperator(rollBackOprtator);
+                //}
+            }
+            flowTaskParamter.flowTaskOperatorEntity.HandleStatus = handleStatus;
+            flowTaskParamter.flowTaskOperatorEntity.Completion = 1;
+            flowTaskParamter.flowTaskOperatorEntity.HandleTime = DateTime.Now;
+        }
+        updateOperatorList.Add(flowTaskParamter.flowTaskOperatorEntity);
+        await _flowTaskRepository.UpdateTaskOperator(updateOperatorList);
+        // 经办记录
+        await CreateOperatorRecode(flowTaskParamter, handleStatus);
+    }
+
+    /// <summary>
+    /// 获取未审经办并修改完成状态.
+    /// </summary>
+    /// <param name="thisFlowTaskOperatorEntityList">当前节点所有经办.</param>
+    /// <returns></returns>
+    public List<FlowTaskOperatorEntity> GetNotCompletion(List<FlowTaskOperatorEntity> thisFlowTaskOperatorEntityList)
+    {
+        var notCompletion = thisFlowTaskOperatorEntityList.FindAll(x => x.Completion == 0);
+        notCompletion.ForEach(item =>
+        {
+            item.Completion = 1;
+        });
+        return notCompletion;
+    }
+
+    /// <summary>
+    /// 对审批人节点分组.
+    /// </summary>
+    /// <param name="flowTaskOperatorEntities">所有经办.</param>
+    /// <returns></returns>
+    public Dictionary<string, List<FlowTaskOperatorEntity>> GroupByOperator(List<FlowTaskOperatorEntity> flowTaskOperatorEntities)
+    {
+        var dic = new Dictionary<string, List<FlowTaskOperatorEntity>>();
+        foreach (var item in flowTaskOperatorEntities.GroupBy(x => x.TaskNodeId))
+        {
+            dic.Add(item.Key, flowTaskOperatorEntities.FindAll(x => x.TaskNodeId == item.Key));
+        }
+        return dic;
+    }
+
+    /// <summary>
+    /// 保存当前未完成节点下个候选人节点的候选人.
+    /// </summary>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    public List<FlowCandidatesEntity> SaveNodeCandidates(FlowTaskParamter flowTaskParamter)
+    {
+        var flowCandidateList = new List<FlowCandidatesEntity>();
+        if (flowTaskParamter.candidateList.IsNotEmptyOrNull())
+        {
+            foreach (var item in flowTaskParamter.candidateList.Keys)
+            {
+                var node = flowTaskParamter.flowTaskNodeEntityList.Find(x => x.NodeCode == item);
+                if (node != null)
+                {
+                    flowCandidateList.Add(new FlowCandidatesEntity()
+                    {
+                        Id = SnowflakeIdHelper.NextId(),
+                        TaskId = node.TaskId,
+                        TaskNodeId = node.Id,
+                        HandleId = _userManager.UserId,
+                        Account = _userManager.Account,
+                        Candidates = string.Join(",", flowTaskParamter.candidateList[item]),
+                        TaskOperatorId = flowTaskParamter.flowTaskOperatorEntity.Id
+                    });
+                }
+            }
+            _flowTaskRepository.CreateFlowCandidates(flowCandidateList);
+        }
+        if (flowTaskParamter.errorRuleUserList.IsNotEmptyOrNull())
+        {
+            flowCandidateList.Clear();
+            foreach (var item in flowTaskParamter.errorRuleUserList.Keys)
+            {
+                var node = flowTaskParamter.flowTaskNodeEntityList.Find(x => x.NodeCode == item);
+                if (node != null)
+                {
+                    flowCandidateList.Add(new FlowCandidatesEntity()
+                    {
+                        Id = SnowflakeIdHelper.NextId(),
+                        TaskId = node.TaskId,
+                        TaskNodeId = node.Id,
+                        HandleId = _userManager.UserId,
+                        Account = _userManager.Account,
+                        Candidates = string.Join(",", flowTaskParamter.errorRuleUserList[item]),
+                        TaskOperatorId = flowTaskParamter.flowTaskOperatorEntity.Id
+                    });
+                }
+            }
+            _flowTaskRepository.CreateFlowCandidates(flowCandidateList);
+        }
+        return flowCandidateList;
+    }
+
+    /// <summary>
+    /// 获取子流程继承父流程的表单数据.
+    /// </summary>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    /// <param name="childTaskProperties">子流程属性.</param>
+    /// <returns></returns>
+    public async Task<object> GetSubFlowFormData(FlowTaskParamter flowTaskParamter, ChildTaskProperties childTaskProperties)
+    {
+        var childFlowEngine = _flowTaskRepository.GetFlowTemplateInfo(childTaskProperties.flowId);
+        var thisFormId = flowTaskParamter.flowTaskNodeEntity.FormId;
+        var nextFormId = childFlowEngine.flowTemplateJson.ToObject<FlowTemplateJsonModel>().properties.ToObject<StartProperties>().formId;
+        var mapRule = GetMapRule(childTaskProperties.assignList, flowTaskParamter.flowTaskNodeEntity.NodeCode);
+        var childFormData = await _runService.SaveDataToDataByFId(thisFormId, nextFormId, mapRule, flowTaskParamter.formData.ToObject<Dictionary<string, object>>(), true);
+        return childFormData;
+    }
+
+    /// <summary>
+    /// 获取流程任务名称.
+    /// </summary>
+    /// <param name="flowTaskSubmitModel">提交参数.</param>
+    /// <returns></returns>
+    public async Task GetFlowTitle(FlowTaskSubmitModel flowTaskSubmitModel)
+    {
+        var flowTemplateJsonModel = flowTaskSubmitModel.flowJsonModel.ToObject<FlowJsonModel>().flowTemplateJson.ToObject<FlowTemplateJsonModel>();
+        var startProp = flowTemplateJsonModel.properties.ToObject<StartProperties>();
+        var userName = flowTaskSubmitModel.crUser.IsNotEmptyOrNull() ? await _usersService.GetUserName(flowTaskSubmitModel.crUser, false) : _userManager.User.RealName;
+        if (startProp.titleType == 1)
+        {
+            var formDataDic = flowTaskSubmitModel.formData.ToObject<Dictionary<string, object>>();
+            formDataDic.Add("@flowFullName", flowTaskSubmitModel.flowJsonModel.fullName);
+            formDataDic.Add("@flowFullCode", flowTaskSubmitModel.flowJsonModel.enCode);
+            formDataDic.Add("@launchUserName", userName);
+            formDataDic.Add("@launchTime", DateTime.Now.ToString("yyyy-MM-dd"));
+            foreach (var item in startProp.titleContent.Substring3())
+            {
+                if (formDataDic.ContainsKey(item) && formDataDic[item] != null)
+                {
+                    startProp.titleContent = startProp.titleContent?.Replace("{" + item + "}", formDataDic[item].ToString());
+                }
+                else
+                {
+                    startProp.titleContent = startProp.titleContent?.Replace("{" + item + "}", string.Empty);
+                }
+            }
+            flowTaskSubmitModel.flowTitle = startProp.titleContent;
+        }
+        else
+        {
+            flowTaskSubmitModel.flowTitle = string.Format("{0}的{1}", userName, flowTaskSubmitModel.flowJsonModel.fullName);
+        }
+    }
+
+    /// <summary>
+    /// 添加经办记录.
+    /// </summary>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    /// <param name="handleStatus">审批类型（0：拒绝，1：同意）.</param>
+    /// <returns></returns>
+    public async Task CreateOperatorRecode(FlowTaskParamter flowTaskParamter, int handleStatus)
+    {
+        FlowTaskOperatorRecordEntity flowTaskOperatorRecordEntity = new FlowTaskOperatorRecordEntity();
+        flowTaskOperatorRecordEntity.HandleTime = DateTime.Now;
+        flowTaskOperatorRecordEntity.HandleId = handleStatus == 2 ? flowTaskParamter.flowTaskEntity.CreatorUserId : _userManager.UserId;
+        flowTaskOperatorRecordEntity.HandleStatus = handleStatus;
+        flowTaskOperatorRecordEntity.HandleOpinion = flowTaskParamter.handleOpinion;
+        flowTaskOperatorRecordEntity.SignImg = flowTaskParamter.signImg;
+        flowTaskOperatorRecordEntity.Status = 0;
+        flowTaskOperatorRecordEntity.FileList = flowTaskParamter.fileList.ToJsonString();
+        flowTaskOperatorRecordEntity.TaskId = flowTaskParamter.flowTaskEntity.Id;
+        flowTaskOperatorRecordEntity.NodeCode = flowTaskParamter.flowTaskEntity.ThisStepId;
+        flowTaskOperatorRecordEntity.NodeName = flowTaskParamter.flowTaskEntity.ThisStep;
+        flowTaskOperatorRecordEntity.OperatorId = flowTaskParamter.freeApproverUserId;
+        if (flowTaskParamter.flowTaskOperatorEntity.IsNotEmptyOrNull())
+        {
+            if (handleStatus == 0 || handleStatus == 1)
+            {
+                flowTaskOperatorRecordEntity.Status = flowTaskParamter.flowTaskOperatorEntity.ParentId.IsNotEmptyOrNull() ? 1 : 0;
+            }
+            flowTaskOperatorRecordEntity.NodeCode = flowTaskParamter.flowTaskOperatorEntity.NodeCode;
+            flowTaskOperatorRecordEntity.NodeName = flowTaskParamter.flowTaskOperatorEntity.NodeName;
+            flowTaskOperatorRecordEntity.TaskOperatorId = flowTaskParamter.flowTaskOperatorEntity.Id;
+            flowTaskOperatorRecordEntity.TaskNodeId = flowTaskParamter.flowTaskOperatorEntity.TaskNodeId;
+        }
+        else if (flowTaskParamter.flowTaskNodeEntity.IsNotEmptyOrNull())
+        {
+            flowTaskOperatorRecordEntity.NodeCode = flowTaskParamter.flowTaskNodeEntity.NodeCode;
+            flowTaskOperatorRecordEntity.NodeName = flowTaskParamter.flowTaskNodeEntity.NodeName;
+            flowTaskOperatorRecordEntity.TaskNodeId = flowTaskParamter.flowTaskNodeEntity.Id;
+        }
+        await _flowTaskRepository.CreateTaskOperatorRecord(flowTaskOperatorRecordEntity);
+    }
+
+    /// <summary>
+    /// 判断会签人数是否达到会签比例.
+    /// </summary>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    /// <param name="handleStatus">审批类型（0：拒绝，1：同意）.</param>
+    /// <returns></returns>
+    public bool IsAchievebilProportion(FlowTaskParamter flowTaskParamter, int handleStatus)
+    {
+        var index = flowTaskParamter.approversProperties.countersignRatio;
+        if (flowTaskParamter.thisFlowTaskOperatorEntityList.Count == 0)
+            return true;
+        if (handleStatus == 0)
+            index = 100 - index;
+        //完成人数（加上当前审批人）
+        var comIndex = flowTaskParamter.thisFlowTaskOperatorEntityList.FindAll(x => x.HandleStatus == handleStatus && x.Completion == 1 && x.State == "0").Count.ParseToDouble();
+        if (flowTaskParamter.freeApproverUserId.IsNullOrEmpty())
+        {
+            ++comIndex;
+        }
+        //完成比例
+        var comProportion = (comIndex / flowTaskParamter.thisFlowTaskOperatorEntityList.Count.ParseToDouble() * 100).ParseToInt();
+        return comProportion >= index;
+    }
+
+    /// <summary>
+    /// 获取cron表达式.
+    /// </summary>
+    /// <param name="overTimeDuring">间隔.</param>
+    /// <param name="startingTime">起始时间.</param>
+    /// <param name="type">0：小时 1：分钟.</param>
+    /// <returns></returns>
+    public string GetCron(int overTimeDuring, DateTime startingTime, int type = 0)
+    {
+        if (type == 0)
+        {
+            return string.Format("{0} {1} 0/{2} * * ?", startingTime.Second, startingTime.Minute, overTimeDuring);
+        }
+        else
+        {
+            return string.Format("{0} 0/{1} * * * ?", startingTime.Second, overTimeDuring);
+        }
+    }
+
+    /// <summary>
+    /// 获取起始时间.
+    /// </summary>
+    /// <param name="timeOutConfig">限时配置.</param>
+    /// <param name="receiveTime">接收时间.</param>
+    /// <param name="createTime">发起时间.</param>
+    /// <param name="formData">表单数据.</param>
+    /// <returns></returns>
+    public DateTime GetStartingTime(TimeOutConfig timeOutConfig, DateTime receiveTime, DateTime createTime, string formData)
+    {
+        var dt = DateTime.Now;
+        switch (timeOutConfig.nodeLimit)
+        {
+            case 0:
+                dt = receiveTime;
+                break;
+            case 1:
+                dt = createTime;
+                break;
+            case 2:
+                var jobj = formData.ToObject();
+                if (jobj.ContainsKey(timeOutConfig.formField))
+                {
+                    try
+                    {
+                        if (jobj[timeOutConfig.formField] is long)
+                        {
+                            dt = jobj[timeOutConfig.formField].ParseToLong().TimeStampToDateTime();
+                        }
+                        else
+                        {
+                            dt = jobj[timeOutConfig.formField].ToString().ParseToDateTime();
+                        }
+                    }
+                    catch (Exception)
+                    {
+                        break;
+                    }
+                }
+                break;
+        }
+        return dt;
+    }
+
+    /// <summary>
+    /// 获取下一节点表单初始数据并保存.
+    /// </summary>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    /// <param name="nextNodeList">下一节点.</param>
+    /// <returns></returns>
+    public async Task<Dictionary<string, object>> GetNextFormData(FlowTaskParamter flowTaskParamter, List<FlowTaskNodeEntity> nextNodeList)
+    {
+        var nextNodeData = new Dictionary<string, object>();
+        var mapRule = new List<Dictionary<string, string>>();
+        var thisFormId = flowTaskParamter.flowTaskNodeEntity.FormId;
+        foreach (var item in nextNodeList)
+        {
+            if (FlowTaskNodeTypeEnum.approver.ParseToString().Equals(item.NodeType))
+            {
+                var approversPro = item.NodePropertyJson.ToObject<ApproversProperties>();
+                var nextFormId = item.FormId;
+                if (FlowTaskNodeTypeEnum.subFlow.ParseToString().Equals(flowTaskParamter.flowTaskNodeEntity.NodeType))
+                {
+                    // 传递节点
+                    var extendNode = approversPro.assignList.Select(x => x.nodeId).ToList();
+                    // 最后审批节点
+                    var lastHandleNode = (await _flowTaskRepository.GetTaskOperatorRecordList(x => x.TaskId == flowTaskParamter.flowTaskEntity.Id && (x.HandleStatus == 1 || x.HandleStatus == 2), o => o.HandleTime, SqlSugar.OrderByType.Desc)).FirstOrDefault();
+                    if (extendNode.Any())
+                    {
+                        lastHandleNode = (await _flowTaskRepository.GetTaskOperatorRecordList(x => extendNode.Contains(x.NodeCode) && x.TaskId == flowTaskParamter.flowTaskEntity.Id && (x.HandleStatus == 1 || x.HandleStatus == 2), o => o.HandleTime, SqlSugar.OrderByType.Desc)).FirstOrDefault();
+                    }
+                    if (lastHandleNode.IsNotEmptyOrNull() && lastHandleNode.NodeCode.IsNotEmptyOrNull())
+                    {
+                        thisFormId = flowTaskParamter.flowTaskNodeEntityList.Find(x => x.Id == lastHandleNode.TaskNodeId)?.FormId;
+                        mapRule = GetMapRule(approversPro.assignList, lastHandleNode.NodeCode);
+                    }
+                }
+                else
+                {
+                    mapRule = GetMapRule(approversPro.assignList, flowTaskParamter.flowTaskNodeEntity.NodeCode);
+                }
+                var data =await _runService.GetFlowFormDataDetails(thisFormId, flowTaskParamter.flowTaskEntity.Id);
+                var nextFormData = await _runService.SaveDataToDataByFId(thisFormId, nextFormId, mapRule, data);
+                nextNodeData[item.NodeCode] = nextFormData;
+            }
+        }
+        return nextNodeData;
+    }
+
+    /// <summary>
+    /// 获取表单传递字段.
+    /// </summary>
+    /// <param name="assignItems">传递规则.</param>
+    /// <param name="nodeCode">传递节点编码.</param>
+    /// <returns></returns>
+    private List<Dictionary<string, string>> GetMapRule(List<AssignItem> assignItems, string nodeCode)
+    {
+        if (!assignItems.Any()) return null;
+        var ruleList = assignItems.Find(x => x.nodeId == nodeCode)?.ruleList;
+        var mapRule = new List<Dictionary<string, string>>();
+        if (ruleList.IsNotEmptyOrNull())
+        {
+            foreach (var item in ruleList)
+            {
+                if (item.parentField.IsNotEmptyOrNull())
+                {
+                    var dic = new Dictionary<string, string>();
+                    dic.Add(item.parentField, item.childField);
+                    mapRule.Add(dic);
+                }
+            }
+        }
+        return mapRule;
+    }
+
+    /// <summary>
+    /// 终止任务(包含子流程任务).
+    /// </summary>
+    /// <param name="flowTaskEntity">当前任务.</param>
+    /// <returns></returns>
+    public async Task CancelTask(FlowTaskEntity flowTaskEntity)
+    {
+        flowTaskEntity.Status = FlowTaskStatusEnum.Cancel.ParseToInt();
+        flowTaskEntity.EndTime = DateTime.Now;
+        await _flowTaskRepository.UpdateTask(flowTaskEntity);
+        foreach (var item in await _flowTaskRepository.GetTaskNodeList(x => x.TaskId == flowTaskEntity.Id))
+        {
+            SpareTime.Cancel("CS_" + item.Id);
+            SpareTime.Cancel("TX_" + item.Id);
+        }
+        var childTaskList = await _flowTaskRepository.GetTaskList(x => flowTaskEntity.Id == x.ParentId && x.DeleteMark == null);
+        foreach (var item in childTaskList)
+        {
+            await CancelTask(item);
+        }
+    }
+
+    /// <summary>
+    /// 同步发起配置.
+    /// </summary>
+    /// <param name="approversPro"></param>
+    /// <param name="startPro"></param>
+    /// <returns></returns>
+    public ApproversProperties SyncApproProCofig(ApproversProperties approversPro, StartProperties startPro)
+    {
+        approversPro.timeLimitConfig = approversPro.timeLimitConfig.on == 2 ? startPro.timeLimitConfig : approversPro.timeLimitConfig;//限时配置
+        approversPro.noticeConfig = approversPro.noticeConfig.on == 2 ? startPro.noticeConfig : approversPro.noticeConfig;//提醒配置
+        approversPro.overTimeConfig = approversPro.overTimeConfig.on == 2 ? startPro.overTimeConfig : approversPro.overTimeConfig;//超时配置
+        approversPro.approveMsgConfig = approversPro.approveMsgConfig.on == 2 ? startPro.approveMsgConfig : approversPro.approveMsgConfig;//同意
+        approversPro.rejectMsgConfig = approversPro.rejectMsgConfig.on == 2 ? startPro.rejectMsgConfig : approversPro.rejectMsgConfig;//退回
+        approversPro.copyMsgConfig = approversPro.copyMsgConfig.on == 2 ? startPro.copyMsgConfig : approversPro.copyMsgConfig;//抄送
+        approversPro.overTimeMsgConfig = approversPro.overTimeMsgConfig.on == 2 ? startPro.overTimeMsgConfig : approversPro.overTimeMsgConfig;//超时
+        approversPro.noticeMsgConfig = approversPro.noticeMsgConfig.on == 2 ? startPro.noticeMsgConfig : approversPro.noticeMsgConfig;//提醒
+        return approversPro;
+    }
+}

workflow/Tnb.WorkFlow/Manager/FlowTaskUserUtil.cs

@@ -0,0 +1,759 @@
+using JNPF.Common.Const;
+using JNPF.Common.Core.Manager;
+using JNPF.Common.Enums;
+using JNPF.Common.Extension;
+using JNPF.Common.Filter;
+using JNPF.Common.Manager;
+using JNPF.Common.Models.User;
+using JNPF.Common.Models.WorkFlow;
+using JNPF.Common.Security;
+using JNPF.FriendlyException;
+using JNPF.RemoteRequest.Extensions;
+using JNPF.Systems.Entitys.Dto.User;
+using JNPF.Systems.Entitys.Permission;
+using JNPF.Systems.Interfaces.Permission;
+using JNPF.UnifyResult;
+using JNPF.WorkFlow.Entitys.Entity;
+using JNPF.WorkFlow.Entitys.Enum;
+using JNPF.WorkFlow.Entitys.Model;
+using JNPF.WorkFlow.Entitys.Model.Properties;
+using JNPF.WorkFlow.Interfaces.Repository;
+using Mapster;
+using Newtonsoft.Json.Linq;
+using SqlSugar;
+
+namespace JNPF.WorkFlow.Manager;
+
+public class FlowTaskUserUtil
+{
+    private readonly IFlowTaskRepository _flowTaskRepository;
+    private readonly IUsersService _usersService;
+    private readonly IOrganizeService _organizeService;
+    private readonly IDepartmentService _departmentService;
+    private readonly IUserRelationService _userRelationService;
+    private readonly IUserManager _userManager;
+    private readonly ICacheManager _cacheManager;
+
+    public FlowTaskUserUtil(IFlowTaskRepository flowTaskRepository, IUsersService usersService, IOrganizeService organizeService, IDepartmentService departmentService, IUserRelationService userRelationService, IUserManager userManager, ICacheManager cacheManager)
+    {
+        _flowTaskRepository = flowTaskRepository;
+        _usersService = usersService;
+        _organizeService = organizeService;
+        _departmentService = departmentService;
+        _userRelationService = userRelationService;
+        _userManager = userManager;
+        _cacheManager = cacheManager;
+    }
+
+    /// <summary>
+    /// 获取节点审批人员id.
+    /// </summary>
+    /// <param name="flowTaskParamter">当前任务参数.</param>
+    /// <param name="approversProperties">节点属性.</param>
+    /// <param name="flowTaskNodeEntity">节点实体.</param>
+    /// <returns></returns>
+    public async Task<List<string>> GetFlowUserId(FlowTaskParamter flowTaskParamter, ApproversProperties approversProperties, FlowTaskNodeEntity flowTaskNodeEntity)
+    {
+        var userIdList = new List<string>();
+        // 获取全部用户id
+        var userList1 = await _usersService.GetUserListByExp(x => x.DeleteMark == null && x.EnabledMark == 1, u => new UserEntity() { Id = u.Id });
+        // 发起者本人.
+        var userEntity = _usersService.GetInfoByUserId(flowTaskParamter.flowTaskEntity.CreatorUserId);
+        switch (approversProperties.assigneeType)
+        {
+            // 发起者主管
+            case (int)FlowTaskOperatorEnum.LaunchCharge:
+                var crDirector = await GetManagerByLevel(userEntity.ManagerId, approversProperties.managerLevel);
+                if (crDirector.IsNotEmptyOrNull())
+                    userIdList.Add(crDirector);
+                break;
+
+            // 发起者本人
+            case (int)FlowTaskOperatorEnum.InitiatorMe:
+                userIdList.Add(userEntity.Id);
+                break;
+
+            // 部门主管
+            case (int)FlowTaskOperatorEnum.DepartmentCharge:
+                var organizeEntity = await _organizeService.GetInfoById(userEntity.OrganizeId);
+                if (organizeEntity.IsNotEmptyOrNull() && organizeEntity.OrganizeIdTree.IsNotEmptyOrNull())
+                {
+                    var orgTree = organizeEntity.OrganizeIdTree.Split(",").Reverse().ToList();
+                    if (orgTree.Count >= approversProperties.departmentLevel)
+                    {
+                        var orgId = orgTree[approversProperties.departmentLevel - 1];
+                        var organize = await _organizeService.GetInfoById(orgId);
+                        if (organize.IsNotEmptyOrNull() && organize.ManagerId.IsNotEmptyOrNull())
+                        {
+                            userIdList.Add(organize.ManagerId);
+                        }
+                    }
+                }
+                break;
+
+            // 表单变量
+            case (int)FlowTaskOperatorEnum.VariableApprover:
+                var jd = flowTaskParamter.formData.ToObject<JObject>();
+                var fieldValueList = new List<string>();
+                var formField = approversProperties.formField;
+                if (approversProperties.assignList.Any() && flowTaskParamter.flowTaskNodeEntity.IsNotEmptyOrNull())
+                {
+                    var ruleList = approversProperties.assignList.Find(x => x.nodeId == flowTaskParamter.flowTaskNodeEntity.NodeCode)?.ruleList;
+                    if (ruleList.IsNotEmptyOrNull() && ruleList.Any(x => x.childField == approversProperties.formField))
+                    {
+                        formField = ruleList.Find(x => x.childField == approversProperties.formField)?.parentField;
+                    }
+                }
+                if (jd.ContainsKey(formField))
+                {
+                    if (jd[formField] is JArray)
+                    {
+                        fieldValueList = jd[formField].ToObject<List<string>>();
+                    }
+                    else
+                    {
+                        if (jd[formField].ToString().IsNotEmptyOrNull())
+                        {
+                            fieldValueList = jd[formField].ToString().Split(",").ToList();
+                        }
+                    }
+                }
+                userIdList = _userRelationService.GetUserId(fieldValueList, string.Empty);
+                break;
+
+            // 环节(提交时下个节点是环节就跳过，审批则看环节节点是否是当前节点的上级)
+            case (int)FlowTaskOperatorEnum.LinkApprover:
+                if (flowTaskParamter.flowTaskNodeEntityList.Any(x => x.NodeCode.Equals(approversProperties.nodeId) && x.SortCode < flowTaskNodeEntity.SortCode))
+                {
+                    // 环节节点所有经办人(过滤掉加签人)
+                    userIdList = (await _flowTaskRepository.GetTaskOperatorRecordList(x =>
+                        x.TaskId == flowTaskNodeEntity.TaskId && !SqlFunc.IsNullOrEmpty(x.NodeCode)
+                        && x.NodeCode.Equals(approversProperties.nodeId) && x.HandleStatus == 1 && x.Status == 0))
+                        .Where(x => HasFreeApprover(x.TaskOperatorId).Result).Where(x => x.HandleId.IsNotEmptyOrNull()).Select(x => x.HandleId).Distinct().ToList();
+                }
+                break;
+
+            // 接口(接口结构为{"code":200,"data":{"handleId":"admin"},"msg":""})
+            case (int)FlowTaskOperatorEnum.ServiceApprover:
+                try
+                {
+                    var Token = _userManager.ToKen.IsNotEmptyOrNull() ? _userManager.ToKen : _cacheManager.Get<List<UserOnlineModel>>(CommonConst.CACHEKEYONLINEUSER + _userManager.TenantId).Find(x => x.userId == _userManager.UserId).token;
+                    var data = await approversProperties.getUserUrl.SetHeaders(new { Authorization = Token }).GetAsStringAsync();
+                    var result = data.ToObject<RESTfulResult<object>>();
+                    if (result.IsNotEmptyOrNull())
+                    {
+                        var resultJobj = result.data.ToObject<JObject>();
+                        if (result.code == 200)
+                        {
+                            var handleId = resultJobj["handleId"].ToString();
+                            var handleIdList = handleId.Split(",").ToList();
+                            var userList2 = await _usersService.GetUserListByExp(x => x.DeleteMark == null, u => new UserEntity() { Id = u.Id });
+
+                            // 利用list交集方法过滤非用户数据
+                            userIdList = userList2.Select(x => x.Id).Intersect(handleIdList).ToList();
+                        }
+                    }
+                }
+                catch (AppFriendlyException ex)
+                {
+                    break;
+                }
+
+                break;
+
+            // 候选人
+            case (int)FlowTaskOperatorEnum.CandidateApprover:
+                userIdList = _flowTaskRepository.GetFlowCandidates(flowTaskNodeEntity.Id);
+                break;
+            default:
+                userIdList = (await GetUserDefined(approversProperties));
+                userIdList = await GetExtraRuleUsers(userIdList, approversProperties.extraRule, flowTaskNodeEntity.TaskId);
+                break;
+        }
+        userIdList = userList1.Select(x => x.Id).Intersect(userIdList).ToList();// 过滤掉作废人员和非用户人员
+        if (userIdList.Count == 0)
+        {
+            userIdList = _flowTaskRepository.GetFlowCandidates(flowTaskNodeEntity.Id);
+        }
+        return userIdList.Distinct().ToList();
+
+    }
+
+    /// <summary>
+    /// 附加条件过滤.
+    /// </summary>
+    /// <param name="userList">过滤用户.</param>
+    /// <param name="extraRule">过滤规则.</param>
+    /// <param name="taskId">任务id.</param>
+    /// <returns></returns>
+    private async Task<List<string>> GetExtraRuleUsers(List<string> userList, string extraRule, string taskId)
+    {
+        var flowUserEntity = _flowTaskRepository.GetFlowUserEntity(taskId);
+        if (flowUserEntity.IsNullOrEmpty())
+        {
+            var subordinate = (await _usersService.GetUserListByExp(u => u.EnabledMark == 1 && u.DeleteMark == null && u.ManagerId == _userManager.UserId)).Select(u => u.Id).ToList().ToJsonString();
+            flowUserEntity = new FlowUserEntity()
+            {
+                OrganizeId = _userManager.User.OrganizeId,
+                PositionId = _userManager.User.PositionId,
+                ManagerId = _userManager.User.ManagerId,
+                Subordinate = subordinate
+            };
+        }
+        switch (extraRule)
+        {
+            case "2":
+                userList = _userRelationService.GetUserId("Organize", flowUserEntity.OrganizeId).Intersect(userList).ToList();
+                break;
+            case "3":
+                userList = _userRelationService.GetUserId("Position", flowUserEntity.PositionId).Intersect(userList).ToList();
+                break;
+            case "4":
+                userList = new List<string> { flowUserEntity.ManagerId }.Intersect(userList).ToList();
+                break;
+            case "5":
+                userList = flowUserEntity.Subordinate.ToObject<List<string>>().Intersect(userList).ToList();
+                break;
+            case "6":
+                // 直属公司id
+                var companyId = _departmentService.GetCompanyId(flowUserEntity.OrganizeId);
+                var objIdList = (await _departmentService.GetCompanyAllDep(companyId)).Select(x => x.Id).ToList();
+                objIdList.Add(companyId);
+                userList = _userRelationService.GetUserId(objIdList, "Organize").Intersect(userList).ToList();
+                break;
+        }
+        return userList;
+    }
+
+    /// <summary>
+    /// 根据类型获取审批人.
+    /// </summary>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    /// <param name="nextFlowTaskNodeEntity">下个审批节点数据.</param>
+    /// <param name="type">操作标识（0：提交，1：审批，3:变更）.</param>
+    /// <param name="isShuntNodeCompletion">是否分流合流已完成.</param>
+    /// <returns></returns>
+    public async Task AddFlowTaskOperatorEntityByAssigneeType(FlowTaskParamter flowTaskParamter, FlowTaskNodeEntity nextFlowTaskNodeEntity, int type = 1, bool isShuntNodeCompletion = true)
+    {
+        try
+        {
+            if (FlowTaskNodeTypeEnum.approver.ParseToString().Equals(nextFlowTaskNodeEntity.NodeType))
+            {
+                var approverPropertiers = nextFlowTaskNodeEntity.NodePropertyJson.ToObject<ApproversProperties>();
+                var errorUserId = new List<string>();
+                if (flowTaskParamter.errorRuleUserList.IsNotEmptyOrNull() && flowTaskParamter.errorRuleUserList.ContainsKey(nextFlowTaskNodeEntity.NodeCode))
+                {
+                    errorUserId = flowTaskParamter.errorRuleUserList[nextFlowTaskNodeEntity.NodeCode];
+                }
+                var startProperties = flowTaskParamter.startProperties;
+                if (type == 3)
+                {
+                    startProperties.errorRule = "3";
+                }
+                // 创建人
+                var userId = type == 0 ? _userManager.UserId : flowTaskParamter.flowTaskEntity.CreatorUserId;
+                var handleIds = await GetFlowUserId(flowTaskParamter, approverPropertiers, nextFlowTaskNodeEntity);
+                if (handleIds.Count == 0 && isShuntNodeCompletion)
+                {
+                    switch (startProperties.errorRule)
+                    {
+                        case "1":
+                            handleIds.Add("admin");
+                            break;
+                        case "2":
+                            if ((await _usersService.GetUserListByExp(x => startProperties.errorRuleUser.Contains(x.Id) && x.DeleteMark == null && x.EnabledMark == 1)).Any())
+                            {
+                                handleIds = startProperties.errorRuleUser;
+                            }
+                            else
+                            {
+                                handleIds.Add("admin");
+                            }
+                            break;
+                        case "3":
+                            if (errorUserId.IsNotEmptyOrNull() && errorUserId.Count > 0)
+                            {
+                                handleIds = errorUserId;
+                            }
+                            else
+                            {
+                                if (!flowTaskParamter.errorNodeList.Select(x => x.nodeId).Contains(nextFlowTaskNodeEntity.NodeCode))
+                                {
+                                    flowTaskParamter.errorNodeList.Add(new FlowTaskCandidateModel { nodeId = nextFlowTaskNodeEntity.NodeCode, nodeName = nextFlowTaskNodeEntity.NodeName });
+                                }
+                            }
+                            break;
+                        case "4":
+                            // 异常节点下一节点是否存在候选人节点.
+                            var falag = flowTaskParamter.flowTaskNodeEntityList.
+                                Any(x => nextFlowTaskNodeEntity.NodeNext.Split(",").Contains(x.NodeCode)
+                                && FlowTaskNodeTypeEnum.approver.ParseToString().Equals(x.NodeType)
+                                && x.NodePropertyJson.ToObject<ApproversProperties>().assigneeType == 7);
+                            if (falag)
+                            {
+                                handleIds.Add("admin");
+                            }
+                            else
+                            {
+                                handleIds.Add("jnpf");
+                            }
+                            break;
+                        case "5":
+                            throw Oops.Oh(ErrorCode.WF0035);
+                    }
+                }
+                var index = 0;
+                var isAnyOperatorUser = !_flowTaskRepository.AnyTaskOperatorUser(x => x.TaskNodeId == nextFlowTaskNodeEntity.Id && x.State == "0");// 不存在依次审批插入.
+                var OperatorUserList = new List<FlowTaskOperatorUserEntity>();
+                foreach (var item in handleIds)
+                {
+                    if (item.IsNotEmptyOrNull())
+                    {
+                        if (approverPropertiers.counterSign == 2 && isAnyOperatorUser)
+                        {
+                            FlowTaskOperatorUserEntity flowTaskOperatorUserEntity = new FlowTaskOperatorUserEntity();
+                            flowTaskOperatorUserEntity.Id = SnowflakeIdHelper.NextId();
+                            flowTaskOperatorUserEntity.NodeCode = nextFlowTaskNodeEntity.NodeCode;
+                            flowTaskOperatorUserEntity.NodeName = nextFlowTaskNodeEntity.NodeName;
+                            flowTaskOperatorUserEntity.TaskNodeId = nextFlowTaskNodeEntity.Id;
+                            flowTaskOperatorUserEntity.TaskId = nextFlowTaskNodeEntity.TaskId;
+                            flowTaskOperatorUserEntity.CreatorTime = GetTimerDate(approverPropertiers, flowTaskParamter.flowTaskNodeEntity.NodeCode);
+                            flowTaskOperatorUserEntity.Completion = 0;
+                            flowTaskOperatorUserEntity.State = "0";
+                            flowTaskOperatorUserEntity.Type = approverPropertiers.assigneeType.ToString();
+                            flowTaskOperatorUserEntity.HandleId = item;
+                            flowTaskOperatorUserEntity.SortCode = index++;
+                            OperatorUserList.Add(flowTaskOperatorUserEntity);
+                            if (index == 1)
+                            {
+                                flowTaskParamter.flowTaskOperatorEntityList.Add(OperatorUserList.FirstOrDefault().Adapt<FlowTaskOperatorEntity>());
+                            }
+                        }
+                        else
+                        {
+                            FlowTaskOperatorEntity flowTaskOperatorEntity = new FlowTaskOperatorEntity();
+                            flowTaskOperatorEntity.Id = SnowflakeIdHelper.NextId();
+                            flowTaskOperatorEntity.NodeCode = nextFlowTaskNodeEntity.NodeCode;
+                            flowTaskOperatorEntity.NodeName = nextFlowTaskNodeEntity.NodeName;
+                            flowTaskOperatorEntity.TaskNodeId = nextFlowTaskNodeEntity.Id;
+                            flowTaskOperatorEntity.TaskId = nextFlowTaskNodeEntity.TaskId;
+                            flowTaskOperatorEntity.CreatorTime = GetTimerDate(approverPropertiers, flowTaskParamter.flowTaskNodeEntity.NodeCode);
+                            flowTaskOperatorEntity.Completion = 0;
+                            flowTaskOperatorEntity.State = "0";
+                            flowTaskOperatorEntity.Type = approverPropertiers.assigneeType.ToString();
+                            flowTaskOperatorEntity.HandleId = item;
+                            flowTaskOperatorEntity.SortCode = index++;
+                            flowTaskParamter.flowTaskOperatorEntityList.Add(flowTaskOperatorEntity);
+                        }
+                    }
+                }
+                await _flowTaskRepository.CreateTaskOperatorUser(OperatorUserList);
+            }
+        }
+        catch (AppFriendlyException ex)
+        {
+            throw Oops.Oh(ex.ErrorCode);
+        }
+    }
+
+    /// <summary>
+    /// 获取抄送人.
+    /// </summary>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    /// <param name="handleStatus">审批类型（0：拒绝，1：同意）.</param>
+    public async Task GetflowTaskCirculateEntityList(FlowTaskParamter flowTaskParamter, int handleStatus)
+    {
+        var circulateUserList = flowTaskParamter.copyIds.IsNotEmptyOrNull() ? flowTaskParamter.copyIds.Split(",").ToList() : new List<string>();
+        #region 抄送人
+        if (handleStatus == 1)
+        {
+            var userList = await GetUserDefined(flowTaskParamter.approversProperties, 1);
+            userList = await GetExtraRuleUsers(userList, flowTaskParamter.approversProperties.extraCopyRule, flowTaskParamter.flowTaskOperatorEntity.TaskId);
+            circulateUserList = circulateUserList.Union(userList).ToList();
+        }
+        foreach (var item in circulateUserList.Distinct())
+        {
+            flowTaskParamter.flowTaskCirculateEntityList.Add(new FlowTaskCirculateEntity()
+            {
+                Id = SnowflakeIdHelper.NextId(),
+                ObjectType = flowTaskParamter.flowTaskOperatorEntity.Type,
+                ObjectId = item,
+                NodeCode = flowTaskParamter.flowTaskOperatorEntity.NodeCode,
+                NodeName = flowTaskParamter.flowTaskOperatorEntity.NodeName,
+                TaskNodeId = flowTaskParamter.flowTaskOperatorEntity.TaskNodeId,
+                TaskId = flowTaskParamter.flowTaskOperatorEntity.TaskId,
+                CreatorTime = DateTime.Now,
+            });
+        }
+        #endregion
+    }
+
+    /// <summary>
+    /// 获取自定义人员名称.
+    /// </summary>
+    /// <param name="approversProperties">节点属性.</param>
+    /// <param name="userNameList">用户名称容器.</param>
+    /// <param name="userIdList">用户id容器.</param>
+    /// <returns></returns>
+    public async Task GetUserNameDefined(ApproversProperties approversProperties, List<string> userNameList, List<string> userIdList = null)
+    {
+        if (userIdList == null)
+        {
+            userIdList = (await GetUserDefined(approversProperties)).Distinct().ToList();
+        }
+        foreach (var item in userIdList)
+        {
+            var name = await _usersService.GetUserName(item);
+            if (name.IsNotEmptyOrNull())
+                userNameList.Add(name);
+        }
+    }
+
+    /// <summary>
+    /// 获取候选人节点信息.
+    /// </summary>
+    /// <param name="flowTaskCandidateModels">返回参数.</param>
+    /// <param name="nextNodeEntities">下一节点集合.</param>
+    /// <param name="nodeEntities">所有节点.</param>
+    /// <returns></returns>
+    public async Task GetCandidates(List<FlowTaskCandidateModel> flowTaskCandidateModels, List<FlowTaskNodeEntity> nextNodeEntities, List<FlowTaskNodeEntity> nodeEntities)
+    {
+        foreach (var item in nextNodeEntities)
+        {
+            ApproversProperties approverPropertiers = null;
+            var isSubFlow = false;//是否子流程节点.
+            if (FlowTaskNodeTypeEnum.approver.ParseToString().Equals(item.NodeType))
+                approverPropertiers = item.NodePropertyJson.ToObject<ApproversProperties>();
+            if (FlowTaskNodeTypeEnum.subFlow.ParseToString().Equals(item.NodeType))
+            {
+                approverPropertiers = item.NodePropertyJson.ToObject<ChildTaskProperties>().Adapt<ApproversProperties>();
+                isSubFlow = true;
+            }
+
+            if (approverPropertiers.IsNotEmptyOrNull())
+            {
+                if (approverPropertiers.assigneeType == 7 || approverPropertiers.isBranchFlow)
+                {
+                    var candidateItem = new FlowTaskCandidateModel();
+                    candidateItem.nodeId = item.NodeCode;
+                    candidateItem.nodeName = item.NodeName;
+                    candidateItem.isBranchFlow = approverPropertiers.isBranchFlow;
+                    candidateItem.isCandidates = approverPropertiers.assigneeType == 7;
+                    var objIds = approverPropertiers.approverRole
+                        .Union(approverPropertiers.approverPos)
+                        .Union(approverPropertiers.approverOrg)
+                        .Union(approverPropertiers.approverGroup).ToList();
+                    var flag = false;//是否有数据
+                    var input = new UserConditionInput()
+                    {
+                        departIds = objIds,
+                        userIds = approverPropertiers.approvers,
+                        pagination = new PageInputBase()
+                    };
+                    _userRelationService.GetUserPage(input, ref flag);
+                    candidateItem.hasCandidates = flag;
+                    flowTaskCandidateModels.Add(candidateItem);
+                }
+            }
+            // 子流程节点则要看下一节点是否存在候选人或选择分支
+            if (isSubFlow)
+            {
+                var subFlowNextNodes = nodeEntities.FindAll(m => item.NodeNext.Contains(m.NodeCode));
+                await GetCandidates(flowTaskCandidateModels, subFlowNextNodes, nodeEntities);
+            }
+        }
+    }
+
+    /// <summary>
+    /// 候选人员列表.
+    /// </summary>
+    /// <param name="nextNodeEntity">下一节点.</param>
+    /// <param name="flowHandleModel">审批参数.</param>
+    /// <param name="hasCandidates">是否存在候选人.</param>
+    /// <returns></returns>
+    public dynamic GetCandidateItems(FlowTaskNodeEntity nextNodeEntity, FlowHandleModel flowHandleModel, bool hasCandidates = true)
+    {
+        var approverPropertiers = nextNodeEntity.NodePropertyJson.ToObject<ApproversProperties>();
+        if (FlowTaskNodeTypeEnum.subFlow.ParseToString().Equals(nextNodeEntity.NodeType))
+        {
+            approverPropertiers = nextNodeEntity.NodePropertyJson.ToObject<ChildTaskProperties>().Adapt<ApproversProperties>();
+        }
+        var objIds = approverPropertiers.approverRole
+                        .Union(approverPropertiers.approverPos)
+                        .Union(approverPropertiers.approverOrg)
+                        .Union(approverPropertiers.approverGroup).ToList();
+        var input = new UserConditionInput()
+        {
+            departIds = objIds,
+            userIds = approverPropertiers.approvers,
+            pagination = flowHandleModel
+        };
+        return _userRelationService.GetUserPage(input, ref hasCandidates);
+    }
+
+    /// <summary>
+    /// 获取子流程下异常节点信息.
+    /// </summary>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    /// <param name="nextNodeEntities">下一节点集合.</param>
+    /// <returns></returns>
+    public async Task GetErrorNode(FlowTaskParamter flowTaskParamter, List<FlowTaskNodeEntity> nextNodeEntities)
+    {
+        try
+        {
+            foreach (var item in nextNodeEntities)
+            {
+                if (FlowTaskNodeTypeEnum.approver.ParseToString().Equals(item.NodeType))
+                {
+                    var approverPropertiers = item.NodePropertyJson.ToObject<ApproversProperties>();
+                    var list = await GetFlowUserId(flowTaskParamter, approverPropertiers, item);
+                    if (list.Count == 0)
+                    {
+                        if (flowTaskParamter.startProperties.errorRule == "3" && !flowTaskParamter.errorNodeList.Select(x => x.nodeId).Contains(item.NodeCode))
+                        {
+                            var candidateItem = new FlowTaskCandidateModel();
+                            candidateItem.nodeId = item.NodeCode;
+                            candidateItem.nodeName = item.NodeName;
+                            flowTaskParamter.errorNodeList.Add(candidateItem);
+                        }
+                        if (flowTaskParamter.startProperties.errorRule == "5")
+                            throw Oops.Oh(ErrorCode.WF0035);
+                    }
+                }
+                else if (FlowTaskNodeTypeEnum.subFlow.ParseToString().Equals(item.NodeType))
+                {
+                    var subFlowNextNodes = flowTaskParamter.flowTaskNodeEntityList.FindAll(m => item.NodeNext.Contains(m.NodeCode));
+                    await GetErrorNode(flowTaskParamter, subFlowNextNodes);
+                }
+            }
+        }
+        catch (AppFriendlyException ex)
+        {
+            throw Oops.Oh(ex.ErrorCode);
+        }
+    }
+
+    /// <summary>
+    /// 获取子流程发起人.
+    /// </summary>
+    /// <param name="childTaskProperties">子流程属性.</param>
+    /// <param name="flowTaskParamter">当前任务参数.</param>
+    /// <param name="flowTaskNodeEntity">子流程节点.</param>
+    /// <returns></returns>
+    public async Task<List<string>> GetSubFlowCrUser(ChildTaskProperties childTaskProperties, FlowTaskParamter flowTaskParamter, FlowTaskNodeEntity flowTaskNodeEntity)
+    {
+        var approverPropertiers = childTaskProperties.Adapt<ApproversProperties>();
+        var childTaskCrUserList = await GetFlowUserId(flowTaskParamter, approverPropertiers, flowTaskNodeEntity);
+        if (childTaskCrUserList.Count == 0)
+        {
+            switch (childTaskProperties.errorRule)
+            {
+                case "2":
+                    if ((await _usersService.GetUserListByExp(x => childTaskProperties.errorRuleUser.Contains(x.Id) && x.DeleteMark == null && x.EnabledMark == 1)).Any())
+                    {
+                        childTaskCrUserList = childTaskProperties.errorRuleUser;
+                    }
+                    else
+                    {
+                        childTaskCrUserList.Add("admin");
+                    }
+                    break;
+                case "6":
+                    childTaskCrUserList.Add(flowTaskParamter.flowTaskEntity.CreatorUserId);
+                    break;
+                default:
+                    childTaskCrUserList.Add("admin");
+                    break;
+            }
+        }
+        return childTaskCrUserList;
+    }
+
+    /// <summary>
+    /// 获取审批人名称.
+    /// </summary>
+    /// <param name="flowTaskNodeModel">当前节点.</param>
+    /// <param name="flowTaskParamter">任务参数.</param>
+    /// <param name="flowJsonModel">流程实体.</param>
+    /// <returns></returns>
+    public async Task<string> GetApproverUserName(FlowTaskNodeModel flowTaskNodeModel, FlowTaskParamter flowTaskParamter, FlowJsonModel flowJsonModel)
+    {
+        var userNameList = new List<string>();
+        var userName = await _usersService.GetUserName(flowTaskParamter.flowTaskEntity.CreatorUserId);
+        if (flowTaskNodeModel.nodeType.Equals(FlowTaskNodeTypeEnum.start.ParseToString()))
+        {
+            if (flowJsonModel.visibleType == 0)
+            {
+                userNameList.Add(userName);
+            }
+            else
+            {
+                await GetUserNameDefined(flowTaskParamter.startProperties.Adapt<ApproversProperties>(), userNameList);
+            }
+        }
+        else if (flowTaskNodeModel.nodeType.Equals(FlowTaskNodeTypeEnum.subFlow.ParseToString()))
+        {
+            var subFlowProperties = flowTaskNodeModel.nodePropertyJson.ToObject<ChildTaskProperties>();
+            var userIdList = (await _flowTaskRepository.GetTaskList(x => subFlowProperties.childTaskId.Contains(x.Id))).Select(x => x.CreatorUserId).ToList();
+            var approverProperties = subFlowProperties.Adapt<ApproversProperties>();
+            if (userIdList.Count == 0)
+            {
+                userIdList = await GetFlowUserId(flowTaskParamter, approverProperties, flowTaskNodeModel.Adapt<FlowTaskNodeEntity>());
+            }
+            await GetUserNameDefined(approverProperties, userNameList, userIdList);
+        }
+        else
+        {
+            var approverProperties = flowTaskNodeModel.nodePropertyJson.ToObject<ApproversProperties>();
+            var userIdList = (await _flowTaskRepository.GetTaskOperatorList(x => x.TaskNodeId == flowTaskNodeModel.id && SqlFunc.IsNullOrEmpty(x.ParentId) && !x.State.Equals("-1"))).Select(x => x.HandleId).Distinct().ToList();
+            if (approverProperties.counterSign == 2)
+            {
+                userIdList = (await _flowTaskRepository.GetTaskOperatorUserList(x => x.TaskId == flowTaskNodeModel.taskId && x.TaskNodeId == flowTaskNodeModel.id)).Select(x => x.HandleId).ToList();
+            }
+            if (!userIdList.Any())
+            {
+                userIdList = await GetFlowUserId(flowTaskParamter, approverProperties, flowTaskNodeModel.Adapt<FlowTaskNodeEntity>());
+            }
+            await GetUserNameDefined(approverProperties, userNameList, userIdList);
+        }
+        return string.Join(",", userNameList.Distinct());
+    }
+
+    /// <summary>
+    /// 获取级别主管.
+    /// </summary>
+    /// <param name="managerId">主管id.</param>
+    /// <param name="level">级别.</param>
+    /// <returns></returns>
+    public async Task<string> GetManagerByLevel(string managerId, int level)
+    {
+        --level;
+        if (level == 0)
+        {
+            return managerId;
+        }
+        else
+        {
+            var manager = await _usersService.GetInfoByUserIdAsync(managerId);
+            return manager.IsNullOrEmpty() ? string.Empty : await GetManagerByLevel(manager.ManagerId, level);
+        }
+    }
+
+    /// <summary>
+    /// 判断经办记录人是否加签且加签是否完成.
+    /// </summary>
+    /// <param name="id">经办id.</param>
+    /// <returns></returns>
+    public async Task<bool> HasFreeApprover(string id)
+    {
+        var entityList = await GetOperator(id, new List<FlowTaskOperatorEntity>());
+        if (entityList.Count == 0)
+        {
+            return true;
+        }
+        else
+        {
+            return !entityList.Any(x => x.HandleStatus.IsEmpty() || x.HandleStatus == 0);
+        }
+    }
+
+    /// <summary>
+    /// 递归获取加签人.
+    /// </summary>
+    /// <param name="id">经办id.</param>
+    /// <param name="flowTaskOperatorEntities">所有经办.</param>
+    /// <returns></returns>
+    public async Task<List<FlowTaskOperatorEntity>> GetOperator(string id, List<FlowTaskOperatorEntity> flowTaskOperatorEntities)
+    {
+        var childEntity = await _flowTaskRepository.GetTaskOperatorInfo(x => x.ParentId == id && !x.State.Equals("-1"));
+        if (childEntity.IsNotEmptyOrNull())
+        {
+            childEntity.State = "-1";
+            flowTaskOperatorEntities.Add(childEntity);
+            return await GetOperator(childEntity.Id, flowTaskOperatorEntities);
+        }
+        else
+        {
+            return flowTaskOperatorEntities;
+        }
+    }
+
+    /// <summary>
+    /// 递归获取加签人.
+    /// </summary>
+    /// <param name="id">经办id.</param>
+    /// <param name="flowTaskOperatorEntities">所有经办.</param>
+    /// <returns></returns>
+    public async Task<List<FlowTaskOperatorEntity>> GetOperatorNew(string id, List<FlowTaskOperatorEntity> flowTaskOperatorEntities)
+    {
+        var childEntity = await _flowTaskRepository.GetTaskOperatorInfo(x => x.HandleType == id && !x.State.Equals("-1"));
+        if (childEntity.IsNotEmptyOrNull())
+        {
+            childEntity.State = "-1";
+            flowTaskOperatorEntities.Add(childEntity);
+            return await GetOperatorNew(childEntity.Id, flowTaskOperatorEntities);
+        }
+        else
+        {
+            return flowTaskOperatorEntities;
+        }
+    }
+
+    /// <summary>
+    /// 获取自定义人员.
+    /// </summary>
+    /// <param name="approversProperties">节点属性.</param>
+    /// <param name="userType">0：审批人员，1：抄送人员.</param>
+    /// <returns></returns>
+    public async Task<List<string>> GetUserDefined(ApproversProperties approversProperties, int userType = 0)
+    {
+        var userIdList = new List<string>();
+        var objIdList = new List<string>();
+        if (userType == 0)
+        {
+            userIdList = approversProperties.approvers;
+            objIdList = approversProperties.approverRole
+            .Union(approversProperties.approverPos)
+            .Union(approversProperties.approverOrg)
+            .Union(approversProperties.approverGroup).ToList();
+        }
+        else
+        {
+            userIdList = approversProperties.circulateUser;
+            objIdList = approversProperties.circulateRole
+            .Union(approversProperties.circulatePosition)
+            .Union(approversProperties.circulateOrg)
+            .Union(approversProperties.circulateGroup).ToList();
+        }
+        userIdList = userIdList.Union(_userRelationService.GetUserId(objIdList, string.Empty)).ToList();
+        return userIdList;
+
+    }
+
+    /// <summary>
+    /// 获取定时器节点定时结束时间.
+    /// </summary>
+    /// <param name="approverPropertiers">定时器节点属性.</param>
+    /// <param name="nodeCode">定时器节点编码.</param>
+    /// <returns></returns>
+    public DateTime GetTimerDate(ApproversProperties approverPropertiers, string nodeCode)
+    {
+        var nowTime = DateTime.Now;
+        if (approverPropertiers.timerList.Count > 0)
+        {
+            string upNodeStr = string.Join(",", approverPropertiers.timerList.Select(x => x.upNodeCode).ToArray());
+            if (upNodeStr.Contains(nodeCode))
+            {
+                foreach (var item in approverPropertiers.timerList)
+                {
+                    var result = DateTime.Now.AddDays(item.day).AddHours(item.hour).AddMinutes(item.minute).AddSeconds(item.second);
+                    if (result > nowTime)
+                    {
+                        nowTime = result;
+                    }
+                }
+            }
+        }
+        return nowTime;
+    }
+}

workflow/Tnb.WorkFlow/Manager/FlowTemplateUtil.cs

@@ -0,0 +1,785 @@
+using System.Text;
+using JNPF.Common.Core.Manager;
+using JNPF.Common.Extension;
+using JNPF.Common.Models.WorkFlow;
+using JNPF.Common.Security;
+using JNPF.Extras.Thirdparty.JSEngine;
+using JNPF.FriendlyException;
+using JNPF.Systems.Interfaces.Permission;
+using JNPF.WorkFlow.Entitys.Entity;
+using JNPF.WorkFlow.Entitys.Enum;
+using JNPF.WorkFlow.Entitys.Model;
+using JNPF.WorkFlow.Entitys.Model.Item;
+using JNPF.WorkFlow.Entitys.Model.Properties;
+using JNPF.WorkFlow.Interfaces.Repository;
+using Mapster;
+using Newtonsoft.Json.Linq;
+
+namespace JNPF.WorkFlow.Manager;
+
+public class FlowTemplateUtil
+{
+    private readonly IDataBaseManager _dataBaseManager;
+    private readonly IUserManager _userManager;
+    private readonly IFlowTaskRepository _flowTaskRepository;
+    private readonly IUsersService _usersService;
+
+    /// <summary>
+    /// 可用节点.
+    /// </summary>
+    public List<FlowTaskNodeEntity> flowTaskNodeEntityList { get; set; } = new List<FlowTaskNodeEntity>();
+
+    /// <summary>
+    /// 所有节点.
+    /// </summary>
+    public List<TaskNodeModel> taskNodeList { get; set; } = new List<TaskNodeModel>();
+
+    /// <summary>
+    /// 开始节点.
+    /// </summary>
+    public FlowTaskNodeEntity startNode { get; set; } = new FlowTaskNodeEntity();
+
+    /// <summary>
+    /// 开始节点属性.
+    /// </summary>
+    public StartProperties startPro { get; set; } = new StartProperties();
+
+    public FlowTemplateUtil(IDataBaseManager dataBaseManager, IUserManager userManager, IFlowTaskRepository flowTaskRepository,
+        IUsersService usersService)
+    {
+        _dataBaseManager = dataBaseManager;
+        _userManager = userManager;
+        _flowTaskRepository = flowTaskRepository;
+        _usersService = usersService;
+    }
+
+    /// <summary>
+    /// 加载参数.
+    /// </summary>
+    /// <param name="flowEngineEntity"></param>
+    /// <param name="formData"></param>
+    /// <param name="taskId"></param>
+    public void Load(FlowJsonModel flowJsonModel, string formData, string taskId, bool isDeleteCondition = true)
+    {
+        this.flowTaskNodeEntityList.Clear();
+        this.taskNodeList.Clear();
+        var flowTemplateJsonModel = flowJsonModel.flowTemplateJson.ToObject<FlowTemplateJsonModel>();
+        #region 流程模板所有节点
+        var flowTemplateJsonModelList = new List<FlowTemplateJsonModel>();
+        var childNodeIdList = new List<string>();
+        GetChildNodeIdList(flowTemplateJsonModel, childNodeIdList);
+        GetFlowTemplateList(flowTemplateJsonModel, flowTemplateJsonModelList);
+        #endregion
+        GetFlowTemplateAll(flowTemplateJsonModel, this.taskNodeList, flowTemplateJsonModelList, childNodeIdList, taskId);
+        if (isDeleteCondition)
+        {
+            DeleteConditionTaskNodeModel(taskNodeList, formData, taskId);
+            var defaultFormId = this.taskNodeList.Find(m => FlowTaskNodeTypeEnum.start.ParseToString().Equals(m.type)).propertyJson.formId;
+            foreach (var item in this.taskNodeList)
+            {
+                var flowTaskNodeEntity = new FlowTaskNodeEntity();
+                flowTaskNodeEntity.Id = SnowflakeIdHelper.NextId();
+                flowTaskNodeEntity.CreatorTime = DateTime.Now;
+                flowTaskNodeEntity.TaskId = item.taskId;
+                flowTaskNodeEntity.NodeCode = item.nodeId;
+                flowTaskNodeEntity.NodeType = item.type;
+                flowTaskNodeEntity.Completion = FlowTaskNodeTypeEnum.start.ParseToString().Equals(item.type) ? 1 : 0;
+                flowTaskNodeEntity.NodeName = FlowTaskNodeTypeEnum.start.ParseToString().Equals(item.type) ? "开始" : item.propertyJson.title;
+                flowTaskNodeEntity.NodeUp = !FlowTaskNodeTypeEnum.approver.ParseToString().Equals(item.type) ? null : item.propertyJson.rejectStep;
+                flowTaskNodeEntity.NodeNext = item.nextNodeId;
+                flowTaskNodeEntity.NodePropertyJson = JsonHelper.ToJsonString(item.propertyJson);
+                flowTaskNodeEntity.State = "1";
+                if (FlowTaskNodeTypeEnum.subFlow.ParseToString().Equals(item.type))
+                {
+                    string subFlowId = item.propertyJson.flowId;//子流程流程id
+                    var jsonInfo = _flowTaskRepository.GetFlowTemplateJsonInfo(x => x.Id == subFlowId && x.DeleteMark == null);
+                    flowTaskNodeEntity.FormId = jsonInfo.FlowTemplateJson.ToObject<FlowTemplateJsonModel>().properties.ToObject<StartProperties>().formId;
+                }
+                else
+                {
+                    string formId = item.propertyJson.formId;
+                    flowTaskNodeEntity.FormId = formId.IsNotEmptyOrNull() ? formId : defaultFormId;
+                }
+                flowTaskNodeEntityList.Add(flowTaskNodeEntity);
+            }
+            DeleteTimerTaskNode(this.flowTaskNodeEntityList);
+            this.startNode = this.flowTaskNodeEntityList.Find(m => FlowTaskNodeTypeEnum.start.ParseToString().Equals(m.NodeType));
+            this.startPro = this.startNode.NodePropertyJson.ToObject<StartProperties>();
+        }
+    }
+
+    /// <summary>
+    /// 递归获取流程模板最外层childNode中所有nodeid.
+    /// </summary>
+    /// <param name="template">流程模板实例.</param>
+    /// <param name="childNodeIdList">子节点id.</param>
+    private void GetChildNodeIdList(FlowTemplateJsonModel template, List<string> childNodeIdList)
+    {
+        if (template.IsNotEmptyOrNull() && template.childNode.IsNotEmptyOrNull())
+        {
+            childNodeIdList.Add(template.childNode.nodeId);
+            GetChildNodeIdList(template.childNode, childNodeIdList);
+        }
+    }
+
+    /// <summary>
+    /// 递归获取流程模板数组.
+    /// </summary>
+    /// <param name="template">流程模板.</param>
+    /// <param name="templateList">流程模板数组.</param>
+    private void GetFlowTemplateList(FlowTemplateJsonModel template, List<FlowTemplateJsonModel> templateList)
+    {
+        if (template.IsNotEmptyOrNull())
+        {
+            var haschildNode = template.childNode.IsNotEmptyOrNull();
+            var hasconditionNodes = template.conditionNodes.IsNotEmptyOrNull() && template.conditionNodes.Count > 0;
+
+            templateList.Add(template);
+
+            if (hasconditionNodes)
+            {
+                foreach (var conditionNode in template.conditionNodes)
+                {
+                    GetFlowTemplateList(conditionNode, templateList);
+                }
+            }
+
+            if (haschildNode)
+            {
+                GetFlowTemplateList(template.childNode, templateList);
+            }
+        }
+    }
+
+    /// <summary>
+    /// 递归审批模板获取所有节点.
+    /// </summary>
+    /// <param name="template">当前审批流程json.</param>
+    /// <param name="nodeList">流程节点数组.</param>
+    /// <param name="templateList">流程模板数组.</param>
+    private void GetFlowTemplateAll(FlowTemplateJsonModel template, List<TaskNodeModel> nodeList, List<FlowTemplateJsonModel> templateList, List<string> childNodeIdList, string taskId = "")
+    {
+        try
+        {
+            if (template.IsNotEmptyOrNull())
+            {
+                var taskNodeModel = template.Adapt<TaskNodeModel>();
+                taskNodeModel.taskId = taskId;
+                taskNodeModel.propertyJson = GetPropertyByType(template.type, template.properties);
+                if (taskNodeModel.isBranchFlow)
+                {
+                    taskNodeModel.propertyJson.isBranchFlow = taskNodeModel.isBranchFlow;
+                }
+                var haschildNode = template.childNode.IsNotEmptyOrNull();
+                var hasconditionNodes = template.conditionNodes.IsNotEmptyOrNull() && template.conditionNodes.Count > 0;
+                List<string> nextNodeIdList = new List<string> { string.Empty };
+                if (templateList.Count > 1)
+                {
+                    nextNodeIdList = GetNextNodeIdList(templateList, template, childNodeIdList);
+                }
+                taskNodeModel.nextNodeId = string.Join(',', nextNodeIdList.ToArray());
+                nodeList.Add(taskNodeModel);
+
+                if (hasconditionNodes)
+                {
+                    foreach (var conditionNode in template.conditionNodes)
+                    {
+                        GetFlowTemplateAll(conditionNode, nodeList, templateList, childNodeIdList, taskId);
+                    }
+                }
+
+                if (haschildNode)
+                {
+                    taskNodeModel.childNodeId = template.childNode.nodeId;
+                    GetFlowTemplateAll(template.childNode, nodeList, templateList, childNodeIdList, taskId);
+                }
+            }
+        }
+        catch (AppFriendlyException ex)
+        {
+            throw Oops.Oh(ex.ErrorCode);
+        }
+    }
+
+    /// <summary>
+    /// 根据类型获取不同属性对象.
+    /// </summary>
+    /// <param name="type">属性类型.</param>
+    /// <param name="jd">数据.</param>
+    /// <returns></returns>
+    private dynamic GetPropertyByType(string type, JObject jd)
+    {
+        switch (type)
+        {
+            case "approver":
+                return jd.ToObject<ApproversProperties>();
+            case "timer":
+                return jd.ToObject<TimerProperties>();
+            case "start":
+                return jd.ToObject<StartProperties>();
+            case "condition":
+                return jd.ToObject<ConditionProperties>();
+            case "subFlow":
+                return jd.ToObject<ChildTaskProperties>();
+            default:
+                return jd;
+        }
+    }
+
+    /// <summary>
+    /// 获取当前模板的下一节点
+    /// 下一节点数据来源：conditionNodes和childnode (conditionNodes优先级大于childnode)
+    /// conditionNodes非空：下一节点则为conditionNodes数组中所有nodeID
+    /// conditionNodes非空childNode非空：下一节点则为childNode的nodeId
+    /// conditionNodes空childNode空则为最终节点(两种情况：当前模板属于conditionNodes的最终节点或childNode的最终节点)
+    /// conditionNodes的最终节点:下一节点为与conditionNodes同级的childNode的nodeid,没有则继续递归，直到最外层的childNode
+    /// childNode的最终节点直接为"".
+    /// </summary>
+    /// <param name="templateList">模板数组</param>
+    /// <param name="template">当前模板</param>
+    /// <param name="childNodeIdList">最外层childnode的nodeid集合</param>
+    /// <returns></returns>
+    private List<string> GetNextNodeIdList(List<FlowTemplateJsonModel> templateList, FlowTemplateJsonModel template, List<string> childNodeIdList)
+    {
+        List<string> nextNodeIdList = new List<string>();
+        if (template.conditionNodes.IsNotEmptyOrNull() && template.conditionNodes.Count > 0)
+        {
+            nextNodeIdList = template.conditionNodes.Select(x => x.nodeId).ToList();
+        }
+        else
+        {
+            if (template.childNode.IsNotEmptyOrNull())
+            {
+                nextNodeIdList.Add(template.childNode.nodeId);
+            }
+            else
+            {
+                //判断是否是最外层的节点
+                if (childNodeIdList.Contains(template.nodeId))
+                {
+                    nextNodeIdList.Add(string.Empty);
+                }
+                else
+                {
+                    //conditionNodes中最终节点
+                    nextNodeIdList.Add(GetChildId(templateList, template, childNodeIdList));
+                }
+            }
+        }
+        return nextNodeIdList;
+    }
+
+    /// <summary>
+    /// 递归获取conditionNodes最终节点下一节点.
+    /// </summary>
+    /// <param name="templateList">流程模板数组.</param>
+    /// <param name="template">当前模板.</param>
+    /// <param name="childNodeIdList">最外层childNode的节点数据.</param>
+    /// <returns></returns>
+    private string GetChildId(List<FlowTemplateJsonModel> templateList, FlowTemplateJsonModel template, List<string> childNodeIdList)
+    {
+        var prevModel = new FlowTemplateJsonModel();
+        if (template.prevId.IsNotEmptyOrNull())
+        {
+            prevModel = templateList.Find(x => x.nodeId.Equals(template.prevId));
+            if (prevModel.childNode.IsNotEmptyOrNull() && prevModel.childNode.nodeId != template.nodeId)
+            {
+                return prevModel.childNode.nodeId;
+            }
+            if (childNodeIdList.Contains(prevModel.nodeId))
+            {
+                return prevModel.childNode.IsNullOrEmpty() ? string.Empty : prevModel.childNode.nodeId;
+            }
+            else
+            {
+                return GetChildId(templateList, prevModel, childNodeIdList);
+            }
+        }
+        else
+        {
+            return string.Empty;
+        }
+    }
+
+    /// <summary>
+    /// 删除条件节点
+    /// 将条件的上非条件的节点的nextnode替换成当前条件的nextnode.
+    /// </summary>
+    /// <param name="taskNodeModelList">所有节点数据.</param>
+    /// <param name="formDataJson">填写表单数据.</param>
+    /// <param name="taskId">任务id.</param>
+    /// <returns></returns>
+    private void DeleteConditionTaskNodeModel(List<TaskNodeModel> taskNodeModelList, string formDataJson, string taskId)
+    {
+        var conditionTaskNodeModelList = taskNodeModelList.FindAll(x => FlowTaskNodeTypeEnum.condition.ParseToString().Equals(x.type));
+        var dic = new Dictionary<string, List<TaskNodeModel>>();
+        foreach (var item in conditionTaskNodeModelList.GroupBy(x => x.upNodeId))
+        {
+            dic.Add(item.Key, taskNodeModelList.FindAll(x => x.upNodeId == item.Key && FlowTaskNodeTypeEnum.condition.ParseToString().Equals(x.type)));
+        }
+        //条件的默认情况判断（同层条件的父节点是一样的，只要非默认的匹配成功则不需要走默认的）
+        var isDefault = new List<string>();
+        foreach (var nodeId in dic.Keys)
+        {
+            var index = 0;
+            foreach (var item in dic[nodeId])
+            {
+                ++index;
+                //条件节点的父节点且为非条件的节点
+                var upTaskNodeModel = taskNodeModelList.Find(x => x.nodeId == nodeId);
+                if (FlowTaskNodeTypeEnum.condition.ParseToString().Equals(upTaskNodeModel.type))
+                {
+                    // 父级条件不满足则子级条件则不需要验证
+                    if (!upTaskNodeModel.propertyJson.isDefault && !ConditionNodeJudge(formDataJson, upTaskNodeModel.propertyJson, taskId))
+                    {
+                        break;
+                    }
+                    upTaskNodeModel = GetUpTaskNodeModelIsNotCondition(taskNodeModelList, upTaskNodeModel);
+                    // 如果父节点下一节点存在某个审批节点则不需要判断了
+                    if (taskNodeModelList.Where(x => upTaskNodeModel.nextNodeId.Contains(x.nodeId)).Any(y => FlowTaskNodeTypeEnum.approver.ParseToString().Equals(y.type)))
+                    {
+                        break;
+                    }
+                }
+                if (!item.propertyJson.isDefault && ConditionNodeJudge(formDataJson, item.propertyJson, taskId))
+                {
+                    upTaskNodeModel.nextNodeId = item.nextNodeId;
+                    isDefault.Add(item.upNodeId);
+                    break;
+                }
+                else
+                {
+                    if (!isDefault.Contains(item.upNodeId) && item.propertyJson.isDefault)
+                    {
+                        upTaskNodeModel.nextNodeId = item.nextNodeId;
+                    }
+                    else
+                    {
+                        if (index == dic[nodeId].Count)
+                        {
+                            upTaskNodeModel.nextNodeId = upTaskNodeModel.childNodeId.IsNotEmptyOrNull() ? upTaskNodeModel.childNodeId : FlowTaskNodeTypeEnum.end.ParseToString();
+                        }
+                    }
+                }
+            }
+        }
+
+        if (formDataJson.IsNotEmptyOrNull())
+        {
+            taskNodeModelList.RemoveAll(x => FlowTaskNodeTypeEnum.condition.ParseToString().Equals(x.type));
+        }
+    }
+
+    /// <summary>
+    /// 向上递获取非条件的节点.
+    /// </summary>
+    /// <param name="taskNodeModelList">所有节点数据.</param>
+    /// <param name="taskNodeModel">当前节点.</param>
+    /// <returns></returns>
+    private TaskNodeModel GetUpTaskNodeModelIsNotCondition(List<TaskNodeModel> taskNodeModelList, TaskNodeModel taskNodeModel)
+    {
+        var preTaskNodeModel = taskNodeModelList.Find(x => x.nodeId == taskNodeModel.upNodeId);
+        if (FlowTaskNodeTypeEnum.condition.ParseToString().Equals(preTaskNodeModel.type))
+        {
+            return GetUpTaskNodeModelIsNotCondition(taskNodeModelList, preTaskNodeModel);
+        }
+        else
+        {
+            return preTaskNodeModel;
+        }
+    }
+
+    /// <summary>
+    /// 条件判断.
+    /// </summary>
+    /// <param name="formDataJson">表单填写数据.</param>
+    /// <param name="conditionPropertie">条件属性.</param>
+    /// <param name="taskId">任务id.</param>
+    /// <returns></returns>
+    private bool ConditionNodeJudge(string formDataJson, ConditionProperties conditionPropertie, string taskId)
+    {
+        try
+        {
+            bool flag = false;
+            StringBuilder expression = new StringBuilder();
+            expression.AppendFormat("select * from base_user where  ");
+            var formData = formDataJson.ToObject<JObject>();
+            int i = 0;
+            foreach (ConditionsItem flowNodeWhereModel in conditionPropertie.conditions)
+            {
+                var logic = flowNodeWhereModel.logic;
+                var symbol = flowNodeWhereModel.symbol.Equals("==") ? "=" : flowNodeWhereModel.symbol;
+                // 条件值
+                var formValue = GetConditionValue(flowNodeWhereModel.fieldType.ParseToInt(), formData, flowNodeWhereModel.field, taskId, flowNodeWhereModel.jnpfKey);
+                // 匹配值
+                var value = " ";
+                if (flowNodeWhereModel.fieldValueType.ParseToInt() == 2)
+                {
+                    //数组类型控件
+                    var jnpfKeyList = new List<string>() { "cascader", "comSelect", "address", "currOrganize" };
+                    if (jnpfKeyList.Contains(flowNodeWhereModel.jnpfKey) && flowNodeWhereModel.fieldValue.Count > 0)
+                    {
+                        if (flowNodeWhereModel.jnpfKey.Equals("currOrganize"))
+                        {
+                            value = flowNodeWhereModel.fieldValue[flowNodeWhereModel.fieldValue.Count - 1];
+                        }
+                        else
+                        {
+                            value = string.Join(",", flowNodeWhereModel.fieldValue);
+                        }
+                    }
+                    else
+                    {
+                        value = flowNodeWhereModel.fieldValue.ToString();
+                    }
+
+                    if ("currentUser".Equals(value))
+                    {
+                        value = _userManager.UserId;
+                    }
+
+                    if ("time".Equals(flowNodeWhereModel.jnpfKey))
+                    {
+                        formValue = formValue.Replace(":", string.Empty);
+                        value = value.Replace(":", string.Empty);
+                    }
+                }
+                else
+                {
+                    value = GetConditionValue(flowNodeWhereModel.fieldValueType.ParseToInt(), formData, flowNodeWhereModel.fieldValue, taskId, flowNodeWhereModel.jnpfKey);
+                }
+
+                if (symbol.Equals("=") || symbol.Equals("<>"))
+                {
+                    expression.AppendFormat("('{0}'{1}'{2}')", formValue, symbol, value);
+                }
+                else if (symbol.Equals("like"))
+                {
+                    expression.AppendFormat("('{0}' {1} '%{2}%')", formValue, symbol, value);
+                }
+                else if (symbol.Equals("notLike"))
+                {
+                    expression.AppendFormat("('{0}' {1} '%{2}%')", formValue, "not like", value);
+                }
+                else
+                {
+                    if (string.IsNullOrWhiteSpace(formValue) || string.IsNullOrWhiteSpace(value))
+                    {
+                        expression.Append("(1=2)");
+                    }
+                    else
+                    {
+                        expression.AppendFormat("({0}{1}{2})", formValue, symbol, value);
+                    }
+                }
+
+                if (logic.IsNotEmptyOrNull() && i != conditionPropertie.conditions.Count - 1)
+                {
+                    expression.Append(" " + logic.Replace("&&", " and ").Replace("||", " or ") + " ");
+                }
+
+                i++;
+            }
+            var link = _dataBaseManager.GetTenantDbLink(_userManager.TenantId, _userManager.TenantDbName);
+            flag = _dataBaseManager.WhereDynamicFilter(link, expression.ToString());
+            return flag;
+        }
+        catch (Exception e)
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// 获取条件匹配值.
+    /// </summary>
+    /// <param name="type">条件类型 1、字段 2、自定义 3、聚合函数.</param>
+    /// <param name="formData">表单数据.</param>
+    /// <param name="field">关联字段.</param>
+    /// <param name="taskId">任务id.</param>
+    /// <param name="jnpfKey">控件key.</param>
+    /// <returns></returns>
+    private string GetConditionValue(int type, JObject formData, string field, string taskId, string jnpfKey)
+    {
+        var conditionValue = " ";
+        if (type == 1)
+        {
+            if (formData.ContainsKey(field))
+            {
+                if (formData[field] is JArray)
+                {
+                    try
+                    {
+                        var jar = formData[field].ToObject<List<string>>();
+                        if (jar.Count > 0)
+                        {
+                            conditionValue = string.Join(",", jar);
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        var arr = formData[field].ToObject<List<List<string>>>();
+                        conditionValue = string.Join(",", arr.Select(x => string.Join(",", x)).ToList());
+                    }
+                }
+                else
+                {
+                    if (formData[field].IsNotEmptyOrNull())
+                    {
+                        conditionValue = formData[field].ToString();
+                        SysWidgetFormValue(taskId, jnpfKey, ref conditionValue);
+                    }
+                }
+            }
+        }
+        else
+        {
+            // 获取聚合函数要替换的参数key
+            foreach (var item in field.Substring3())
+            {
+                if (formData.ContainsKey(item))
+                {
+                    field = field.Replace("{" + item + "}", "'" + formData[item] + "'");
+                }
+                else if (item.Contains("tableField") && item.Contains("-"))
+                {
+                    var fields = item.Split("-").ToList();
+                    var tableField = fields[0];
+                    var keyField = fields[1];
+                    if (formData.ContainsKey(tableField) && formData[tableField] is JArray)
+                    {
+                        var jar = formData[tableField] as JArray;
+
+                        var tableValue = jar.Where(x => x.ToObject<JObject>().ContainsKey(keyField)).Select(x => x.ToObject<JObject>()[keyField]).ToObject<List<string>>();
+                        var valueStr = string.Join("','", tableValue);
+                        field = field.Replace("{" + item + "}", "'" + valueStr + "'");
+                    }
+                }
+                else
+                {
+                    field = field.Replace("{" + item + "}", "''");
+                }
+            }
+            // 执行函数获取值
+            conditionValue = JsEngineUtil.AggreFunction(field).ToString();
+        }
+
+        return conditionValue;
+    }
+
+    /// <summary>
+    /// 系统控件条件匹配数据转换.
+    /// </summary>
+    /// <param name="taskId">任务id</param>
+    /// <param name="jnpfKey">条件匹配字段类型</param>
+    /// <param name="formValue">条件匹配值</param>
+    private void SysWidgetFormValue(string taskId, string jnpfKey, ref string formValue)
+    {
+        var taskEntity = _flowTaskRepository.GetTaskFirstOrDefault(taskId);
+        if (taskEntity.IsNotEmptyOrNull())
+        {
+            var creatorUser = _usersService.GetInfoByUserId(taskEntity.CreatorUserId);
+            switch (jnpfKey)
+            {
+                case "createUser":
+                    formValue = taskEntity.CreatorUserId;
+                    break;
+                case "modifyUser":
+                    if (taskEntity.LastModifyUserId.IsNotEmptyOrNull())
+                    {
+                        formValue = _userManager.UserId;
+                    }
+
+                    break;
+                case "currOrganize":
+                    if (creatorUser.OrganizeId.IsNotEmptyOrNull())
+                    {
+                        formValue = creatorUser.OrganizeId;
+                    }
+
+                    break;
+                case "createTime":
+                    formValue = ((DateTime)taskEntity.CreatorTime).ParseToUnixTime().ToString();
+                    break;
+                case "modifyTime":
+                    if (taskEntity.LastModifyTime.IsNotEmptyOrNull())
+                    {
+                        formValue = DateTime.Now.ParseToUnixTime().ToString();
+                    }
+
+                    break;
+                case "currPosition":
+                    if (creatorUser.PositionId.IsNotEmptyOrNull())
+                    {
+                        formValue = creatorUser.PositionId;
+                    }
+
+                    break;
+            }
+        }
+        else
+        {
+            switch (jnpfKey)
+            {
+                case "createUser":
+                    formValue = _userManager.UserId;
+                    break;
+                case "modifyUser":
+                    formValue = " ";
+                    break;
+                case "currOrganize":
+                    if (_userManager.User.OrganizeId.IsNotEmptyOrNull())
+                    {
+                        formValue = _userManager.User.OrganizeId;
+                    }
+
+                    break;
+                case "createTime":
+                    formValue = DateTime.Now.ParseToUnixTime().ToString();
+                    break;
+                case "modifyTime":
+                    formValue = "0";
+                    break;
+                case "currPosition":
+                    if (_userManager.User.PositionId.IsNotEmptyOrNull())
+                    {
+                        formValue = _userManager.User.PositionId;
+                    }
+
+                    break;
+            }
+        }
+    }
+
+    /// <summary>
+    /// 删除定时器.
+    /// </summary>
+    /// <param name="flowTaskNodeEntityList">所有节点</param>
+    private void DeleteTimerTaskNode(List<FlowTaskNodeEntity> flowTaskNodeEntityList)
+    {
+        foreach (var item in flowTaskNodeEntityList)
+        {
+            if ("timer".Equals(item.NodeType))
+            {
+                // 下一节点为Timer类型节点的节点集合
+                var taskNodeList = flowTaskNodeEntityList.FindAll(x => x.NodeNext.Contains(item.NodeCode));
+
+                // Timer类型节点的下节点集合
+                var nextTaskNodeList = flowTaskNodeEntityList.FindAll(x => item.NodeNext.Contains(x.NodeCode));
+
+                // 保存定时器节点的上节点编码到属性中
+                var timerProperties = item.NodePropertyJson.ToObject<TimerProperties>();
+                timerProperties.upNodeCode = string.Join(",", taskNodeList.Select(x => x.NodeCode).ToArray());
+                item.NodePropertyJson = timerProperties.ToJsonString();
+
+                // 上节点替换NodeNext
+                foreach (var taskNode in taskNodeList)
+                {
+                    var flowTaskNodeEntity = flowTaskNodeEntityList.Where(x => x.NodeCode == taskNode.NodeCode).FirstOrDefault();
+                    flowTaskNodeEntity.NodeNext = item.NodeNext;
+                }
+
+                // 下节点添加定时器属性
+                nextTaskNodeList.ForEach(nextNode =>
+                {
+                    var flowTaskNodeEntity = flowTaskNodeEntityList.Where(x => x.NodeCode == nextNode.NodeCode).FirstOrDefault();
+                    if (FlowTaskNodeTypeEnum.approver.ParseToString().Equals(flowTaskNodeEntity.NodeType))
+                    {
+                        var properties = flowTaskNodeEntity.NodePropertyJson.ToObject<ApproversProperties>();
+                        properties.timerList.Add(item.NodePropertyJson.ToObject<TimerProperties>());
+                        flowTaskNodeEntity.NodePropertyJson = JsonHelper.ToJsonString(properties);
+                    }
+                });
+            }
+        }
+
+        flowTaskNodeEntityList.RemoveAll(x => FlowTaskNodeTypeEnum.timer.ParseToString().Equals(x.NodeType));
+        UpdateNodeSort(flowTaskNodeEntityList);
+    }
+
+    /// <summary>
+    /// 处理并保存节点.
+    /// </summary>
+    /// <param name="entitys">节点list.</param>
+    private 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>
+    private 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);
+                    }
+                }
+            }
+        }
+    }
+}