A codeless configurable task flow development system and method

Abstract

The present application relates to the technical field of data processing, and more particularly to a code-free configurable task flow development system and method, comprising a task data acquisition module, a flow visual arrangement module, an event binding engine module, a condition rule analysis module, a task state management module and a resource dynamic loading module. The flow visual arrangement module generates task nodes and dependency relationship data based on a graphical interface; the condition rule analysis module converts natural language conditions into dynamically callable verification logic; the task state management module drives state migration according to the dependency relationship data and atomically updates the task state after calling the verification logic; and the resource dynamic loading module responds to resource loading instructions to schedule external resources. Through a modular decoupling mechanism, business personnel can configure task logic using a graphical interface without writing program code, thereby solving the technical problems of strong programming dependency and high coupling degree of task logic and code.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of data processing, and in particular to a no-code configurable task flow program development system and method. BACKGROUND

[0002] The no-code configurable task flow is a business process management method based on a graphical user interface. Users build and modify workflow models through visual components by dragging and dropping, without the need to write code. This method abstracts the complexity of underlying technology and can automatically execute serialized tasks and process decision logic based on business rule definitions, thereby reducing technical barriers while improving automation efficiency, enabling non-developers to quickly deploy and maintain complex processes, and being suitable for accelerating enterprise digital transformation and operational optimization.

[0003] The existing task system development has the problems of strong programming dependency and high coupling degree of task logic and code. The root cause lies in that the task business logic is directly hard-coded in the software program source code. For example, in the field of game development, programmers must solidify the state conversion rules, event response logic, and inter-task dependency relationships of specific tasks in the form of conditional branching statements and state judgment codes in the program logic layer. When a planner needs to adjust the number of task objectives or modify the completion conditions, the developer must locate and modify the corresponding program code implementation layer logic, recompile and deploy the entire module, resulting in strong coupling between business requirement changes and underlying code implementation. SUMMARY

[0004] To address the deficiencies in the prior art, the present application provides a no-code configurable task flow program development system and method, which solves the problems of strong programming dependency and high coupling degree of task logic and code in task system development.

[0005] To solve the above technical problems, the specific technical solutions of the present application are as follows:

[0006] In a first aspect, the present application provides a no-code configurable task flow program development system and method, which includes:

[0007] A task data acquisition module acquires user input task metadata, encapsulates it as an independent task data object, and outputs the task data object to a flow visualization arrangement module;

[0008] A flow visualization arrangement module receives the task data object, generates task nodes and directed connections through a graphical interface, generates dependency relationship data describing the task execution order, and outputs the dependency relationship data to a task state management module;

[0009] An event binding engine module predefines a set of event types, associates and registers external event triggers with task nodes, and sends state change requests to the task state management module;

[0010] A conditional rule analysis module receives a user-defined conditional expression and converts it into dynamically callable verification logic;

[0011] A task state management module receives dependency relationship data and state change requests, drives state migration according to the dependency relationship data, calls the verification logic of the conditional rule analysis module to perform conditional verification, atomically updates the task state according to the verification result, and sends a resource loading instruction to the resource dynamic loading module;

[0012] A resource dynamic loading module receives a resource loading instruction and loads external resources associated with a task data object.

[0013] Further, the code-free configurable task flow development system of the present application comprises:

[0014] A dynamic form unit parses metadata structures to generate graphical input controls, collects user input task metadata, and outputs the collected data to a data packaging unit;

[0015] A data packaging unit receives collected data, serializes user input properties into a task data object containing a task identifier, a resource index, and an initial state value, and passes the task data object to a flow visualization arrangement module.

[0016] Further, the code-free configurable task flow development system of the present application comprises:

[0017] A directed graph modeling unit receives a task data object, maps the task data object to a node entity, converts a connection line to a state migration path, and outputs a node mapping relationship to a dependency analysis unit;

[0018] A dependency analysis unit receives a node mapping relationship, generates an adjacency matrix describing the task trigger sequence, and calls a conflict processing unit when a circular dependency path is detected;

[0019] A conflict processing unit reconstructs the circular dependency path through a topological sorting algorithm and outputs the reconstructed adjacency matrix to the dependency analysis unit;

[0020] The dependency analysis unit outputs the adjacency matrix to the task state management module.

[0021] Further, the code-free configurable task flow development system of the present application comprises:

[0022] A registration storage unit receives node association data from the flow visualization arrangement module, maintains a mapping table of event types and task identifiers, and outputs the mapping table to a proxy generation unit;

[0023] The agent generation unit receives the mapping table, creates an event response method for each task, and generates event agent data;

[0024] The message distribution unit receives the event agent data and the external event, routes the external event to the bound task through a message queue, and sends a state change request including a target task identifier to the task state management module.

[0025] Further, the code-free configurable task flow development system of the present application, the condition rule analysis module comprises:

[0026] The syntax conversion unit receives the user-defined condition expression, compiles the natural language condition into an abstract syntax tree, and outputs the abstract syntax tree to the context binding unit;

[0027] The context binding unit receives the abstract syntax tree, injects runtime environment data, and generates an executable rule object;

[0028] The logic execution unit receives the executable rule object, generates a verification function that returns a Boolean value, and returns the verification result to the task state management module.

[0029] Further, the code-free configurable task flow development system of the present application, the task state management module comprises:

[0030] The state machine engine unit receives the dependency relationship data and the state change request, invokes the verification logic of the condition rule analysis module to perform condition verification, executes the state transition rule according to the verification result according to the adjacency matrix, and triggers the task state update event;

[0031] The persistence unit listens to the task state update event and synchronizes the task state to the distributed storage;

[0032] The event-driven unit triggers the subsequent task chain when the state machine engine unit verification passes, and sends the resource identifier to the resource dynamic loading module.

[0033] Further, the code-free configurable task flow development system of the present application, the resource dynamic loading module comprises:

[0034] The state listening unit receives the resource loading instruction, subscribes to the task state change event, and sends the resource index to the asynchronous loading unit when the task enters the execution state;

[0035] The asynchronous loading unit receives the resource index, schedules external files according to the resource index, directly calls if there is a matching cache resource in the resource pool unit, otherwise loads a new resource;

[0036] The resource pool unit caches resources using the least recently used strategy, and provides cache data to the asynchronous loading unit;

[0037] The asynchronous loading unit outputs a resource ready event to the rendering interface after the resource is ready.

[0038] Further, the code-free configurable task flow program development system of the present application further comprises:

[0039] The message distribution unit carries a target state value in a state change request sent to the task state management module;

[0040] The state machine engine unit receives the state change request, updates the current task state according to the target state value in the request after passing the verification logic, and triggers the subsequent task node defined in the adjacency matrix.

[0041] Further, the code-free configurable task flow program development system of the present application further comprises:

[0042] The event-driven unit sends an instruction including a resource identifier to the resource dynamic loading module when the task state migrates to the execution state;

[0043] The asynchronous loading unit triggers an update operation of the visual arrangement interface through the rendering interface after completing the resource loading, and feeds back the task execution result to the user operation interface in real time.

[0044] In a second aspect, the present application provides a code-free configurable task flow program development method applied to the code-free configurable task flow program development system, comprising:

[0045] Step 1: obtaining the task metadata input by the user, encapsulating into an independent task data object, and outputting the task data object to step 2;

[0046] Step 2: receiving the task data object, generating task nodes and directed connections through a graphical interface, generating dependency relationship data describing the task execution order, and outputting the dependency relationship data to step 5;

[0047] Step 3: predefining a set of event types, associating and registering external event triggers with task nodes, and sending a state change request to step 5;

[0048] Step 4: receiving a condition expression defined by the user, and converting it into a dynamically callable verification logic;

[0049] Step 5: receiving the dependency relationship data and the state change request, driving state migration according to the dependency relationship data, calling the verification logic of step 4 to perform condition verification, atomically updating the task state according to the verification result, and sending a resource loading instruction to step 6;

[0050] Step 6: receiving the resource loading instruction, and loading the external resource associated with the task data object.

[0051] The application has the beneficial effects that

[0052] The application has the beneficial effects that the programming dependency is eliminated through the codeless graphical configuration mechanism, and the hard-coded association between task logic and program code is cut off by adopting the modular decoupling design. The task data acquisition module generates graphical input controls through dynamic form, non-developers can configure task metadata and encapsulate them as independent data objects; the process visual arrangement module converts the directed graph model into the adjacency matrix to describe the task dependency relationship, and eliminates the need for manual coding of process control statements. The event binding engine module establishes the mapping relationship between event types and task identifiers, and the conditional rule analysis module compiles natural language expressions into executable verification logic, realizing the physical separation of business rules and execution engine. The task state management module drives state migration according to the adjacency matrix, atomically updates the task state after calling the verification logic, and the resource dynamic loading module responds to state changes and schedules resources on demand, forming a closed-loop data flow from user configuration to execution feedback. Each module interacts through standardized interfaces, and business personnel only need to modify configuration data to adjust task parameters, without the need to recompile the program source code layer, thereby essentially solving the technical problems of strong programming dependency and high code coupling degree. BRIEF DESCRIPTION OF DRAWINGS

[0053] In order to more clearly illustrate the technical solutions of the present application, the following will briefly introduce the drawings needed to be used in the embodiments. Obviously, for those skilled in the art, other drawings can also be obtained from the drawings without creative labor.

[0054] Figure 1 The flowchart of the codeless configurable task flow program development method provided by the embodiments of the present application. DETAILED DESCRIPTION

[0055] In order to make the purpose, technical scheme and advantages of the present application clearer, the technical scheme of the present application will be described clearly and completely in combination with the specific embodiments of the present application and corresponding drawings. Obviously, the described embodiments are only part of the embodiments of the present application, not all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor are within the scope of protection of the present application. The technical scheme provided by each embodiment of the present application will be described in detail below in combination with the drawings. In order to better understand the purpose of the present application, the present application will be further described in detail below.

[0056] The codeless configurable task flow program development system provided by the present application comprises:

[0057] The task data acquisition module acquires the task metadata input by the user, encapsulates them as independent task data objects, and outputs the task data objects to the process visual arrangement module;

[0058] The flow visualization arrangement module receives the task data object, generates the task node and the directed connection through the graphical interface, generates the dependency relationship data describing the task execution order, and outputs the dependency relationship data to the task state management module;

[0059] The event binding engine module predefines a set of event types, registers the external event trigger and the task node in association, and sends a state change request to the task state management module;

[0060] The conditional rule analysis module receives the condition expression defined by the user, and converts it into a dynamically callable verification logic;

[0061] The task state management module receives the dependency relationship data and the state change request, drives the state migration according to the dependency relationship data, calls the verification logic of the conditional rule analysis module to perform the conditional verification, atomically updates the task state according to the verification result, and sends a resource loading instruction to the resource dynamic loading module;

[0062] The resource dynamic loading module receives the resource loading instruction and loads the external resource associated with the task data object.

[0063] The task data acquisition module obtains the task metadata defined by the user through the graphical input interface, and the metadata includes task description and initial parameters. The module uses dynamic form technology to analyze the metadata structure, renders it into interactive controls such as text boxes or drop-down lists, and collects user input information. Then, the input information is serialized into an independent task data object through data encapsulation operation, and the task data object includes a unique task identifier, a resource reference pointer and a state initial value field, forming a business data entity separated from the program code. The task data acquisition module transmits the encapsulated task data object to the flow visualization arrangement module, realizes complete closure of the data input link, and facilitates subsequent module processing.

[0064] After the flow visualization arrangement module receives the task data object, the task node entity is presented in the graphical user interface. The user connects the nodes in the directed acyclic graph model through the drag operation, establishes the state migration path between tasks, and the system automatically analyzes the node connection relationship to generate the dependency relationship data in the form of an adjacency matrix. The adjacency matrix describes the trigger order of task execution, such as starting task B after task A is completed. In the conflict detection stage, when a circular dependency is identified, the system calls the topological sorting algorithm to reconstruct the path and correct the dependency logic. Finally, the flow visualization arrangement module outputs the corrected dependency relationship data to the task state management module, realizing seamless conversion from visual configuration to execution logic.

[0065] The event binding engine module predefines a set of event types, including task start, completion or failure events, and maintains a mapping table of event types and task identifiers after receiving node association data output by the process visualization and arrangement module; an event listening agent method is created for each task, event agent data is generated, and an event response relationship is registered through a publish and subscribe mode; when an external system triggers an event, the message distribution unit receives event agent data and external event input, and routes them to the binding task node through a message queue; the event binding engine module sends a state change request to the task state management module, including the target task identifier and the target state value, so that the event-driven mechanism decouples event response and task execution at runtime.

[0066] The conditional rule analysis module receives user-defined natural language condition expressions, supports parameterized input in a declarative interface, such as judgment logic in the form of "player gold ≥ 100"; the syntax conversion unit compiles the expression into an abstract syntax tree structure and outputs it to the context binding unit; the context binding unit injects runtime environment data, such as game state variables, to generate executable rule objects; the logic execution unit receives executable rule objects, generates a Boolean return value verification function, and returns it to the task state management module for condition verification, achieving physical separation of business judgment logic and program control flow.

[0067] The task state management module receives dependency relationship data from the process visualization and arrangement module and state change requests from the event binding engine module, and the dependency relationship data drives the state machine engine to perform state migration; the state machine engine unit calls the verification function of the conditional rule analysis module, executes condition determination, and updates the task state to a new value according to the verification result, such as migrating from "to be processed" to "completed"; at the same time, the state machine engine unit triggers a task state update event; the persistence unit listens to the state update event and synchronizes the task state to the distributed storage system; after the condition verification is passed, the event-driven unit triggers the subsequent task chain defined in the dependency relationship data, and sends a resource loading instruction to the resource dynamic loading module, including the resource identifier.

[0068] The resource dynamic loading module receives a resource loading instruction from the task state management module, and a state monitoring unit subscribes to a task state change event; when it is detected that the task enters an execution state, the state monitoring unit sends a resource index to an asynchronous loading unit; after receiving the resource index, the asynchronous loading unit dispatches external resources such as audio or model files according to the index; in the resource pool management unit, the least recently used strategy is used to cache resources, and if the matching cached resources exist, they are directly called, otherwise new resources are loaded through asynchronous I / O; after the resources are ready, the asynchronous loading unit triggers the update operation of the visual arrangement interface through the rendering interface, and feeds back the task execution result to the user operation interface in real time. The entire system starts from user input, goes through data acquisition, visual arrangement, event binding, condition analysis, state management and resource loading links, and the logical data flow gradually advances, and finally completes the closed-loop feedback in the user interface. Technical personnel can configure complex task logic without writing code.

[0069] Specifically, the code-free configurable task flow development system of the present application comprises:

[0070] A dynamic form unit parses a metadata structure to generate a graphical input control, collects task metadata input by a user, and outputs the collected data to a data packaging unit;

[0071] A data packaging unit receives collected data, serializes user input attributes into a task data object containing a task identifier, a resource index, and an initial state value, and passes the task data object to a flow visual arrangement module.

[0072] The task data collection module includes a dynamic form unit and a data packaging unit. The dynamic form unit parses the JSON Schema defined by the metadata structure, generates graphical input controls including text boxes, drop-down selection boxes and resource selectors; collects task attribute data input by a user through an interactive interface, including description text, resource path information and initial state values, and outputs the collected data to the data packaging unit. The data packaging unit receives the collected data, performs serialization on the user input attributes, and converts them into a task data object including a unique task identifier, a resource index pointer and a state initial value field; the task data object encapsulates business attributes in a standardized JSON format, achieving physical isolation between data and logic layers; the data packaging unit passes the structured task data object to the flow visual arrangement module to provide entity data basis required for visual editing.

[0073] Specifically, the code-free configurable task flow development system of the present application comprises:

[0074] The directed graph modeling unit receives the task data object, maps the task data object into a node entity, converts a connection line into a state transition path, and outputs a node mapping relationship to the dependency analysis unit;

[0075] The dependency analysis unit receives the node mapping relationship, generates an adjacency matrix describing a task trigger sequence, and calls the conflict processing unit when a circular dependency path is detected;

[0076] The conflict processing unit reconstructs the circular dependency path through a topological sorting algorithm, and outputs the reconstructed adjacency matrix to the dependency analysis unit;

[0077] The dependency analysis unit outputs the adjacency matrix to the task state management module.

[0078] The flow visualization arrangement module includes a directed graph modeling unit, a dependency analysis unit, and a conflict processing unit. The directed graph modeling unit receives a task data object and maps it into a draggable node entity in a graphical interface. A user connects nodes into a directed acyclic graph through a drag-and-connect operation, and a connection line is converted into a state transition path. The modeling unit outputs a node topological relationship to the dependency analysis unit. The dependency analysis unit receives a node mapping relationship, automatically analyzes a connection path to generate a two-dimensional adjacency matrix. The adjacency matrix stores a trigger sequence relationship between tasks and describes a logical dependency, such as task A being completed to trigger task B to start. When a circular dependency is detected through path analysis, the dependency analysis unit calls the conflict processing unit. The conflict processing unit reconstructs a dependency path using a Kahn topological sorting algorithm to eliminate circular references. The reconstructed adjacency matrix is returned to the dependency analysis unit, the analysis unit outputs a final adjacency matrix to the task state management module, and the graphical definition and automatic conflict resolution of a task flow are achieved.

[0079] Specifically, the code-free configurable task flow program development system of the present application includes an event binding engine module:

[0080] A registration storage unit receives node association data of the flow visualization arrangement module, maintains a mapping table of event types and task identifiers, and outputs the mapping table to a proxy generation unit;

[0081] The proxy generation unit receives the mapping table, creates an event response method for each task, and generates event proxy data;

[0082] A message distribution unit receives event proxy data and external events, routes external events to a bound task through a message queue, and sends a state change request including a target task identifier to a task state management module.

[0083] The event binding engine module includes a registration storage unit, an agent generation unit and a message distribution unit. The registration storage unit receives node-event association data output by the process visualization arrangement module, maintains a mapping table of event types and task identifiers; the mapping table records the association relationship such as resource change event binding to task ID-T001; the registration storage unit outputs the mapping table to the agent generation unit. The agent generation unit receives the mapping table, creates an event response agent method for each task; generates event agent data including task identifiers, such as onResourceUpdate() callback function encapsulation; the event agent data is transmitted to the message distribution unit. The message distribution unit receives event agent data and external event input; the external event is derived from the event trigger of the game engine or the business system; the event is routed to the bound task node through the message queue middleware; the message distribution unit sends a state change request to the task state management module, the request includes the target task identifier and the request state value, and realizes the dynamic response of the cross-system event.

[0084] Specifically, the code-free configurable task flow program development system of the present application includes:

[0085] The syntax conversion unit receives the user-defined condition expression, compiles the natural language condition into an abstract syntax tree, and outputs the abstract syntax tree to the context binding unit;

[0086] The context binding unit receives the abstract syntax tree, injects runtime environment data, and generates an executable rule object;

[0087] The logic execution unit receives the executable rule object, generates a verification function that returns a Boolean value, and returns the verification result to the task state management module.

[0088] The condition rule analysis module is composed of a syntax conversion unit, a context binding unit and a logic execution unit. The syntax conversion unit receives the condition expression input by the user in the parameterized form; the natural language rule such as "player level >= 5" is compiled into an abstract syntax tree structure; the syntax tree is output to the context binding unit. The context binding unit receives the abstract syntax tree and injects runtime environment data; the runtime data includes a player attribute library and a game state variable; an executable rule object integrated with the context is generated to isolate the rule logic and the execution environment. The logic execution unit receives the executable rule object, generates a verification function that returns a Boolean value; the function type is a callable delegate of the type Func<GameContext, bool>; the verification result true or false is returned to the task state management module, realizing the declarative configuration and dynamic verification execution of the business rule.

[0089] Specifically, the code-free configurable task flow program development system of the present application includes:

[0090] The state machine engine unit receives the dependency data and the state change request, calls the verification logic of the condition rule analysis module to perform condition verification, performs state conversion rules according to the verification result according to the adjacency matrix, and triggers a task state update event;

[0091] The persistence unit listens to the task state update event and synchronizes the task state to the distributed storage;

[0092] The event-driven unit triggers a subsequent task chain when the state machine engine unit passes the verification, and sends a resource identifier to the resource dynamic loading module.

[0093] The task state management module includes a state machine engine unit, a persistence unit and an event-driven unit. The state machine engine unit receives the adjacency matrix from the process arrangement module and the state change request from the event binding module; calls the verification function of the condition rule analysis module to perform condition verification; performs state conversion according to the truth value result according to the adjacency matrix rule; triggers a task state update event to pass a new state value. The persistence unit listens to the task state update event, synchronizes the task state to the Redis distributed storage in real time; and ensures high availability and consistency of state data. The event-driven unit triggers the subsequent task chain node defined by the adjacency matrix when the verification function returns true; sends a resource loading instruction to the resource dynamic loading module; the instruction includes a resource index pointer of a task data object storage, and realizes state-driven automatic task scheduling.

[0094] Specifically, the code-free configurable task flow development system of the present application includes:

[0095] The state listening unit receives the resource loading instruction, subscribes to the task state change event, and sends the resource index to the asynchronous loading unit when detecting that the task enters the execution state;

[0096] The asynchronous loading unit receives the resource index, schedules external files according to the resource index, directly calls if there is a matching cache resource in the resource pool unit, otherwise loads a new resource;

[0097] The resource pool unit caches resources using the least recently used strategy, and provides cache data to the asynchronous loading unit;

[0098] The asynchronous loading unit outputs a resource ready event to the rendering interface after the resource is ready.

[0099] The resource dynamic loading module is composed of a state monitoring unit, an asynchronous loading unit and a resource pool unit. The state monitoring unit receives a resource loading instruction of the task state management module, subscribes to a task state change message queue, and sends a resource index pointer to the asynchronous loading unit when detecting that the task state migrates to an execution state. The asynchronous loading unit receives a resource index, queries the resource pool unit according to the index, the resource pool unit manages a loaded resource cache by using a least recently used algorithm, directly returns a resource handle if the cache resource is hit, and loads an external file system resource through asynchronous IO if the cache resource is not hit. The asynchronous loading unit calls a rendering interface to output a resource ready event after the resource is ready, the rendering interface connects a Unity engine rendering pipeline, triggers interface visual update, and completes resource on-demand loading and reuse management.

[0100] Specifically, the code-free configurable task flow program development system of the application further comprises:

[0101] The message distribution unit carries a target state value in a state change request sent to the task state management module;

[0102] The state machine engine unit receives the state change request, updates the current task state according to the target state value in the request after calling the verification logic, and triggers a subsequent task node defined in the adjacency matrix.

[0103] The message distribution unit carries a specific target state value in the state change request. The state value is derived from an expected state transition defined by a user in an event binding stage. The state machine engine unit receives the request containing the target state value, calls a verification function to determine that it is passed, accurately updates the task state to the target value domain according to the request value, and triggers the state machine operation of the subsequent task node in the adjacency matrix to realize the precise state migration control chain driven by the event.

[0104] Specifically, the code-free configurable task flow program development system of the application further comprises:

[0105] The event-driven unit sends an instruction including a resource identifier to the resource dynamic loading module when the task state migrates to the execution state.

[0106] The asynchronous loading unit triggers the update operation of the visual arrangement interface through the rendering interface after completing the resource loading, and feeds back the task execution result to the user operation interface in real time.

[0107] The event-driven unit sends a resource identifier when the task state migrates to the execution state. The resource identifier points to an external asset storage path. The asynchronous loading unit triggers the visual arrangement interface update through the rendering interface after completing the resource loading operation. The update operation includes task state marker refreshing and resource rendering. The task execution result is fed back to the user operation interface in real time, forming a real-time visual closed loop from configuration change to execution feedback.

[0108] The code-free configurable task flow development system of the present application realizes decoupling of business logic and program code through modular design. The system operation process is described below in combination with a game development scenario:

[0109] Task data acquisition module: business personnel define task metadata in a graphical interface. The dynamic form unit parses the metadata structure (such as JSON Schema) to automatically generate input controls including text boxes and drop-down boxes. After the user inputs task attributes (such as task description, resource path, and initial state value), the data encapsulation unit serializes the attributes into an independent task data object, including a unique task identifier, a resource index pointer, and a state initial value field. The object is passed to the flow visualization arrangement module in a standardized format, realizing physical isolation of task configuration and code layer.

[0110] Flow visualization arrangement module: after receiving the task data object, it is rendered as a draggable node in the graphical interface. The user constructs a directed acyclic graph through connection operation to define the state transition path between tasks. The directed graph modeling unit converts the connection into a dependency relationship, and the dependency analysis unit generates an adjacency matrix describing the execution order (such as task A completion triggering task B). If a circular dependency is detected, the conflict processing unit reconstructs the path through a topological sorting algorithm to eliminate logical conflicts, and finally outputs the corrected adjacency matrix to the task state management module.

[0111] Event binding engine module: preset event types (such as resource change, player upgrade). The registration storage unit maintains a mapping table of event types and task identifiers; the proxy generation unit creates an event response method (such as onResourceUpdate()) for each task. When an external system triggers an event, the message distribution unit routes the event to the bound task through a message queue, sends a change request containing the target task identifier and the target state value (such as "in execution") to the task state management module, realizing dynamic decoupling of events and task execution.

[0112] Condition rule analysis module: business personnel define condition expressions in natural language (such as "player gold ≥ 100"). The syntax conversion unit compiles the expression into an abstract syntax tree; the context binding unit injects runtime data (such as player attribute library) to generate an executable rule object; the logic execution unit outputs a verification function that returns a Boolean value, which is called by the task state management module to avoid hardcoding condition logic to the program layer.

[0113] Task state management module: The state machine engine unit receives the adjacency matrix and state change request. The verification function is called to perform conditional judgment: if the verification is passed, the task state is atomized and updated to the target value (such as "to be processed" → "completed") according to the adjacency matrix rule, triggering the task state update event; the persistent unit synchronizes the state to the distributed storage; the event-driven unit triggers the subsequent task chain, and sends the instruction containing the resource identifier to the resource dynamic loading module.

[0114] Resource dynamic loading module: The state listening unit subscribes to the task state event. When the task enters the execution state, the resource index is sent to the asynchronous loading unit. The asynchronous loading unit queries the resource pool unit according to the index: if there is a matching resource in the cache (managed according to the least recently used strategy), the resource handle is directly called; otherwise, the external file is loaded asynchronously. After the resource is ready, the visual arrangement interface is updated through the rendering interface (such as task state marker refresh, model rendering), and the execution result is fed back to the user operation interface in real time.

[0115] Please refer to Figure 1 The present application solves the problem of strong programming dependency in task development through a code-free configuration system. The system provides a graphical user interface, allowing users to define task metadata, process dependency relationships and event response rules through drag-and-drop operations without writing program code; the task data acquisition module uses dynamic form rendering graphical input controls to collect user input and serialize it into independent task data objects, eliminating the dependence on programming skills. The process visualization arrangement module generates task nodes and state transition paths based on the directed graph model, and the dependency analysis unit automatically generates an adjacency matrix to describe the execution order, allowing non-developers to directly configure complex task logic and reducing programming intervention.

[0116] The high coupling degree of task logic and code is solved by a modular decoupling mechanism. The event binding engine module uses the publish / subscribe mode to associate and register external events with task nodes, generating event agent data; the condition rule analysis module compiles natural language condition expressions into dynamically callable verification functions; the task state management module drives state transition according to the adjacency matrix, and calls verification functions and atomically updates the state at runtime. Business rules and process logic are stored in independent data objects, physically separated from the execution engine, and the state machine engine unit only drives the transition according to the configuration data, avoiding hardcoding conditional branch statements in the program control flow.

[0117] The whole data flow forms a closed-loop configuration execution chain. Starting from task metadata collection, the visual arrangement generates dependency data, the event binding engine triggers state change request, the conditional rule analysis provides dynamic verification, and the task state management module updates the state according to the verification result and triggers resource loading; the resource dynamic loading module responds to the instruction to schedule external resources, and the result is fed back to the user interface in real time. The modules interact through standardized interfaces, and business personnel only need to adjust the configuration data to modify task parameters without touching the source code layer, realizing the complete decoupling of task logic and program code.

[0118] In the process visual arrangement module, when the dependency analysis unit detects the circular dependency path between task nodes, the conflict processing unit is called to use the Kahn topological sorting algorithm. Kahn topological sorting algorithm is a graph theory method, which identifies nodes with in-degree 0 and removes their outgoing edges step by step, reconstructs the dependency path into a linear sequence, and thus eliminates the circular reference problem. This algorithm generates a modified adjacency matrix to describe the task trigger sequence, replacing the traditional manual coding of process control logic, so that technical personnel can intuitively understand the task dependency relationship.

[0119] The event binding engine module realizes the dynamic association of external events and task nodes. After the registration and storage unit maintains the event type and task identifier mapping table, the proxy generation unit creates an event response proxy method. The message distribution unit uses a message queue mechanism such as RabbitMQ to route external events to the bound task nodes based on the publish and subscribe mode. This mechanism realizes the decoupling of event triggering and state change, and technical personnel can manage event response logic by configuring the mapping table without interfering with the underlying code.

[0120] The conditional rule analysis module processes user-defined natural language expressions, and the syntax conversion unit compiles conditions such as "player gold ≥ 100" into abstract syntax tree structure. Abstract syntax tree is a tree-shaped data model, and nodes represent operators or operands; the context binding unit injects runtime environment data such as player attribute variables to generate executable rule objects. The logic execution unit outputs a Boolean value verification function accordingly, realizes dynamic invocation of business rules, and makes technical personnel define conditional logic through declarative input, avoiding hard coding to the program layer.

[0121] In the task state management module, the state machine engine unit drives state transition according to the adjacency matrix, and atomically updates the task state after calling the verification function. The state machine model defines a set of finite states and transition rules, and the persistence unit implements state synchronization through distributed storage such as Redis to ensure data consistency. The resource dynamic loading module applies the least recently used strategy to manage the resource pool unit. The least recently used strategy preferentially eliminates the longest unused cache resources. The asynchronous loading unit combines the asynchronous I / O mechanism to schedule external files, and triggers the rendering interface to update the interface after the resources are ready. These strategies optimize resource utilization, and technical personnel can visually manage the entire cycle of task execution.

[0122] The application comprehensively uses topological sorting, message queue, abstract syntax tree compilation, state machine model, cache strategy and asynchronous I / O algorithm strategy, and modules interact through standardized interfaces. Based on graphical configuration, technical personnel in the field can realize task logic without deepening the algorithm implementation details, thereby efficiently understanding and implementing the entire technical solution.

Claims

1. A no-code, configurable task flow development system, characterized in that, include: The task data acquisition module obtains the task metadata input by the user, encapsulates it into an independent task data object, and outputs the task data object to the process visualization and orchestration module. The process visualization and orchestration module receives task data objects, generates task nodes and directed connections through a graphical interface, generates dependency data describing the task execution order, and outputs the dependency data to the task status management module. The event binding engine module has a pre-defined set of event types, associates and registers external event triggers with task nodes, and sends status change requests to the task status management module. The condition rule parsing module receives user-defined condition expressions and converts them into dynamically invoked validation logic. The condition rule parsing module includes: The syntax transformation unit receives user-defined conditional expressions, compiles natural language conditions into an abstract syntax tree, and outputs the abstract syntax tree to the context binding unit. The context binding unit receives the abstract syntax tree, injects runtime environment data, and generates an executable rule object. The logic execution unit receives an executable rule object, generates a verification function that returns a boolean value, and returns the verification result to the task status management module. The task status management module receives dependency data and status change requests, drives state migration based on dependency data, calls the verification logic of the condition rule parsing module to perform condition verification, atomically updates the task status based on the verification results, and sends resource loading instructions to the resource dynamic loading module. The resource dynamic loading module receives resource loading instructions and loads external resources associated with the task data object.

2. The no-code configurable task flow development system according to claim 1, characterized in that, The task data acquisition module includes: The dynamic form unit parses the metadata structure to generate a graphical input control, collects the task metadata input by the user, and outputs the collected data to the data encapsulation unit; The data encapsulation unit receives the collected data, serializes the user input attributes into a task data object containing a task identifier, resource index, and initial state value, and then passes the task data object to the process visualization and orchestration module.

3. The no-code configurable task flow development system according to claim 2, characterized in that, The process visualization and orchestration module includes: The directed graph modeling unit receives task data objects, maps task data objects to node entities, transforms connection lines into state transition paths, and outputs node mapping relationships to the dependency analysis unit. The dependency analysis unit receives node mapping relationships, generates an adjacency matrix describing the task triggering order, and calls the conflict handling unit when a circular dependency path is detected. The conflict resolution unit reconstructs cyclic dependency paths using a topology sorting algorithm and outputs the reconstructed adjacency matrix to the dependency analysis unit. The dependency analysis unit outputs the adjacency matrix to the task status management module.

4. The no-code configurable task flow development system according to claim 3, characterized in that, The event binding engine module includes: Register the storage unit, receive node association data from the process visualization orchestration module, maintain a mapping table between event types and task identifiers, and output the mapping table to the agent generation unit; The proxy generation unit receives the mapping table, creates an event response method for each task, and generates event proxy data. The message distribution unit receives event broker data and external events, routes external events to the bound task through the message queue, and sends a status change request, including the target task identifier, to the task status management module.

5. The no-code configurable task flow development system according to claim 4, characterized in that, The task status management module includes: The state machine engine unit receives dependency data and state change requests, calls the verification logic of the condition rule parsing module to perform condition verification, executes state transition rules according to the adjacency matrix based on the verification results, and triggers task state update events. The persistent unit listens for task status update events and synchronizes the task status to distributed storage. The event-driven unit triggers the subsequent task chain and sends the resource identifier to the resource dynamic loading module when the state machine engine unit verifies the result.

6. The no-code configurable task flow development system according to claim 5, characterized in that, The resource dynamic loading module includes: The status monitoring unit receives resource loading instructions, subscribes to task status change events, and sends resource indexes to the asynchronous loading unit when it detects that a task has entered the execution state. The asynchronous loading unit receives the resource index, schedules external files based on the resource index, and if the resource pool unit has a matching cached resource, it is called directly; otherwise, the new resource is loaded. The resource pool unit uses a least recently used strategy to cache resources and provides cached data to the asynchronous loading unit. The asynchronous loading unit outputs a resource ready event to the rendering interface after the resources are ready.

7. The no-code configurable task flow development system according to claim 6, characterized in that, Also includes: The message distribution unit sends a status change request to the task status management module, which carries the target status value. The state machine engine unit receives a state change request, and after the verification logic is passed, it updates the current task state according to the target state value in the request and triggers the subsequent task nodes defined in the adjacency matrix.

8. The no-code configurable task flow development system according to claim 7, characterized in that, Also includes: When the task state transitions to the execution state, the event-driven unit sends an instruction including a resource identifier to the resource dynamic loading module. After the asynchronous loading unit completes resource loading, it triggers an update operation on the visual orchestration interface through the rendering interface, and feeds back the task execution results to the user interface in real time.

9. A no-code configurable task flow development method, applied to the no-code configurable task flow development system as described in any one of claims 1 to 8, characterized in that, include: Step 1: Obtain the task metadata input by the user, encapsulate it into an independent task data object, and output the task data object to Step 2; Step 2: Receive the task data object, generate task nodes and directed connections through the graphical interface, generate dependency data describing the task execution order, and output the dependency data to Step 5. Step 3: Preset the event type set, associate and register external event triggers with task nodes, and send a status change request to Step 5; Step 4: Receive user-defined conditional expressions and convert them into dynamically invoked validation logic; Step 5: Receive dependency data and state change requests, drive state transition based on dependency data, call the verification logic in step 4 to perform condition verification, atomically update task state based on verification results, and send resource loading instructions to step 6. Step 6: Receive the resource loading instruction and load the external resources associated with the task data object.

Images