Code-free configurable task process type development system and method

Abstract

The invention relates to the technical field of data processing, in particular to a code-free configurable task process type development system and method, and the system comprises a task data collection module, a process visualization 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 visualization arrangement module generates task nodes and dependency relationship data based on a graphical interface; the condition rule analysis module is used for converting natural language conditions into verification logic capable of being dynamically called; the task state management module drives state transition according to the dependency relationship data, and the task state is atomized and updated after verification logic is called; and the resource dynamic loading module responds to the resource loading instruction to schedule external resources. Through a modularized decoupling mechanism, business personnel use a graphical interface to configure task logic, program codes do not need to be written, and the technical problems of high programming dependency and high task logic and code coupling degree are solved.

Description

Technical Field

[0001] The present invention relates to the field of data processing technology, and in particular to a code-free configurable task flow development system and method. Background Art

[0002] Code-free configurable task flow is a business process management method based on a graphical user interface. Users build and modify workflow models by dragging and dropping visual groups without writing code. This approach abstracts the complexity of the underlying technology and only requires business rule definitions to automatically execute serialized tasks and process decision logic. Therefore, it lowers the technical threshold while improving automation efficiency, allowing non-developers to quickly deploy and maintain complex processes. It is suitable for accelerating enterprise digital transformation and operational optimization.

[0003] The existing task system development has problems with strong programming dependencies and high coupling between task logic and code. The fundamental reason is 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 transition rules, event response logic and inter-task dependencies of specific tasks in the form of conditional branch statements and state judgment codes in the program logic layer. When planners need to adjust the number of task targets or modify the completion conditions, developers must locate and modify the corresponding program code implementation layer logic and recompile and deploy the entire module, resulting in a strong coupling between business demand changes and the underlying code implementation. Summary of the Invention

[0004] In view of the shortcomings of the existing technology, the present invention provides a code-free configurable task process development system and method to solve the problems of strong programming dependence and high coupling between task logic and code in task system development.

[0005] In order to solve the above technical problems, the specific technical solutions of the present invention are as follows: In a first aspect, the present invention provides a code-free configurable task flow development system and method, comprising: The task data collection 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 orchestration module; The process visualization orchestration module receives task data objects, generates task nodes and directed connections through a graphical interface, generates dependency data describing the order of task execution, and outputs the dependency data to the task status management module; The event binding engine module presets 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; The conditional rule parsing module receives user-defined conditional expressions and converts them into dynamically callable verification logic; The task status management module receives dependency data and status change requests, drives status migration based on dependency data, calls the verification logic of the conditional rule parsing module to perform conditional 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.

[0006] Furthermore, the task data collection module of the code-free configurable task flow development system of the present invention includes: The dynamic form unit parses the metadata structure to generate graphic input controls, 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 passes the task data object to the process visualization orchestration module.

[0007] Furthermore, the code-free configurable task process development system of the present invention includes a process visualization orchestration module: The directed graph modeling unit receives the task data object, maps the task data object into a node entity, converts the connection line into a state transition path, and outputs the node mapping relationship to the dependency analysis unit; The dependency analysis unit receives the node mapping relationship, generates an adjacency matrix describing the task triggering order, and calls the conflict handling unit when a circular dependency path is detected; The conflict handling unit reconstructs the cyclic dependency path through a topological 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.

[0008] Furthermore, the code-free configurable task flow development system of the present invention includes an event binding engine module: The registration storage unit receives the node association data of the process visualization orchestration module, maintains the mapping table between event types and task identifiers, and outputs the mapping table to the agent generation unit; The agent generation unit receives the mapping table, creates an event response method for each task, and generates event agent data; The message distribution unit receives event agent data and external events, routes the external events to the bound tasks through the message queue, and sends a state change request including the target task identifier to the task state management module.

[0009] Furthermore, the code-free configurable task flow development system of the present invention includes a conditional rule parsing module: The syntax conversion unit receives the user-defined conditional expression, compiles the natural language condition 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 executable rule objects; 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 status management module.

[0010] Furthermore, the task status management module of the code-free configurable task flow development system of the present invention includes: The state machine engine unit receives dependency data and state change requests, calls the verification logic of the conditional rule parsing module to perform conditional verification, executes state transition rules according to the adjacency matrix based on the verification results, and triggers task state update events; Persistence unit, monitors task status update events and synchronizes task status to distributed storage; The event-driven unit triggers the subsequent task chain when the state machine engine unit passes the verification, and sends the resource identifier to the resource dynamic loading module.

[0011] Furthermore, the code-free configurable task flow development system of the present invention includes a resource dynamic loading module: The state monitoring unit receives resource loading instructions, subscribes to task state change events, and sends the resource index to the asynchronous loading unit when detecting that the task enters the execution state; The asynchronous loading unit receives the resource index and schedules the external file based on the resource index. If the resource pool unit has a matching cache resource, it will be directly called, otherwise a new resource will be loaded. The resource pool unit caches resources using the least recently used strategy and provides cached data to the asynchronous loading unit; The asynchronous loading unit outputs a resource ready event to the rendering interface after the resource is ready.

[0012] Furthermore, the code-free configurable task flow development system of the present invention further includes: The state change request sent by the message distribution unit to the task state management module carries the target state value; The state machine engine unit receives the state change request, calls the verification logic and 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.

[0013] Furthermore, the code-free configurable task flow development system of the present invention further includes: When the task state is transferred 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 the update operation of the visual orchestration interface through the rendering interface, and feeds back the task execution results to the user operation interface in real time.

[0014] In a second aspect, the present invention provides a code-free configurable task flow development method, which is applied to a code-free configurable task flow development system, including: 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 a 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 the external event trigger with the task node and register it, and send a state change request to step 5; Step 4: Receive the user-defined conditional expression and convert it into dynamically callable verification logic; Step 5: Receive dependency data and state change requests, drive state migration based on dependency data, call the verification logic in step 4 to perform condition verification, atomically update the task state based on the verification results, and send a resource loading instruction to step 6; Step 6: Receive a resource loading instruction and load the external resources associated with the task data object.

[0015] Beneficial effects of the present invention: The beneficial effects of the present invention are reflected in the elimination of programming dependencies through a code-free graphical configuration mechanism, and the use of a modular decoupling design to cut off the hard-coded association between task logic and program code. The task data acquisition module generates a graphical input control through a dynamic form, and non-developers can configure task metadata and encapsulate it as an independent data object; the process visualization orchestration module converts the directed graph model into an adjacency matrix to describe task dependencies, eliminating the need for manual coding of process control statements. The event binding engine module establishes a mapping relationship between event types and task identifiers, and the conditional rule parsing module compiles natural language expressions into executable verification logic to achieve physical separation of business rules and execution engines. The task state management module drives state migration based on the adjacency matrix, atomically updates the task state after calling the verification logic, and the resource dynamic loading module dispatches resources on demand in response to state changes, forming a closed-loop data flow from user configuration to execution feedback. Each module interacts through a standardized interface. Business personnel only need to modify the configuration data to adjust task parameters, without recompiling the program source code layer, essentially solving the technical problems of strong programming dependencies and high code coupling. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] In order to more clearly illustrate the technical solution of the present invention, the following is a brief introduction to the drawings required for use in the embodiments. Obviously, for ordinary technicians in this field, other drawings can be obtained based on the drawings without paying any creative labor.

[0017] Figure 1 A flowchart of a code-free, configurable task flow development method provided by an embodiment of the present invention. DETAILED DESCRIPTION

[0018] In order to make the purpose, technical solutions and advantages of the present invention clearer, the technical solutions of the present invention will be clearly and completely described below in conjunction with the specific embodiments of the present invention and the corresponding drawings. Obviously, the embodiments described are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present invention. The technical solutions provided by each embodiment of the present invention are described in detail below in conjunction with the drawings. In order to better understand the purpose of the present invention, the present invention is further described in detail below.

[0019] The present invention provides a code-free configurable task flow development system, comprising: The task data collection 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 orchestration module; The process visualization orchestration module receives task data objects, generates task nodes and directed connections through a graphical interface, generates dependency data describing the order of task execution, and outputs the dependency data to the task status management module; The event binding engine module presets 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; The conditional rule parsing module receives user-defined conditional expressions and converts them into dynamically callable verification logic; The task status management module receives dependency data and status change requests, drives status migration based on dependency data, calls the verification logic of the conditional rule parsing module to perform conditional 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.

[0020] The present invention provides a code-free configurable task process development system, which relates to the field of data processing technology, specifically to the code-free configuration of task logic through a modular structure. The task data acquisition module obtains the task metadata defined by the user through a graphical input interface. These metadata include task descriptions and initial parameters. The module uses dynamic form technology to parse the metadata structure, renders it into interactive controls, such as text boxes or drop-down lists, and collects user input information; then, through data encapsulation operations, the input information is serialized into an independent task data object. 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 passes the encapsulated task data object to the process visualization orchestration module to achieve complete closure of the data input link, which is convenient for subsequent module processing.

[0021] After receiving the task data object, the process visualization orchestration module presents the task node entity in the graphical user interface. The user connects the nodes in the directed acyclic graph model by dragging and dropping to establish the state migration path between tasks. The system automatically analyzes the node connection relationship and generates dependency data in the form of an adjacency matrix, where the adjacency matrix describes the triggering 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 process visualization orchestration module outputs the corrected dependency data to the task state management module, realizing a seamless transition from visual configuration to execution logic.

[0022] The event binding engine module predefines a set of event types, including task start, completion or failure events. After receiving the node association data output by the process visualization orchestration module, the module maintains a mapping table between event types and task identifiers; creates an event listening proxy method for each task, generates event proxy data, and registers event response relationships through the publish and subscribe model; when an external system triggers an event, the message distribution unit receives the event proxy data and external event input, and routes it to the bound task node through the message queue; the event binding engine module sends a state change request to the task state management module, which includes the target task identifier and target state value, so that the event-driven mechanism decouples event response and task execution at runtime.

[0023] The conditional rule parsing module receives user-defined natural language conditional expressions and uses a declarative interface to support parameterized input, such as judgment logic in the form of "player gold coins ≥ 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 the executable rule object, generates a Boolean return value verification function, and returns it to the task status management module for conditional verification, thereby achieving physical separation of business judgment logic and program control flow.

[0024] After the task state management module receives the dependency data from the process visualization orchestration module and the state change request from the event binding engine module, the dependency data drives the state machine engine to execute state migration; the state machine engine unit calls the verification function of the condition rule parsing module, executes the condition judgment, and updates the task status to the new value according to the verification result, such as migrating from "pending" to "completed"; at the same time, the state machine engine unit triggers the task status update event; the persistence unit listens to the status update event and synchronizes the task status to the distributed storage system; after the condition verification is passed, the event-driven unit triggers the subsequent task chain defined in the dependency data and sends a resource loading instruction to the resource dynamic loading module, which includes a resource identifier.

[0025] The resource dynamic loading module receives resource loading instructions from the task status management module, and the status monitoring unit subscribes to task status change events. When it detects that a task has entered the execution state, the status monitoring unit sends a resource index to the asynchronous loading unit. After receiving the resource index, the asynchronous loading unit schedules external resources, such as audio or model files, based on the index. In the resource pool management unit, the least recently used strategy is used to cache resources. If a matching cached resource exists, it is 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 orchestration interface through the rendering interface, and feeds back the task execution results to the user operation interface in real time. The entire system starts with user input, and through data collection, visual orchestration, event binding, conditional parsing, status management and resource loading, the logical data flow gradually advances, and finally completes the closed-loop feedback in the user interface. Technicians can configure complex task logic without writing code.

[0026] Specifically, the code-free configurable task flow development system of the present invention includes a task data acquisition module comprising: The dynamic form unit parses the metadata structure to generate graphic input controls, 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 passes the task data object to the process visualization orchestration module.

[0027] The task data collection module includes a dynamic form unit and a data encapsulation unit. The dynamic form unit parses the JSON Schema defined by the metadata structure and generates graphical input controls including text boxes, drop-down selection boxes, and resource selectors. It collects task attribute data entered by users through the interactive interface, including descriptive text, resource path information, and initial state values, and outputs the collected data to the data encapsulation unit. The data encapsulation unit receives the collected data, performs serialization operations on the user-entered attributes, and converts them into task data objects that include a unique task identifier, resource index pointer, and initial state value fields. The task data object uses the standardized JSON format to encapsulate business attributes, achieving physical isolation between data and the logical layer. The data encapsulation unit passes the structured task data object to the process visualization orchestration module, providing the entity data foundation required for visual editing.

[0028] Specifically, the code-free configurable task process development system of the present invention includes a process visualization orchestration module: The directed graph modeling unit receives the task data object, maps the task data object into a node entity, converts the connection line into a state transition path, and outputs the node mapping relationship to the dependency analysis unit; The dependency analysis unit receives the node mapping relationship, generates an adjacency matrix describing the task triggering order, and calls the conflict handling unit when a circular dependency path is detected; The conflict handling unit reconstructs the cyclic dependency path through a topological 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.

[0029] The process visual orchestration module includes a directed graph modeling unit, a dependency analysis unit, and a conflict resolution unit. The directed graph modeling unit receives task data objects and maps them to draggable node entities in a graphical interface. Users connect nodes into a directed acyclic graph by dragging lines, and the lines are converted into state transition paths. The modeling unit outputs the node topology relationship to the dependency analysis unit. The dependency analysis unit receives the node mapping relationship and automatically analyzes the connection path to generate a two-dimensional adjacency matrix. The adjacency matrix stores the triggering order relationship between tasks, describing the logical dependency that triggers the start of task B when task A is completed. When path analysis detects a circular dependency, the dependency analysis unit calls the conflict resolution unit. The conflict resolution unit uses the Kahn topological sorting algorithm to reconstruct the dependency path and eliminate circular references. The reconstructed adjacency matrix is ​​returned to the dependency analysis unit, which then outputs the final adjacency matrix to the task state management module, enabling graphical definition of task processes and automated conflict resolution.

[0030] Specifically, the code-free configurable task flow development system of the present invention includes an event binding engine module: The registration storage unit receives the node association data of the process visualization orchestration module, maintains the mapping table between event types and task identifiers, and outputs the mapping table to the agent generation unit; The agent generation unit receives the mapping table, creates an event response method for each task, and generates event agent data; The message distribution unit receives event agent data and external events, routes the external events to the bound tasks through the message queue, and sends a state change request including the target task identifier to the task state management module.

[0031] The event binding engine module includes a registration storage unit, an agent generation unit, and a message dispatch unit. The registration storage unit receives the node-event association data output by the process visualization orchestration module and maintains a mapping table between event types and task identifiers. The mapping table records, for example, the association between resource change events and 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 the task identifier, such as the onResourceUpdate() callback function encapsulation, and passes the event agent data to the message dispatch unit. The message dispatch unit receives event agent data and external event input; external events originate from event triggers in the game engine or business system; the event is routed to the bound task node through the message queue middleware; the message dispatch unit sends a state change request to the task state management module, which includes the target task identifier and the requested state value, to achieve dynamic response to cross-system events.

[0032] Specifically, the code-free configurable task flow development system of the present invention includes a conditional rule parsing module: The syntax conversion unit receives the user-defined conditional expression, compiles the natural language condition 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 executable rule objects; 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 status management module.

[0033] The conditional rule parsing module consists of a syntax conversion unit, a context binding unit, and a logic execution unit. The syntax conversion unit receives the conditional expression entered by the user in a parameterized form; compiles natural language rules such as "Player level ≥ 5" into an abstract syntax tree structure; and outputs the syntax tree to the context binding unit. The context binding unit receives the abstract syntax tree and injects runtime environment data; the runtime data includes the player attribute library and game state variables; generates an executable rule object with integrated context, isolating the rule logic from the execution environment. The logic execution unit receives the executable rule object and generates a verification function that returns a Boolean value; the function type is Func<GameContext, bool> A callable delegate; returns a true or false value of the verification result to the task status management module, realizing declarative configuration of business rules and dynamic verification execution.

[0034] Specifically, the code-free configurable task flow development system of the present invention includes a task status management module: The state machine engine unit receives dependency data and state change requests, calls the verification logic of the conditional rule parsing module to perform conditional verification, executes state transition rules according to the adjacency matrix based on the verification results, and triggers task state update events; Persistence unit, monitors task status update events and synchronizes task status to distributed storage; The event-driven unit triggers the subsequent task chain when the state machine engine unit passes the verification, and sends the resource identifier to the resource dynamic loading module.

[0035] The task state management module consists of a state machine engine unit, a persistence unit, and an event-driven unit. The state machine engine unit receives state change requests from the process orchestration module, including the adjacency matrix and the event binding module. It then calls the validation function of the conditional rule parsing module to perform conditional validation. Based on the truth value result, it executes state transitions according to the adjacency matrix rules and triggers task state update events to transmit the new state value. The persistence unit monitors task state update events and synchronizes task states to Redis distributed storage in real time, ensuring high availability and consistency of state data. When the validation function returns a true value, the event-driven unit triggers subsequent task chain nodes defined by the adjacency matrix and sends resource loading instructions to the dynamic resource loading module. These instructions include resource index pointers to the task data object storage, enabling state-driven automated task scheduling.

[0036] Specifically, the code-free configurable task flow development system of the present invention includes a resource dynamic loading module: The state monitoring unit receives resource loading instructions, subscribes to task state change events, and sends the resource index to the asynchronous loading unit when detecting that the task enters the execution state; The asynchronous loading unit receives the resource index and schedules the external file based on the resource index. If the resource pool unit has a matching cache resource, it will be directly called, otherwise a new resource will be loaded. The resource pool unit caches resources using the least recently used strategy and provides cached data to the asynchronous loading unit; The asynchronous loading unit outputs a resource ready event to the rendering interface after the resource is ready.

[0037] The resource dynamic loading module consists of a state monitoring unit, an asynchronous loading unit, and a resource pool unit. The state monitoring unit receives resource loading instructions from the task state management module; subscribes to the task state change message queue; and when it detects that the task state has migrated to the execution state, it sends a resource index pointer to the asynchronous loading unit. The asynchronous loading unit receives the resource index and queries the resource pool unit based on the index; the resource pool unit uses the least recently used algorithm to manage the loaded resource cache; if the cached resource is hit, the resource handle is directly returned; if it is not hit, the external file system resource is loaded through asynchronous IO. After the resource is ready, the asynchronous loading unit calls the rendering interface to output a resource ready event; the rendering interface connects to the Unity engine rendering pipeline, triggering the interface visual update, and completing the on-demand loading and reuse management of resources.

[0038] Specifically, the code-free configurable task flow development system of the present invention further includes: The state change request sent by the message distribution unit to the task state management module carries the target state value; The state machine engine unit receives the state change request, calls the verification logic and 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.

[0039] The state change request sent by the message dispatch unit carries a specific target state value; this state value is derived from the expected state transition defined by the user during the event binding phase. The state machine engine unit receives the request containing the target state value, invokes the validation function, and, upon passing the validation, accurately updates the task state to the target value range based on the requested value. This triggers the state machine operations corresponding to the subsequent task nodes in the adjacency matrix, thus implementing an event-driven, precise state transition control chain.

[0040] Specifically, the code-free configurable task flow development system of the present invention further includes: When the task state is transferred 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 the update operation of the visual orchestration interface through the rendering interface, and feeds back the task execution results to the user operation interface in real time.

[0041] The event-driven unit sends a resource identifier when the task transitions to the execution state; the resource identifier points to the external asset storage path. After the asynchronous loading unit completes resource loading, it triggers an update of the visual orchestration interface through the rendering interface. This update includes refreshing the task status marker and rendering the resources. Task execution results are fed back to the user interface in real time, forming a real-time, visual closed loop from configuration changes to execution feedback.

[0042] The code-free, configurable task flow development system of the present invention achieves decoupling of business logic and program code through modular design. The following describes the system operation process in conjunction with the game development scenario: Task Data Collection Module: Business personnel define task metadata in a graphical interface. The dynamic form unit parses the metadata structure (e.g., JSON Schema) and automatically generates input controls, including text boxes and drop-down boxes. After the user enters task attributes (such as task description, resource path, and initial state value), the data encapsulation unit serializes these attributes into a separate task data object, including a unique task identifier, resource index pointer, and initial state value fields. This object is passed to the process visual orchestration module in a standardized format, physically isolating task configuration from the code layer.

[0043] The process visual orchestration module receives task data objects and renders them as draggable nodes in a graphical interface. Users construct a directed acyclic graph by connecting them, defining the state transition paths between tasks. The directed graph modeling unit converts the connections into dependencies, and the dependency analysis unit generates an adjacency matrix describing the execution order (e.g., the completion of task A triggers task B). If a circular dependency is detected, the conflict handling unit reconstructs the path using a topological sorting algorithm to eliminate logical conflicts and ultimately outputs the corrected adjacency matrix to the task state management module.

[0044] The event binding engine module pre-sets event types (e.g., resource change, player upgrade). The registration storage unit maintains a mapping table between event types and task identifiers; the proxy generation unit creates event response methods (e.g., onResourceUpdate()) for each task. When an external system triggers an event, the message dispatch unit routes the event to the bound task via the message queue and sends a change request containing the target task identifier and target state value (e.g., "Executing") to the task state management module, dynamically decoupling events from task execution.

[0045] Conditional Rule Parsing Module: Business personnel define conditional expressions (e.g., "Player's gold ≥ 100") in natural language. The syntax conversion unit compiles the expression into an abstract syntax tree. The context binding unit injects runtime data (e.g., a player attribute library) to generate executable rule objects. The logic execution unit outputs a validation function that returns a Boolean value for the task status management module to call, eliminating the need for hard-coding conditional logic into the program layer.

[0046] Task State Management Module: The state machine engine unit receives the adjacency matrix and state change requests. It calls the validation function to execute the conditional check. If validation passes, the task state is atomically updated to the target value (e.g., "pending" → "completed") according to the adjacency matrix rules, triggering a task state update event. The persistence unit synchronizes the state to distributed storage. The event-driven unit triggers the subsequent task chain and sends a command containing a resource identifier to the dynamic resource loading module.

[0047] Dynamic Resource Loading Module: The status monitoring unit subscribes to task status events. When a task enters the execution state, it sends a resource index to the asynchronous loading unit. The asynchronous loading unit queries the resource pool unit based on the index. If a matching resource exists in the cache (managed according to the least recently used policy), the resource handle is directly called; otherwise, an external file is asynchronously loaded. Once the resource is ready, the visual orchestration interface is updated through the rendering interface (such as refreshing the task status mark and rendering the model), providing real-time feedback on the execution results to the user interface.

[0048] See also Figure 1The present invention solves the problem of strong programming dependency in task development through a code-free configuration system. The system provides a graphical user interface that allows users to define task metadata, process dependencies, and event response rules by dragging and dropping without writing program code; the task data acquisition module uses dynamic forms to render graphical input controls, collects user input and serializes it into independent task data objects, eliminating the dependence on programming skills. The process visualization orchestration module generates task nodes and state transition paths based on a directed graph model, and the dependency analysis unit automatically generates an adjacency matrix to describe the execution order. Non-developers can directly configure complex task logic and reduce programming intervention.

[0049] The high degree of coupling between task logic and code is addressed through a modular decoupling mechanism. The event binding engine module uses a publish-and-subscribe model to register external events with task nodes and generate event proxy data. The conditional rule parsing module compiles natural language conditional expressions into dynamically callable validation functions. The task state management module drives state migration based on the adjacency matrix, calling validation functions and atomically updating state at runtime. Business rules and process logic are stored in independent data objects, physically separated from the execution engine. The state machine engine unit drives migration only based on configuration data, avoiding hard-coding conditional branch statements into the program control flow.

[0050] The overall data flow forms a closed-loop configuration execution chain. Beginning with task metadata collection, dependency data is generated through visual orchestration. The event binding engine triggers state change requests, and conditional rule parsing provides dynamic verification. The task state management module updates the state and triggers resource loading based on the verification results. The resource dynamic loading module responds to instructions and dispatches external resources, with the results fed back to the user interface in real time. Modules interact through standardized interfaces, allowing business personnel to modify task parameters simply by adjusting configuration data without touching the source code, achieving complete decoupling of task logic from program code.

[0051] In the process visualization orchestration module of this invention, when the dependency analysis unit detects a circular dependency path between task nodes, it calls the conflict handling unit to apply the Kahn topological sorting algorithm. The Kahn topological sorting algorithm is a graph theory method that eliminates circular references by identifying nodes with zero in-degree and gradually removing their out-edges, reconstructing dependency paths into a linear sequence. This algorithm generates a revised adjacency matrix that describes the task triggering sequence, replacing traditional manually coded process control logic and enabling technicians to intuitively understand task dependencies.

[0052] The event binding engine module dynamically associates external events with task nodes. After the registration storage unit maintains a mapping table between event types and task identifiers, the proxy generation unit creates event response proxy methods. The message distribution unit uses a message queue mechanism such as RabbitMQ to route external events to bound task nodes based on a publish-and-subscribe model. This mechanism decouples event triggering from state changes, allowing technicians to manage event response logic by configuring the mapping table without intervening in the underlying code.

[0053] The conditional rule parsing module processes user-defined natural language expressions. The syntax conversion unit compiles conditions such as "Player gold ≥ 100" into an abstract syntax tree (AST). An AST is a tree-like data model where 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 then outputs Boolean validation functions, enabling dynamic invocation of business rules. This allows technicians to define conditional logic through declarative input, avoiding hard-coding in the program layer.

[0054] In the task state management module, the state machine engine unit drives state migration based on the adjacency matrix and atomically updates the task state after calling the validation function. The state machine model defines a finite set of states and transition rules. The persistence unit synchronizes state through distributed storage such as Redis to ensure data consistency. The dynamic resource loading module manages the resource pool unit using a least recently used strategy, which prioritizes the removal of cached resources that have not been accessed for the longest time. The asynchronous loading unit utilizes asynchronous I / O mechanisms to schedule external files, triggering a rendering interface update when resources are ready. These strategies optimize resource utilization, allowing technicians to visually manage the entire task execution cycle.

[0055] The present invention integrates topological sorting, message queuing, abstract syntax tree compilation, state machine models, caching strategies, and asynchronous I / O, with modules interacting via standardized interfaces. Those skilled in the art can implement task logic based on graphical configuration without delving into the details of algorithm implementation, allowing them to efficiently understand and implement the entire technical solution.

Claims

1. A code-free configurable task flow development system, characterized by: include: The task data collection 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 orchestration module; The process visualization orchestration module receives task data objects, generates task nodes and directed connections through a graphical interface, generates dependency data describing the order of task execution, and outputs the dependency data to the task status management module; The event binding engine module presets 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; The conditional rule parsing module receives user-defined conditional expressions and converts them into dynamically callable verification logic; The task status management module receives dependency data and status change requests, drives status migration based on dependency data, calls the verification logic of the conditional rule parsing module to perform conditional 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 code-free configurable task flow development system according to claim 1, characterized in that: The mission data acquisition module includes: The dynamic form unit parses the metadata structure to generate graphic input controls, 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 passes the task data object to the process visualization orchestration module.

3. The code-free configurable task flow development system according to claim 2, characterized in that: The process visual orchestration module includes: The directed graph modeling unit receives the task data object, maps the task data object into a node entity, converts the connection line into a state transition path, and outputs the node mapping relationship to the dependency analysis unit; The dependency analysis unit receives the node mapping relationship, generates an adjacency matrix describing the task triggering order, and calls the conflict handling unit when a circular dependency path is detected; The conflict handling unit reconstructs the cyclic dependency path through a topological 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 code-free configurable task flow development system according to claim 3, characterized in that: The event binding engine module includes: The registration storage unit receives the node association data of the process visualization orchestration module, maintains the mapping table between event types and task identifiers, and outputs the mapping table to the agent generation unit; The agent generation unit receives the mapping table, creates an event response method for each task, and generates event agent data; The message distribution unit receives event agent data and external events, routes the external events to the bound tasks through the message queue, and sends a state change request including the target task identifier to the task state management module.

5. The code-free configurable task flow development system according to claim 4, characterized in that: The conditional rule parsing module includes: The syntax conversion unit receives the user-defined conditional expression, compiles the natural language condition 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 executable rule objects; 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 status management module.

6. The code-free configurable task flow development system according to claim 5, 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 conditional rule parsing module to perform conditional verification, executes state transition rules according to the adjacency matrix based on the verification results, and triggers task state update events; Persistence unit, monitors task status update events and synchronizes task status to distributed storage; The event-driven unit triggers the subsequent task chain when the state machine engine unit passes the verification, and sends the resource identifier to the resource dynamic loading module.

7. The code-free configurable task flow development system according to claim 6, characterized in that: The resource dynamic loading module includes: The state monitoring unit receives resource loading instructions, subscribes to task state change events, and sends the resource index to the asynchronous loading unit when detecting that the task enters the execution state; The asynchronous loading unit receives the resource index and schedules the external file based on the resource index. If the resource pool unit has a matching cache resource, it will be directly called, otherwise a new resource will be loaded. The resource pool unit caches resources using the least recently used strategy and provides cached data to the asynchronous loading unit; The asynchronous loading unit outputs a resource ready event to the rendering interface after the resource is ready.

8. The code-free configurable task flow development system according to claim 7, characterized in that: Also includes: The state change request sent by the message distribution unit to the task state management module carries the target state value; The state machine engine unit receives the state change request, calls the verification logic and 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.

9. The code-free configurable task flow development system according to claim 8, characterized in that: Also includes: When the task state is transferred 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 the update operation of the visual orchestration interface through the rendering interface, and feeds back the task execution results to the user operation interface in real time.

10. A code-free configurable task flow development method, applied to the code-free configurable task flow development system according to any one of claims 1 to 9, 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 a 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 the external event trigger with the task node and register it, and send a state change request to step 5; Step 4: Receive the user-defined conditional expression and convert it into dynamically callable verification logic; Step 5: Receive dependency data and state change requests, drive state migration based on dependency data, call the verification logic in step 4 to perform condition verification, atomically update the task state based on the verification results, and send a resource loading instruction to step 6; Step 6: Receive a resource loading instruction and load the external resources associated with the task data object.

Images