omega_logic/Util/LogicHelper.cs

using Infrastructure;
using LitJson;
using Model.Custom;
using Services;

namespace Util
{
    public class LogicHelper
    {
        /// <summary>
        /// 获取逻辑项目的Json数据
        /// </summary>
        /// <param name="projectId">项目ID</param>
        /// <param name="request">请求参数</param>
        public static void GetLogicJsonData(int projectId, string request)
        {
            var logicProjectService = App.GetService<ILogicProjectService>();
            var logicProject = logicProjectService.GetById(projectId);
            if(logicProject == null)
            {
                return;
            }
            string jsonData = logicProject.setData;
            if(string.IsNullOrEmpty(jsonData))
            {
                return;
            }
            JsonData requestObj = JsonMapper.ToObject(request);
            JsonData jsonDataObj = JsonMapper.ToObject(jsonData);
            JsonData nodes = jsonDataObj["nodes"]; // 节点数据
            List<NodeList> nodeList = new List<NodeList>(); // 节点列表
            foreach(JsonData node in nodes)
            {
                JsonData id = node["id"];
                JsonData type = node["type"];
                NodeList nodeListObj = new NodeList();
                nodeListObj.nodeId = id.ToString();
                nodeListObj.nodeType = type.ToString();
                nodeListObj.nodeData = node;
                nodeList.Add(nodeListObj);
            }
            List<EdgeList> edgeList = new List<EdgeList>(); // 边列表
            JsonData edges = jsonDataObj["edges"]; // 边数据
            foreach(JsonData edge in edges)
            {
                JsonData source = edge["source"];
                JsonData target = edge["target"];
                EdgeList edgeListObj = new EdgeList();
                edgeListObj.source = source.ToString();
                edgeListObj.target = target.ToString();
                edgeListObj.edgeData = edge;
                edgeList.Add(edgeListObj);
            }

            string startNodeId = "start"; // 起始节点ID
            // 获取起始节点数据
            List<ParamList> paramList = new List<ParamList>();
            NodeList startNode = nodeList.FirstOrDefault(x => x.nodeId == startNodeId) ?? new NodeList();
            JsonData nodeData = startNode.nodeData;
            JsonData input = nodeData["data"]["formData"]["input"]["value"];
            for(int i = 0; i < input.Count; i++)
            {
                JsonData item = input[i];
                string paramName = item["label"].ToString();
                string paramType = item["type"][0].ToString();
                string paramValue = item["value"].ToString();
                ParamList paramListObj = new ParamList();
                paramListObj.nodeId = startNodeId;
                paramListObj.paramName = paramName;
                paramListObj.paramType = paramType;
                paramListObj.paramValue = paramValue;
                paramList.Add(paramListObj);
            }

            // 从起始节点开始
            sortEdge(edgeList, nodeList, paramList, startNodeId);
        }

        /// <summary>
        /// 运行逻辑项目的Json数据
        /// </summary>
        /// <param name="edgeList">边列表</param>
        /// <param name="startNodeId">起始节点ID</param>
        public static void sortEdge(List<EdgeList> edgeList, List<NodeList> nodeList, List<ParamList> paramList, string startNodeId)
        {
            foreach(EdgeList item in edgeList)
            {
                if(item.source == startNodeId)
                {
                    NodeList node = nodeList.FirstOrDefault(x => x.nodeId == item.target) ?? new NodeList();
                    switch(node.nodeType)
                    {
                        case "ifelse": // 如果-否则节点
                            var ifElseResult = LogicNodeHelper.ifElse(node, paramList);
                            if(ifElseResult.Count > 0)
                            {
                                foreach(bool result in ifElseResult)
                                {
                                    if(result)
                                    {
                                        sortEdge(edgeList, nodeList, paramList, item.target);
                                        break;
                                    }
                                }
                            }
                            break;                            
                        case "iteration": // 迭代节点
                            break;
                        case "loop": // 循环节点
                            break;
                        case "code-execute": // 代码执行节点
                            break;
                        case "sql-execute": // SQL执行节点
                            break;
                        case "insert-data": // 插入数据节点
                            break;
                        case "update-data": // 更新数据节点
                            break;
                        case "query-data": // 查询数据节点
                            break;
                        case "delete-data": // 删除数据节点
                            break;
                        case "http-request": // HTTP请求节点
                            break;
                        default:
                            break;
                    }
                }
            }
        }
    }
}