A dynamically configurable method, device, and medium for importing and converting data from documents.

Abstract

This application discloses a dynamically configurable method, device, and medium for importing and converting data from documents, relating to the technical field. The method includes: receiving a user's identifier for zero-value processing and a rule set for field processing; acquiring document fields, parsing the conversion dependencies of preset fields within the rule set, and generating a processing priority sequence for document fields based on the conversion dependencies; determining whether to skip a preset field change based on the identifier; dividing document fields into independent execution domains according to the grouping rules of the grouping field array, processing and triggering the first field data that meets the conversion conditions within each execution domain; starting an asynchronous conversion thread to map the processing results to associated fields in real time; verifying the consistency of the processing results, and submitting the processing results to the database after successful verification. This application achieves dynamic configuration of zero-value processing and group triggering through a rule set architecture, adapting to changes in business scenarios.

Description

Technical Field

[0001] This application relates to the field of data processing and conversion technology, and in particular to a dynamically configurable method, device and medium for converting imported document data. Background Technology

[0002] Currently, most enterprise document data processing systems use fixed conversion rule engines, such as predefined conversion formulas for unit price, quantity, and amount in ERP systems. While this approach can import basic data, it has significant limitations: it cannot dynamically adapt to changing business scenarios, such as tax rate adjustments or discount strategy changes; the processing logic is tightly coupled with the code, requiring the redevelopment of core modules for adding new fields; and it lacks fine-grained control over zero-value data and group triggers, leading to a surge in invalid calculations.

[0003] A particularly prominent problem is the rigid triggering mechanism. When a field value is zero, the system still forces the conversion logic to be executed, resulting in wasted resources. In scenarios with multiple fields linked, the existing solution can only trigger all fields or trigger them independently, and cannot achieve the optimized mode of triggering only the first field in a group. These defects lead to low processing efficiency, resulting in redundant calculations when importing tens of thousands of documents in large enterprises, and increasing the cost of secondary development.

[0004] Based on the above analysis, the problems and shortcomings of the existing technology are as follows:

[0005] Existing document import systems suffer from poor dynamic adaptability, wasted computing resources, and high expansion costs due to fixed triggering mechanisms. Summary of the Invention

[0006] This application provides a dynamically configurable method, device, and medium for converting imported document data, which can solve the problems of poor dynamic adaptability, waste of computing resources, and high expansion costs caused by the fixed triggering mechanism in existing document import systems.

[0007] In a first aspect, embodiments of this application provide a dynamically configurable method for converting imported document data. The method includes: receiving a user's identifier for zero-value processing and a set of rules for field processing, the rule set including a set of independent fields and an array of grouped fields; obtaining document fields, parsing the conversion dependencies of preset fields within the rule set, and generating a processing priority sequence for document fields based on the conversion dependencies; determining whether to skip a preset field change based on the identifier; dividing document fields into independent execution domains according to the grouping rules of the array of grouped fields, processing and triggering the first field data that meets the conversion conditions in each execution domain; starting an asynchronous conversion thread to map the processing results to the associated fields in real time; verifying the consistency of the processing results, and submitting the processing results to the database after verification.

[0008] In one implementation of this application, when a change in a preset field is detected, a determination is made based on an identifier to decide whether to skip the process. Specifically, this includes: detecting the identifier for the current zero-value processing; if the identifier is incorrect, intercepting the zero-value field and removing it from the processing queue; if the identifier is correct, marking the zero-value field as a forced processing state and adding it to a high-priority processing queue.

[0009] In one implementation of this application, document fields are divided into independent execution domains according to grouping rules. Within each execution domain, the first field data that meets the conversion condition is processed and triggered. Specifically, this includes: parsing the topology of the grouping rules and constructing a grouping dependency graph; creating a virtual execution container for each group according to the grouping dependency graph and injecting the document fields into the corresponding container; scanning the fields within the container according to a preset sorting rule and locating the first field that meets the triggering condition as the main trigger point; and suspending the triggering requests of the remaining fields in the same group until the main trigger point completes processing.

[0010] In one implementation of this application, a virtual execution container is created for each group according to the group dependency graph, and document fields are injected into the corresponding container. Specifically, this includes: allocating an independent memory isolation area for the container and storing intermediate conversion results; establishing a data channel between containers so that cross-group fields can pass conversion parameters through the data channel; and releasing container resources and destroying intermediate conversion results after the main trigger point has finished processing.

[0011] In one implementation of this application, an asynchronous conversion thread is started to map the processing results to the associated fields in real time. Specifically, this includes: encapsulating the conversion dependency into a pluggable calculation unit; loading the matching calculation unit according to the field data type; distributing the conversion task to idle calculation nodes through an event bus; and listening for state machine changes of the calculation unit and capturing timeout or abnormal interruption events.

[0012] In one implementation of this application, the consistency of the processing result is verified, and the processing result is submitted to the database after the verification is passed. Specifically, this includes: extracting the numerical change trajectory of document fields before and after conversion; verifying the numerical conservation of related fields according to a preset field balance formula; and when a balance deviation is detected, initiating a rollback compensation mechanism based on transaction logs, generating a data integrity report and marking the coordinates of abnormal fields.

[0013] In one implementation of this application, the method further includes: defining a set of predecessor dependent fields and a set of successor affected fields for configurable fields to obtain a rule chain; constructing a field change path model based on the rule chain; and automatically deconstructing the rule chain into an acyclic subgraph when a circular dependency is detected.

[0014] In one implementation of this application, the method further includes: exposing a configuration interface for the rule set, receiving new rules for processing new fields, and deploying the new rules to the rule engine; starting a sandbox environment to verify the compatibility of the new rules with existing rules; and updating the grouping dependency graph in real time after verification.

[0015] Secondly, embodiments of this application also provide a dynamically configurable document import data conversion device, the device including at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to: receive a user's zero-value processing identifier and a set of rules for field processing, the rule set including an independent field set and a grouped field array; acquire document fields, parse the conversion dependencies of preset fields within the rule set, and generate a processing priority sequence for document fields based on the conversion dependencies; when a change in a preset field is detected, determine whether to skip it based on the identifier; divide the document fields into independent execution domains according to the grouping rules of the grouped field array, process and trigger the first field data that meets the conversion conditions in each execution domain; start an asynchronous conversion thread, and map the processing results to the associated fields in real time; verify the consistency of the processing results, and submit the processing results to the database after verification.

[0016] Thirdly, this application also provides a dynamically configurable non-volatile computer storage medium for converting imported document data. This medium stores computer-executable instructions, which are configured to: receive a user's identifier for zero-value processing and a set of rules for field processing, the rule set including an independent field set and a grouped field array; acquire document fields, parse the conversion dependencies of preset fields within the rule set, and generate a processing priority sequence for document fields based on the conversion dependencies; when a change in a preset field is detected, determine whether to skip it based on the identifier; divide document fields into independent execution domains according to the grouping rules of the grouped field array, process and trigger the first field data that meets the conversion conditions within each execution domain; start an asynchronous conversion thread, mapping the processing results to associated fields in real time; verify the consistency of the processing results, and submit the processing results to the database after successful verification.

[0017] This application provides a dynamically configurable document import data conversion method, device, and medium. Through a rule set architecture, it achieves dynamic configuration of zero-value processing and group triggering to adapt to changes in business scenarios. The grouped virtual container combined with asynchronous computing shortens the processing time for tens of thousands of documents and reduces redundant calculations. The dynamic deconstruction and hot deployment expansion of the rule chain reduces the adaptation cycle for new businesses. The pluggable computing unit supports seamless integration of third-party modules, expanding compatibility. It provides enterprises with a real-time responsive data engine, supports millisecond-level decision analysis, and helps improve supply chain efficiency. Attached Figure Description

[0018] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings:

[0019] Figure 1 A flowchart illustrating a dynamically configurable document import data conversion method provided in this application embodiment;

[0020] Figure 2 This is a schematic diagram of the internal structure of a dynamically configurable document import data conversion device provided in an embodiment of this application. Detailed Implementation

[0021] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below in conjunction with specific embodiments and corresponding drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0022] This application provides a dynamically configurable method, device, and medium for converting imported document data, which solves the problems of poor dynamic adaptability, waste of computing resources, and high expansion costs caused by the fixed triggering mechanism in existing document import systems.

[0023] The technical solutions proposed in the embodiments of this application will be described in detail below with reference to the accompanying drawings.

[0024] Figure 1 This is a flowchart illustrating a dynamically configurable document import data conversion method provided in an embodiment of this application. Figure 1 As shown in the figure, the present application provides a dynamically configurable document import data conversion method, which specifically includes the following steps:

[0025] Step 10: Receive the user's identifier for zero-value processing and the rule set for field processing. The rule set includes a set of individual fields and an array of grouped fields.

[0026] In this step, the zero-value handling identifier `isZero` is a boolean parameter (true / false) set by the user through the system configuration interface. It defines the system's handling strategy for fields with a value of 0. For example, in financial documents, a discount amount of 0 might be ignored (`isZero=false`), while a refund amount of 0 might be subject to mandatory validation (`isZero=true`).

[0027] An independent field set refers to fields that do not require processing in conjunction with other fields, such as basic information fields like product name and order number. Their processing rules only involve format validation. A grouped field array (endEditFieldsArr) refers to a combination of fields with mutually exclusive or dependent relationships, such as promotional fields like discounts, member discounts, and limited-time discounts. The array uses structured data to define group names, lists of fields within each group, and sorting rules.

[0028] Step 20: Obtain document fields, parse the conversion dependencies of preset fields in the rule set, and generate a processing priority sequence of document fields based on the conversion dependencies;

[0029] Step 30: When a change in a preset field is detected, determine whether to skip based on the identifier;

[0030] As an optional embodiment, when a change in a preset field is detected, a determination is made based on an identifier to decide whether to skip the process. Specifically, this may include: Step 301: Detecting the identifier for the current zero-value processing; Step 302: If the identifier is incorrect, intercepting the zero-value field and removing it from the processing queue; Step 303: If the identifier is correct, marking the zero-value field as a forced processing state and adding it to a high-priority processing queue.

[0031] In this step, during the document import process, it's common to encounter fields with values ​​of 0. Based on the company's actual needs, users can configure whether to skip the processing logic for a field with a value of 0. This way, when the system detects a field with a value of 0, it can decide whether to skip the processing logic for that field based on the configuration, thereby improving processing efficiency and avoiding unnecessary calculations.

[0032] During document import, the system reads the user-preset `isZero` value in real time as the basis for subsequent judgments. During the field change detection phase, if the user manually modifies the field value or the system automatically fills in the default value, zero-value fields are identified by value comparison (value=0) and removed from the processing queue. For example, in a sales order, if the quantity of free gifts is 0 and `isZero=false`, the system will skip the inventory deduction logic for that field. Zero-value fields are marked as high priority and enter the processing flow first. For example, in a purchase order, a return quantity of 0 may require mandatory verification to ensure consistency with the received quantity. In this case, the system will prioritize checking the validity of this field and record the verification log. Distinguishing between invalid and valid default values ​​for zero-value fields avoids omissions or errors, improving data accuracy.

[0033] Step 40: Divide the document fields into independent execution domains according to the grouping rules of the grouping field array, and process and trigger the first field data that meets the conversion conditions in each execution domain;

[0034] As an optional implementation, document fields are divided into independent execution domains according to grouping rules. Within each execution domain, the first field data that meets the conversion conditions is processed and triggered. Specifically, this may include: Step 401: Parsing the topology of the grouping rules and constructing a grouping dependency graph; Step 402: Creating a virtual execution container for each group according to the grouping dependency graph and injecting the document fields into the corresponding container; Step 403: Scanning fields within the container according to a preset sorting rule and locating the first field that meets the triggering conditions as the main trigger point; Step 404: Suspending the triggering requests of the remaining fields in the same group until the main trigger point completes processing.

[0035] In this step, users can configure whether to trigger data processing logic in groups as needed. When configured for group triggering, the system will group the imported data according to the user-defined grouping rules. Within each group, only the first piece of data that meets condition 1 (i.e., the specific processing logic trigger condition) will be processed. This is suitable for scenarios where data needs to be processed in batches according to certain rules, but only the first piece of data in each group needs to be processed with specific logic. When configured for non-group triggering, the system will check each piece of data one by one according to the configured field order to see if it meets condition 1. For data that meets the condition, the system will trigger the corresponding processing logic. This method is suitable for scenarios where each piece of data needs to be processed independently, and the processing logic does not depend on other data.

[0036] The topological structure in endEditFieldsArr is parsed, such as Promotions Group → Tax Group, Basic Information Group → Amount Group, and a visual dependency graph is generated using a directed graph algorithm.

[0037] Each group corresponds to an independent memory-isolated container, such as a lightweight sandbox or in-memory object based on Docker. The container stores the group's field data, intermediate calculation results, and processing status, such as pending or processing. For example, the promotion group container only stores field values ​​related to promotions to avoid confusion with tax group data. Fields within the container are scanned according to a preset sorting rule. The first field to meet the triggering condition, such as a discount amount > 0 or an order amount ≥ the discount threshold, is designated as the primary trigger point. In the promotion group, if the discount condition is met first, it becomes the primary trigger point. After the primary trigger point starts processing, the system temporarily freezes the trigger requests of other fields in the same group using a locking mechanism, marking them as suspended until the primary trigger point completes processing. If the primary trigger point fails to process, the next field is triggered sequentially according to the sorting rule.

[0038] As an optional embodiment, a virtual execution container is created for each group according to the group dependency graph, and document fields are injected into the corresponding container. Specifically, it may include: Step 4021: Allocate an independent memory isolation area for the container and store intermediate conversion results; Step 4022: Establish a data channel between containers so that cross-group fields can pass conversion parameters through the data channel; Step 4023: After the main trigger point is processed, release the container resources and destroy the intermediate conversion results.

[0039] In this step, each device is allocated an independent memory address space, and process isolation or namespace techniques are used to prevent memory data from different groups from contaminating each other. Intermediate results, such as the discounted amount calculated by the promotion group, are temporarily stored in the container's cache for subsequent steps to read. For groups with dependencies, such as the promotion group → tax group, the system establishes a channel through a preset data interface. After the promotion group completes processing, the discounted amount is pushed to the tax group container via an event notification as a basic parameter for calculating the tax amount. After the main trigger point completes processing and the result has been synchronized to the associated fields, the container releases the occupied memory resources and deletes the intermediate results. If an exception occurs during processing, the container resources are forcibly cleaned up through a garbage collection mechanism.

[0040] Step 50: Start the asynchronous conversion thread to map the processing results to the associated fields in real time;

[0041] As an optional implementation, an asynchronous conversion thread is started to map the processing results to the associated fields in real time. Specifically, this may include: Step 501: Encapsulating the conversion dependency into a pluggable calculation unit; Step 502: Loading the matching calculation unit according to the field data type; Step 503: Distributing the conversion task to idle calculation nodes through the event bus; Step 504: Listening for state machine changes of the calculation unit and capturing timeout or abnormal interruption events.

[0042] In this step, the field conversion logic—total price = unit price × quantity, tax amount = taxable amount × tax rate—is encapsulated into independent calculation units, and these units are decoupled from each other through interfaces. For example, the discount calculation unit can be independently replaced with different logic such as new customer discounts or member discounts without modifying other code.

[0043] Step 60: Verify the consistency of the processing results, and submit the processing results to the database after successful verification.

[0044] As an optional embodiment, verifying the consistency of the processing results and submitting the processing results to the database after verification can specifically include: Step 601: Extracting the numerical change trajectory of document fields before and after conversion; Step 602: Verifying the numerical conservation of related fields according to the preset field balance formula; Step 603: When a balance deviation is detected, initiating a rollback compensation mechanism based on transaction logs, generating a data integrity report and marking the coordinates of abnormal fields.

[0045] As an optional embodiment, the method may further include: defining a set of predecessor dependent fields and a set of successor affected fields for configurable fields to obtain a rule chain; constructing a field change path model based on the rule chain; and automatically deconstructing the rule chain into an acyclic subgraph when a circular dependency is detected.

[0046] As an optional embodiment, the method may further include: exposing a configuration interface for the rule set, receiving new rules for processing new fields, and deploying the new rules to the rule engine; starting a sandbox environment to verify the compatibility of the new rules with existing rules; and updating the grouping dependency graph in real time after verification.

[0047] The above are embodiments of the method proposed in this application. Based on the same inventive concept, embodiments of this application also provide a dynamically configurable document import data conversion device, the structure of which is as follows: Figure 2 As shown.

[0048] Figure 2 This is a schematic diagram of the internal structure of a dynamically configurable document import data conversion device provided in an embodiment of this application. For example... Figure 2 As shown, the device includes:

[0049] At least one processor 201;

[0050] And a memory 202 that is communicatively connected to at least one processor;

[0051] The memory 202 stores instructions executable by at least one processor. These instructions are executed by at least one processor 201 to enable the processor 201 to: receive a user's identifier for zero-value processing and a set of rules for field processing, the rule set including a set of independent fields and an array of grouped fields; acquire document fields, parse the conversion dependencies of preset fields within the rule set, and generate a processing priority sequence for document fields based on the conversion dependencies; when a change in a preset field is detected, determine whether to skip it based on the identifier; divide the document fields into independent execution domains according to the grouping rules of the array of grouped fields, process and trigger the first field data that meets the conversion conditions in each execution domain; start an asynchronous conversion thread to map the processing results to the associated fields in real time; verify the consistency of the processing results, and submit the processing results to the database after verification.

[0052] Some embodiments of this application provide corresponding to Figure 1A dynamically configurable non-volatile computer storage medium for importing and converting document data stores computer-executable instructions. These instructions are configured to: receive a user's identifier for zero-value processing and a set of rules for field processing, the rule set including a set of independent fields and an array of grouped fields; acquire document fields, parse the conversion dependencies of preset fields within the rule set, and generate a processing priority sequence for document fields based on these dependencies; determine whether to skip a preset field change based on the identifier; divide document fields into independent execution domains according to the grouping rules of the array of grouped fields, process and trigger the first field data that meets the conversion conditions within each execution domain; start an asynchronous conversion thread to map the processing results to associated fields in real time; verify the consistency of the processing results, and submit the processing results to the database after successful verification.

[0053] The various embodiments in this application are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the embodiments for IoT devices and media are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0054] The systems, media, and methods provided in this application are one-to-one correspondences. Therefore, the systems and media also have similar beneficial technical effects as their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the systems and media will not be repeated here.

[0055] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0056] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0057] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0058] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0059] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0060] Memory may include non-persistent storage in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0061] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can store information using any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic magnetic disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0062] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0063] The above description is merely an embodiment of this application and is not intended to limit the scope of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of the claims of this application.

Claims

1. A dynamically configurable method for converting imported document data, characterized in that, The method includes: Receive the user's identifier for zero-value processing and the rule set for field processing, the rule set including a set of independent fields and an array of grouped fields; Obtain the document fields, parse the conversion dependency relationship of the preset fields in the rule set, and generate the processing priority sequence of the document fields according to the conversion dependency relationship; When a change in the preset field is detected, it is determined whether to skip the step based on the identifier. According to the grouping rules of the grouping field array, the document fields are divided into independent execution domains. Within each execution domain, the first field data that meets the conversion conditions is processed and triggered, specifically including: The topological structure of the grouping rules is analyzed, and a grouping dependency graph is constructed. A virtual execution container is created for each group based on the grouping dependency graph, and document fields are injected into the corresponding container. The fields within the container are scanned according to a preset sorting rule, and the first field that meets the triggering condition is located as the main trigger point. Suspend the trigger requests for the remaining fields in the same group until the main trigger point completes processing; Start an asynchronous conversion thread to map the processing results to the associated fields in real time; Verify the consistency of the processing results, and submit the processing results to the database after successful verification.

2. The dynamically configurable document import data conversion method according to claim 1, characterized in that, The step of determining whether to skip based on the identifier when a change in the preset field is detected specifically includes: Detect the identifier for the current zero-value processing; When the identifier is incorrect, the zero-value field is intercepted and removed from the processing queue; When the identifier is correct, the zero-value field is marked as a forced processing state and added to the high-priority processing queue.

3. The dynamically configurable document import data conversion method according to claim 1, characterized in that, The step of creating a virtual execution container for each group based on the grouping dependency graph and injecting document fields into the corresponding container specifically includes: Allocate a separate memory isolation area for the container and store the intermediate conversion results; Establish a data channel between the containers so that cross-group fields can pass conversion parameters through the data channel; After the main trigger point completes its processing, the container resources are released and the intermediate conversion results are destroyed.

4. The dynamically configurable document import data conversion method according to claim 1, characterized in that, The asynchronous conversion thread is initiated to map the processing results to the associated fields in real time, specifically including: The conversion dependency is encapsulated into a pluggable computing unit; Load the matching calculation unit according to the field data type; The conversion task is distributed to idle computing nodes via the event bus; Monitor state machine changes of the computing unit and capture timeout or abnormal interruption events.

5. The dynamically configurable document import data conversion method according to claim 1, characterized in that, The process of verifying the consistency of the processing results and submitting the processing results to the database after the verification is passed specifically includes: extracting the numerical change trajectory of the document fields before and after the conversion; The numerical conservation of the associated fields is verified according to the preset field balancing formula; When an imbalance is detected, a rollback compensation mechanism based on the transaction log is initiated, a data integrity report is generated, and the coordinates of the abnormal fields are marked.

6. The dynamically configurable document import data conversion method according to claim 1, characterized in that, The method further includes: Define the predecessor dependency field set and the successor influence field set for configurable fields to obtain the rule chain; A field change path model is constructed based on the rule chain, and the rule chain is automatically deconstructed into an acyclic subgraph when a circular dependency is detected.

7. The dynamically configurable document import data conversion method according to claim 1, characterized in that, The method further includes: Expose the configuration interface of the rule set, receive new rules for processing new fields, and deploy the new rules to the rule engine; Launch a sandbox environment to verify the compatibility of the new rules with existing rules; The grouping dependency graph is updated in real time after verification.

8. A dynamically configurable document import data conversion device, characterized in that, The device includes: At least one processor; And, a memory communicatively connected to the at least one processor; The memory stores instructions executable by the at least one processor, which, when executed by the at least one processor, enable the at least one processor to: Perform the steps of the dynamically configurable document import data conversion method as described in any one of claims 1-7.

9. A non-volatile computer storage medium capable of dynamically configurable document import data conversion, storing computer-executable instructions, characterized in that, The computer-executable instructions are set as follows: Perform the steps of the dynamically configurable document import data conversion method as described in any one of claims 1-7.

Images