Low-code based offer management system

Abstract

The application relates to the field of quotation management, and specifically discloses a low-code-based quotation management system. First, the input quotation sheet data stream is subjected to structured preprocessing, and a layout area distinguishing static display and dynamic repeated lines is intelligently identified by using regional clustering analysis technology. On this basis, by establishing a field mapping relationship between physical coordinates and natural language table headers, an absolute coordinate formula in Excel that is tightly coupled with a grid position is automatically generalized and converted into an abstract logical atlas pointing to relative business fields by using a cell conversion and relationship deconstruction mechanism. Finally, the identified view configuration and the deconstructed business logic are deeply fused to generate an application architecture package, which is subjected to verification testing. This processing mode realizes the automatic migration of a local quotation sheet to an online system, and ensures the adaptability and correctness of the calculation logic of an online quotation template in a dynamic line expansion scenario.

Description

Technical Field

[0001] This application relates to the field of quotation management, and more specifically, to a low-code-based quotation management system. Background Technology

[0002] With the acceleration of enterprise digital transformation, sales quotations, as a crucial link in business transactions, directly impact a company's market responsiveness through standardized management and efficient workflow. For a long time, enterprises have been accustomed to building complex quotation models based on local spreadsheets (Excel). While this approach offers high flexibility, it suffers from inherent disadvantages in areas such as multi-party collaborative approval, historical version tracking, and data asset accumulation. Therefore, smoothly migrating locally distributed quotation operations to standardized online systems has become an urgent need for enterprise IT infrastructure development. Low-code platforms, with their agile construction and visual configuration advantages, have become the ideal carrier for such quotation management systems.

[0003] However, migrating complex local quotations to readily available low-code systems remains a significant challenge under the current technological framework. Current mainstream solutions typically rely on developers manually disassembling Excel templates, analyzing cell structures one by one, and redefining form components and calculation scripts on the web. This process is not only lengthy and costly, but also highly susceptible to human error leading to the omission of complex linked formulas or distortion of the original layout. Even when existing technologies attempt to automate migration through import tools, their core capabilities are often limited to static syntax translation of table grids—that is, they can only parse Excel into a static JSON grid for the web, lacking the ability to deeply infer business semantics. The fundamental technical bottleneck lies in the paradigm conflict of data addressing methods. Spreadsheets use physical addressing logic based on Cartesian coordinates, such as referencing C2 and D2 for calculations, while low-code systems follow entity attribute logic based on object models, such as referencing current row.unit price and current row.quantity. Existing parsers cannot automatically recognize that visually continuous rows in Excel are actually iterable "dynamic repeating row regions," preventing the automatic generalization of formulas based on fixed physical coordinates into relative referencing logic that adapts to dynamic addition and deletion operations on the web. This lack of semantic understanding leads to logical gaps in quotation sheets under dynamic row expansion scenarios. After system migration, users still need to spend a lot of effort manually rewriting calculation rules, failing to truly achieve automated construction and intelligent delivery of the quotation management system. Summary of the Invention

[0004] To address the aforementioned technical challenges, this application is proposed. According to this application, a low-code-based quotation management system includes: a quotation data stream preprocessing module, used to perform raw data structuring and atomic object extraction on the binary data stream of the quotation to obtain an original cell matrix containing physical coordinate attributes and style fingerprint features; a region clustering analysis module, used to perform region clustering analysis based on isomorphism features on the original cell matrix to identify a set of layout regions that distinguish between static regions and dynamic repeating row regions; a coordinate field mapping module, used to perform header text backtracking extraction and natural language cleaning on the original cell matrix based on the layout region set to obtain a coordinate field mapping dictionary; and a cell transformation and relation destructuring module, used to perform... The local area set locates the formula cells in the original cell matrix and uses a coordinate field mapping dictionary to perform generalization transformation and dependency deconstruction on the operands inside the formulas in the formula cells from absolute physical coordinates to relative business fields to obtain an abstract logic graph; the data component fusion module is used to fuse the layout area set, coordinate field mapping dictionary and abstract logic graph into low-code models and view components to obtain an application architecture package containing full view configuration and logic definition; the architecture package verification and testing module is used to load the application architecture package into the low-code runtime engine to perform data node isolation verification and passability testing to obtain an online quotation template object that supports dynamic row expansion calculation.

[0005] Compared to existing technologies, this application provides a low-code-based quotation management system designed to address the semantic distortion problem during the migration of physical coordinate logic to object-oriented business logic. First, the input quotation data stream undergoes structured preprocessing, and regional clustering analysis is used to intelligently identify layout areas that distinguish between static displays and dynamically repeating rows, thereby accurately defining the iteration scope of business data. Based on this, a field mapping relationship between physical coordinates and natural language table headers is established. Then, a cell transformation and relational deconstruction mechanism is employed to automatically generalize the absolute coordinate formulas tightly coupled to grid positions in Excel into abstract logical graphs pointing to relative business fields, effectively breaking down the data addressing paradigm barrier between the Cartesian coordinate system and the Web object model. Finally, the identified view configuration and deconstructed business logic are deeply integrated to generate an application architecture package, which is then validated and tested. This approach enables automated migration of local quotation documents to the online system without manual formula rewriting, ensuring the adaptability and correctness of the calculation logic in dynamic row expansion scenarios for the online quotation template. Attached Figure Description

[0006] The above and other objects, features, and advantages of this application will become more apparent from the more detailed description of the embodiments of this application in conjunction with the accompanying drawings. The drawings are provided to further illustrate the embodiments of this application and form part of the specification. They are used together with the embodiments of this application to explain this application and do not constitute a limitation thereof. In the drawings, the same reference numerals generally represent the same components or steps.

[0007] Figure 1 This is a block diagram of a low-code-based quotation management system according to an embodiment of this application.

[0008] Figure 2 This is a schematic diagram of the data flow of a low-code-based quotation management system according to an embodiment of this application.

[0009] Figure 3 This is a block diagram of the cell conversion and relation destructuring module in a low-code-based quotation management system according to an embodiment of this application.

[0010] Figure 4 This is a schematic diagram of data flow in a data component fusion module of a low-code-based quotation management system according to an embodiment of this application. Detailed Implementation

[0011] Embodiments of this disclosure will now be described in more detail with reference to the accompanying drawings. While some embodiments of this disclosure are shown in the drawings, it should be understood that this disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of this disclosure. It should be understood that the accompanying drawings and embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of protection of this disclosure.

[0012] This application is made in response to the problems of the prior art. Figure 1 This is a block diagram of a low-code-based quotation management system according to an embodiment of this application. Figure 2 This is a schematic diagram of the data flow in a low-code-based quotation management system according to an embodiment of this application. Specifically, as... Figure 1 and Figure 2As shown, the low-code-based quotation management system 100 according to an embodiment of this application includes: a quotation data stream preprocessing module 110, used to perform raw data structuring and atomic object extraction on the binary data stream of the quotation to obtain an original cell matrix containing physical coordinate attributes and style fingerprint features; a region clustering analysis module 120, used to perform region clustering analysis based on isomorphism features on the original cell matrix to identify a set of layout regions that distinguish between static regions and dynamic repeating row regions; a coordinate field mapping module 130, used to perform header text backtracking extraction and natural language cleaning on the original cell matrix based on the set of layout regions to obtain a coordinate field mapping dictionary; and a cell conversion and relation deconstruction module 14. 0 is used to locate the formula cells in the original cell matrix based on the layout area set, and to use the coordinate field mapping dictionary to perform generalization transformation and dependency deconstruction on the operands inside the formula in the formula cell from absolute physical coordinates to relative business fields to obtain an abstract logic graph; Data component fusion module 150 is used to fuse the layout area set, coordinate field mapping dictionary and abstract logic graph with low-code model and view components to obtain an application architecture package containing full view configuration and logic definition; Architecture package verification and testing module 160 is used to load the application architecture package into the low-code runtime engine to perform data node isolation verification and passability testing to obtain an online quotation template object that supports dynamic row expansion calculation.

[0013] Specifically, the quotation data stream preprocessing module 110 is used to perform raw data structuring and atomic object extraction on the quotation binary data stream to obtain a raw cell matrix containing physical coordinate attributes and style fingerprint features. It is understood that enterprise-level quotation documents are typically stored in binary compressed packages conforming to the Office Open XML standard. Their internal data is scattered across multiple XML files, and the data storage logic employs a sparse matrix strategy, recording only cell nodes containing data or formatting. This results in a non-linear correspondence between physical coordinates and storage order. Furthermore, low-code engines cannot directly understand this unstructured binary stream, let alone perform layout feature analysis and logical inference at the binary level. To achieve automated recognition of quotation format, this high-entropy binary data stream needs to be transformed into an ordered, computable two-dimensional matrix structure. The binary data stream of the quotation is subjected to raw data structuring and atomic object extraction to obtain a raw cell matrix containing physical coordinate attributes and style fingerprint features. This is to eliminate the heterogeneity caused by file storage format, and to map discrete XML nodes into standardized atomic objects with clear physical coordinates and style attributes, thereby providing a precise computational foundation for subsequent isomorphic region clustering analysis and logical generalization.

[0014] Specifically, in one feasible solution, the quotation data stream preprocessing module 110 includes: a data stream filtering and extraction unit 111, used to unpack, filter, and extract the structured data stream of the quotation to obtain a sparse cell dataset containing valid coordinates and original values; a multidimensional attribute dimensionality reduction feature calculation unit 112, used to perform multidimensional attribute dimensionality reduction and feature instantiation calculation on the elements in the sparse cell dataset to obtain a feature-enhanced cell list injected with style fingerprint feature values; and an enhanced cell mapping redundancy processing unit 113, used to perform spatial mapping and redundancy removal processing on the feature-enhanced cell list to obtain the original cell matrix.

[0015] The implementation is as follows: During execution, the data stream filtering and extraction unit 111 first receives the binary data stream of the quotation uploaded by the user via the standard HTTP file transfer protocol. This data stream is essentially a composite ZIP compressed package, which internally follows the directory structure defined by the ECMA-376 standard. It contains core components such as xl / workbook.xml (defining the overall workbook structure), xl / styles.xml (storing global style definitions), xl / sharedStrings.xml (storing shared text indexes), and xl / worksheets / sheetN.xml (storing specific worksheet data). At the start of processing, this unit loads the embedded file parsing engine and uses a ZIP decompression algorithm to unpack the data stream in memory without generating temporary files, ensuring processing efficiency and data security. The parsing engine first reads the [Content_Types].xml file to build a resource index, then locates the storage path of the target worksheet, such as xl / worksheets / sheet1.xml. Given the typically large size of worksheet XML files, this unit does not construct a complete DOM (Document Object Model) tree. Instead, it uses a SAX (Simple API for XML) event-driven model to perform a streaming traversal of the XML document. The parser scans sequentially along the file stream, and when the start element event is triggered and the tag is... <row>When the tag is `r`, read the `r` attribute of the node to lock the current line number; when the tag is `r`... <c>When (Cell) is accessed, the cell parsing logic is triggered. Within this parsing logic, the cell is first extracted... <c>The `r` attribute of a node, such as `E15`, represents the cell's physical coordinates. The parsing engine separates the letter part (AES) from the number part (15) using regular expressions. It then uses a base-26 conversion algorithm to convert the column label letters into integer column numbers based on 0 indices (e.g., A corresponds to 0, Z to 25, AA to 26). This, combined with the row number, establishes the two-dimensional spatial index of the data point. Next, the `s` attribute is extracted; its value is an integer index pointing to the style record in `xl / styles.xml`, representing the style fingerprint of that cell. Finally, the `t` attribute (Type) and child nodes are extracted. <v>(Value). If the t attribute does not exist, then <v>The content within is the raw numeric value; if the t attribute value is s, it indicates that the cell stores a shared string index, in which case the parsing engine needs to determine the index based on the numeric value. <v>The index value in the table is used to look up the corresponding text value in the pre-loaded SharedStrings table in memory using a hash mapping algorithm. During the traversal, this unit simultaneously performs data cleaning and filtering logic. For each scanned cell node, it is checked whether it contains valid data (non-empty strings or non-zero values) or whether it has been assigned a non-default style index. If a node has neither content nor a special style (it is just a blank placeholder in the Excel grid), it is judged as redundant noise and discarded. All nodes that pass the verification are encapsulated into a structured object containing four core dimensions: row index, column index, original value, and style index. After a complete traversal of the entire XML stream, these discrete structured objects are aggregated into a non-contiguous storage collection, namely a sparse cell dataset. For example, for a quotation with data only in positions C3 and D3, the output dataset will only contain two object descriptions, instead of constructing a full empty matrix of 1,048,576 rows.

[0016] After receiving the sparse cell dataset from the previous stage, the multi-dimensional attribute dimensionality reduction feature calculation unit 112 initiates a full traversal processing flow. The engine first loads the parsed xl / styles.xml style definition table from memory as a global search dictionary, which constructs a mapping between style indices and specific format descriptors. For each discrete element in the dataset, an instantiation operation is first performed to construct a memory object containing row indices, column indices, and the original content value. Then, the style index carried by the element is extracted, and its corresponding physical style attribute is searched back through the global search dictionary. Considering the extremely high dimensionality and redundancy of Excel styles, directly comparing them to the original styles incurs excessive computational overhead; therefore, the core of this step lies in performing multi-dimensional attribute feature extraction. Specifically, the unit extracts feature values ​​for four key dimensions from the style descriptors: the RGB hexadecimal code representing the cell fill color. For example, #FFFF00; a combined font feature string containing the font name, font size, and bold / italic status. For example, Arial_11_Bold; a serialized value describing the line style and color of the top, bottom, left, and right borders. ; and a numeric format mask that defines how numerical values ​​are displayed (such as currency symbols, percentage precision). After extracting the aforementioned basic features, a weighted hash algorithm is used to generate a unique pattern fingerprint in order to transform the complex visual patterns into scalar identifiers that can be processed quickly by a computer. For a cell located in row i and column j, its pattern fingerprint feature value... The calculation follows the following logical formula: . In the formula, A non-cryptographic hash mapping function representing a high-throughput method (e.g., MurmurHash3) used to map variable-length attribute strings to fixed-length 32-bit or 64-bit integers; symbol Represents arithmetic multiplication; symbol Represents arithmetic addition; symbol This represents a bitwise XOR operation, used to increase the randomness of the result while maintaining feature independence. In the formula... , , These are preset feature weight coefficients, set based on statistical analysis of a large number of quotation templates. Since background color and border lines are usually the most prominent visual markers distinguishing header areas, group summary rows, and regular detail rows, they are assigned higher weight values, for example, by setting... =100, =50, while the business meaning of font changes is relatively weak, so the weight can be set lower, such as =10. For example, for a unit price column data cell with coordinates (5,2), its background color is white (Hash value amplified by weights to X), font is regular (Hash value amplified by weights to Y), border is thin line (Hash value amplified by weights to Z), and format is two decimal places. The calculation unit inputs these values ​​into the formula to generate a unique integer fingerprint, such as 2849301. This fingerprint value is then injected into the atomic object as an extended metadata field called style fingerprint. Once all sparse elements have been processed, these atomic objects carrying physical coordinates, business data, and style fingerprints are uniformly encapsulated into a feature-enhanced cell list.

[0017] In its specific implementation, the enhanced cell mapping redundancy processing unit 113 first receives a list of feature-enhanced cells output by the previous-level computing unit. To reconstruct the visualized table structure, this unit first initiates boundary detection logic, performing a full traversal scan of the list. During the scan, it extracts the row index r and column index c recorded in each atomic object, and updates the currently observed maximum row value in real time through comparison operations. With the largest column value For example, if the coordinates of the furthest cell in the list are (15, 8), which is the 16th row and 9th column, then the physical boundary of the initial matrix is ​​established. Based on these two extreme values, the cell is initialized in memory with a dimension of... The system uses a two-dimensional array container, pre-setting all elements within the array to an empty state, as a canvas to be filled. The processing then proceeds to the spatial mapping and filling stage. This unit again traverses the feature-enhanced cell list, reading the physical coordinates (r, c) of each atomic object, using them as direct addressing indices, and precisely placing the complete object instance, containing the original value, formula string, and style fingerprint extended attributes, at the corresponding position in the two-dimensional array. This achieves the transformation from sparse storage to a dense matrix view, allowing any cell to be directly accessed via coordinates while preserving its relative position in Excel. While the resulting matrix restores the spatial structure, it often contains a large amount of invalid whitespace. For example, users might habitually start drawing tables from row 5, column 3, resulting in rows 0 to 4 and columns 0 to 2 being logically invalid areas. These areas, though devoid of data, occupy matrix dimensions and are termed edge redundancy. To eliminate this noise that interferes with subsequent region recognition, this unit performs an edge clipping algorithm. This algorithm employs a centripetal approximation strategy, scanning row-by-row or column-by-column from the top, bottom, left, and right boundaries of the matrix towards the center. Taking the top boundary as an example, the algorithm checks all elements in the vector of row 0, determining whether all elements are empty or contain only invalid placeholders of the default style. If the row is determined to be a completely empty and redundant row, the pruning pointer moves down to row 1 to continue checking until the first row containing valid data is encountered, i.e., a row with non-empty values ​​or a significant style fingerprint, and this row is marked as the starting row index of the valid view. Similarly, the algorithm applies the same logic to the bottom, left, and right boundaries, ultimately locking in the rectangular bounding box of valid data. Based on this bounding box, the large matrix in memory is sliced, discarding all data layers outside the bounding box and retaining only the core business data area. The final output data object is the original cell matrix, which is a two-dimensional structured data body that has removed all irrelevant background noise, is compact, and retains the complete style fingerprint and spatial adjacency relationship.

[0018] Specifically, the region clustering analysis module 120 is used to perform region clustering analysis based on isomorphic features on the original cell matrix to identify the set of layout regions that distinguish between static regions and dynamic repeating row regions. Correspondingly, although a compact original cell matrix containing only valid business data has been successfully constructed in the preceding steps through spatial mapping and redundancy removal, this matrix is ​​still only a two-dimensional set of discrete data points from a computer perspective, lacking a macroscopic understanding of the business logic structure. The computing engine cannot distinguish that some rows at the top of the matrix belong to static header descriptions, while the dozens of rows in the middle are actually repeated iterations of the same business logic. If the application is directly generated based on this state, the web form will be a fixed number of static input boxes, unable to respond to the dynamic needs of users adding a new product row in actual pricing scenarios, because the system has not extracted a row model that achieves row expansion through reuse. Therefore, performing region clustering analysis based on isomorphic features on the original cell matrix allows for the identification of implicit structured patterns in the matrix through both visual and logical rules, accurately defining the boundaries between static frames and dynamic recurring regions.

[0019] Specifically, in one feasible scheme, the region clustering analysis module 120 includes: a topological signature featureization unit 121, used to extract topological signatures and vectorize features for each row of the original cell matrix to obtain a row feature descriptor sequence; an isomorphic decision generation unit 122, used to calculate isomorphism judgment index and filter continuity thresholds for adjacent rows in the row feature descriptor sequence to obtain isomorphic decision vectors reflecting logical breakpoints; and a layout region generation unit 123, used to perform region segmentation and type labeling judgment on the isomorphic decision vectors and combine them with the original cell matrix to confirm boundaries to obtain a set of layout regions.

[0020] The implementation is as follows: In order to uncover the hidden row-level structure patterns, the topological signature feature unit 121 initiates the processing logic to process each row of the original cell matrix. The unit performs a deep traversal scan. When processing any specified row, this unit performs feature extraction tasks in parallel across two dimensions: logical topology analysis and visual fingerprint aggregation. For the logical topology dimension, the focus is on resolving the surface heterogeneity problem caused by absolute references in Excel formulas. For example, in the original matrix, the cell in row 5, column 4 might contain the formula "=C5*D5", which is unit price multiplied by quantity, while the cell in row 6, column 4 contains "=C6*D6". Although the string literal changes from 5 to 6, causing a direct mismatch, the business logic is completely consistent. This unit uses a built-in Abstract Syntax Tree (AST) parser to parse all cells containing formulas in the current row. The parser decomposes the formula string into operand and operator nodes, identifying the cell reference nodes. Specifically, this parsing process first starts the lexical analysis engine, which, based on a predefined set of Excel formula syntax rules, uses a deterministic finite automaton (DFA) to perform character-level scanning and segmentation of the extracted formula string, transforming it into an ordered token sequence composed of arithmetic operators, function reserved words, numerical constants, and cell address identifiers. Subsequently, the parser intervenes, using a recursive descent algorithm to process the token sequence, constructing a hierarchical tree-like data structure based on operator precedence and associativity rules. In this abstract syntax tree, non-leaf nodes represent operators such as addition, subtraction, multiplication, division, or logical judgments, while leaf nodes carry specific operands. The system then performs a full-link search of the tree structure using a depth-first search (DFS) algorithm, accurately identifying and locking the cell reference nodes marked as Reference in the metadata, i.e., nodes pointing to specific physical coordinates, thus transforming the originally flat text string into a three-dimensional logical object that can be programmed. Next, a coordinate relativization algorithm is applied to calculate the relative displacement between the reference target and the current cell. For example, if the current cell coordinates are (r, c) and the reference target coordinates are (r', c'), then the converted relative reference description is R[r'-r]C[c'-c]. Taking the aforementioned example, the displacement of C5 relative to E5 in the formula of row 5 is a row offset of 0 and a column offset of -2, thus transforming into R[0]C[-2]; similarly, the displacement of C6 relative to E6 in the formula of row 6 is also R[0]C[-2]. After this transformation, formulas in different rows but with the same logic are normalized into a completely consistent topological structure string, which is the logical topological signature of that row. At the same time, this cell aggregates the style fingerprint feature values ​​generated in the previous stage for each cell in the current row along the column direction. A combined style vector representing the visual style of the entire row is generated through vector concatenation or hash aggregation. This vector accurately describes the row-level combined feature that the first column is white background and bold, and the second column is gray background and regular. Finally, this unit fuses the normalized logical topological signature with the combined style vector to construct a high-dimensional row feature descriptor. This descriptor contains all the core features of the row in terms of logical operation structure and visual representation. After all rows in the matrix have undergone the above processing, these descriptors are arranged in order according to their original row index, and the final output is a sequence of row feature descriptors.

[0021] After receiving the row feature descriptor sequence, the isomorphism decision generation unit 122 initiates a row-by-row scanning analysis based on a sliding window mechanism. This unit sets up an analysis window of length 2, progressing sequentially along the sequence index, focusing on real-time comparison of the isomorphic relationship between the current row (row i) and the next row (row i+1). To quantify this relationship, the unit defines a set of stringent judgment criteria based on both logical and visual dimensions. In specific implementation, this isomorphism judgment index is calculated. The core calculation formula for deciding whether two rows should be merged is: . In the formula, and These represent the logical topological signatures of the i-th and i+1-th rows, respectively, which are the normalized formula structure strings. This is an indicative function that returns 1 if and only if the condition within the parentheses is true, i.e., the logical structures of the two formulas are completely identical; otherwise, it returns 0. This means that if there is even the slightest difference in the calculation logic between the two lines—for example, one line multiplies the unit price by the quantity, and the other line multiplies the unit price by the quantity and then by the discount—no matter how similar they appear visually, the result of that calculation will be zero, and it will be directly determined as non-isomorphic (breakpoint). For strict equality testing, the formula structures of the two rows must be completely identical. The latter part of the formula is used to handle the visual similarity determination of rows that do not contain formulas or have identical formulas. and It is a two-line combined style vector. This represents the cosine similarity calculation function, used to measure the similarity of two high-dimensional style vectors in a direction, and its value ranges from 0 to 1. This is the preset style weight coefficient, such as the default value of 1.0. This is a predefined minimum similarity threshold. This threshold is set based on statistical testing of large-scale historical samples, aiming to allow for subtle style deviations (such as alternating background color bands between rows) while accurately identifying significant visual abrupt changes when transitioning from a header to a data area or vice versa. For example, a threshold of 0.95. Based on this logic, for a specific quotation example, if rows 5 and 6 are both detail rows, and the formula for both is "=Quantity * Unit Price", with the only difference in style being the background grayscale, then... The return value is 1, and the similarity calculation result is 0.98, which is greater than 0.95. A result of 1 indicates that the two lines are logically continuous; however, when scanning to the 10th line (the last line of details) and comparing it with the 11th line (the summary line), the formula structure in the 11th line changes to "SUM(...)" or the style changes abruptly, which will lead to... A value of 0 or a sharp drop in similarity makes It becomes 0. After traversing the complete sequence, the output isomorphic decision vector is a binary sequence consisting of a series of 0s and 1s, such as [...,1,1,1,1,0,...], where each 0 precisely marks a potential business logic breakpoint.

[0022] In its implementation, the layout region generation unit 123 first loads the isomorphic decision vectors output by the isomorphic decision generation unit and the original cell matrix. The core task of this unit is to map the linear decision vectors back to the spatial structure of a two-dimensional matrix and perform semantic segmentation. The processing flow begins with a full scan of the isomorphic decision vectors; the system iterates through each element of the isomorphic decision vectors. This searches for the index position where the value is 0. In the algorithm definition, when... When the value is 0, it means there is a significant logical or visual difference between the i-th row and the (i+1)-th row; this position is marked as a logical breakpoint. Based on these breakpoints, the system uses a slicing algorithm to vertically decompose the original cell matrix into several independent candidate row blocks. For example, in a quotation matrix containing 15 rows, the decision vector at indices 4 and 10 has a value of 0, meaning... =0, =0, other intervals are as follows to All are 1. The slicing algorithm divides the matrix into three independent, continuous regions: the first region contains rows 0 to 4 (header and column names), the second region contains rows 5 to 10 (quotation details), and the third region contains rows 11 to the end (total and remarks). Subsequently, the unit performs type determination logic for each segmented row block. For the second region (rows 5-10), the system detects that this row block contains more than one row (6 rows in total), and its corresponding internal decision sub-vector sequence... A value of 1 indicates that the rows within the region are highly isomorphic and continuous in both logic and style. Row blocks meeting this condition are immediately identified and marked as dynamic repeating row regions. Conversely, for the first region (rows 0-4) and the third region (row 11 to the end), although they may consist of multiple rows, if the decision value between their internal rows is 0, or if they are continuous but belong to non-repeating content such as parallel form fields, the system will perform secondary qualitative analysis based on their relative position in the matrix. The algorithm follows the principle of contextual position priority: row blocks located before being marked as dynamic repeating row regions are uniformly classified as static header regions, used to carry basic form fields such as titles and customer information; while row blocks located after dynamic regions are marked as static footer regions, used to map total price calculations or approval signature fields. After completing the physical segmentation and attribute qualitative analysis of all row blocks, the layout region generation unit assigns a globally unique identifier (UUID) to each identified independent region and encapsulates it into a standardized layout object. This object records in detail the starting and ending row numbers of the region, the region type (Header / Body / Footer), and the physical coordinate range of the region in the original matrix. Finally, all encapsulated region objects are collected and stored in an ordered list, outputting a layout region set. This set not only clearly depicts the macroscopic layout structure of the quotation but also clarifies which parts are fixed backgrounds and which parts are the core business logic that requires dynamic iteration.

[0023] Specifically, in a feasible preferred embodiment, the region clustering analysis module 120 includes: a topological signature characterization unit, used to extract topological signatures and vectorize features for each row of the original cell matrix to obtain a row feature descriptor sequence; a decision isomorphism measurement unit, used to perform a dual-kernel fuzzy isomorphism measurement based on edit distance and Mahalanobis distance on adjacent rows in the row feature descriptor sequence to obtain isomorphic decision vectors reflecting logical breakpoints; and a layout region generation unit, used to perform region segmentation and type labeling determination on the isomorphic decision vectors and combine them with the original cell matrix to confirm boundaries to obtain a set of layout regions. In particular, since the implementation methods of the topological signature characterization unit and the layout region generation unit are the same as those described above, they will not be elaborated here. Only the implementation process of the decision isomorphism measurement unit will be described in detail below.

[0024] It should be understood that when extracting topological signatures and vectorizing features for each row of the original cell matrix to obtain the logical topological signature and combined style vector for each row, the logical topological signature is a formula skeleton after coordinate relativization, while the combined style vector is an aggregation of multi-dimensional visual features. If hard logic assertions are used when calculating the isomorphism determination index and filtering the continuity threshold for adjacent rows in the row feature descriptor sequence, for example, requiring... This type of Boolean logic may be vulnerable when handling industrial-grade data. For example, in the dynamic quote details area (rows 5 to 10) described in the above embodiment, if a user accidentally enters an extra space in a cell formula in row 7, or slightly adjusts the last digit of the RGB value of the background color in row 8, it may be determined that... Or the style doesn't match, causing the judgment index to be lower. =0, and thus, when segmenting regions based on this index, the originally continuous large region of 5-10 rows is incorrectly divided into two segments: 5-7 rows and 8-10 rows, compromising the integrity recognition of the dynamic array. Therefore, this application improves the robustness of the scheme by using a dual-kernel fuzzy isomorphism measure based on edit distance and Mahalanobis distance for adjacent rows in the row feature descriptor sequence. By introducing a more complex probability metric model, it no longer requires the formula strings to be completely equal, but instead calculates the edit distance ratio to allow for minor syntactic differences. At the same time, it no longer uses cosine similarity, which ignores feature correlation, but instead uses Mahalanobis distance and maps it to a probability interval. This allows the algorithm to resist unconscious noise operations by users, and as long as the rows are statistically highly similar, they are still identified as isomorphic.

[0025] Specifically, in one feasible solution, the decision isomorphism metric unit is used for: A similarity calculation based on Levenshtein edit distance is performed on the logical topological signatures of the i-th and (i+1)-th rows in the row feature descriptor sequence to obtain a soft metric for structural consistency between the i-th and (i+1)-th rows. This step is specifically implemented based on the following mathematical model: In this formula, This represents the structural consistency score between the i-th row and the next row, with a value range of [0,1]. and These represent the logical topological signature text of two adjacent lines respectively; This function calculates the minimum number of single-character edits (insertions, deletions, or replacements) required to convert between two strings. Indicates the length of the string; This is used for normalization to ensure the denominator is the maximum possible length. Taking lines 7 and 8 as examples, after preorder relativity, the standard signature of line 7 is... The signature is "MUL(Ref[-2],Ref[-1]), but line 8 has an extra space due to user error, so its signature is incorrect." It becomes "MUL(Ref[-2],Ref[-1])". At this point, the edit distance is 1 (only one space needs to be deleted), and the maximum string length is approximately 25. According to the formula, =1 - 1 / 25 = 0.96. This step, by calculating a ratio rather than absolute equality, effectively tolerates minor character differences caused by the parser or non-substantial differences in user input, thus preventing logical breaks due to format noise.

[0026] A Riemannian manifold measure of visual similarity is applied to the combined style vectors of rows i and i+1 to obtain the visual similarity probability between rows i and i+1. Unlike simple Euclidean distance, this step considers that visual features (such as RGB color channels) are often correlated rather than independent, and therefore uses the following Mahalanobis distance formula based on Gaussian radial basis functions (RBF): In the formula, Represents the probability of visual similarity; and A combined style vector for adjacent rows (e.g., containing R, G, and B components for font size and background color). The inverse covariance matrix of the style feature sample space is used to eliminate the interference of linear correlation between features, that is, the difference is measured by Mahalanobis distance. This is the transpose of the vector difference; This is the bandwidth parameter of the Gaussian kernel, used to control the rate at which similarity decays with distance (e.g., set to the average of the statistical variance). For example, if the background color of row 7 is pure white (255, 255, 255), while row 8 becomes extremely light gray (254, 254, 255) due to a misoperation or screen color picking error, although there is a numerical Euclidean distance, after calculation and mapping using Mahalanobis distance, because this difference is extremely small on the color manifold, the calculated similarity... It may still be as high as 0.99. In this way, the use of Riemannian manifold metric overcomes the problem of amplifying small mismatches in a single dimension, ensuring that slight visual jitter will not affect the judgment of overall isomorphism.

[0027] The system calculates the structural consistency soft metric and visual similarity probability between row i and row i+1 by applying a weighted geometric mean and logical judgment to obtain the i-th isomorphism decision index in the isomorphism decision vector. The system integrates these two dimensions of indicators by constructing a weighted geometric mean function, the calculation logic of which is as follows: ; In this formula, That is, the generalized isomorphism confidence of the i-th row; It is a sensitivity index of structural similarity, set based on specific industrial scenarios, such as taking... =2, used to increase the penalty for structural differences; and These correspond to the structural consistency score and visual similarity probability between the i-th row and the (i+1)-th row calculated in the previous steps, respectively. This is the i-th isomorphic decision index in the final generated isomorphic decision vector; This is an adaptive decision threshold dynamically calculated by the algorithm based on the overall data distribution, such as 0.85. The use of a product-based geometric mean is intended to conform to the principle of the weakest link, meaning that as long as the structure... or visual The similarity in any one dimension is extremely low, resulting in a low overall confidence level. This value quickly approaches 0, thus avoiding the risk of misjudgment where the formula is completely flawed but the judgment is passed solely based on color similarity. Next, the system uses this threshold to perform binary judgment on the confidence level. When greater than or equal to this threshold, A value of 1 indicates that adjacent rows are isomorphic; otherwise, it is 0. Taking rows 7 and 8, which are subject to noise interference in an application scenario, as an example, although there are minor structural differences due to extra spaces and visual differences due to RGB fine-tuning, both maintain a high softness value above 0.9 in their respective dimensions. After weighted geometric averaging... The value is still greater than the preset adaptive threshold of 0.85, thus determining that the two rows are isomorphic and marking the isomorphic decision vector as 1. This decision directly corrects the false breakage judgment under hard logic, ensuring that the algorithm can correctly identify the complete dynamic repeating region extending from row 5 to row 10 without being truncated by intermediate noisy data. Through this preferred implementation method that introduces fuzzy logic and probability measurement, the generated isomorphic decision vector with high noise resistance lays a precise data foundation for subsequent layout analysis and logical abstraction. It fundamentally eliminates the risk of logical chain breakage caused by data noise, ensuring that when formulating dynamic region segmentation strategies in subsequent steps, rows that are physically continuous but have minor syntactic or visual perturbations can be accurately aggregated into the same dynamic repeating row region.

[0028] Specifically, the coordinate field mapping module 130 is used to extract header text and perform natural language cleaning on the original cell matrix based on the layout region set to obtain a coordinate field mapping dictionary. It should be understood that although the previous steps successfully deconstructed the quotation's layout structure into static and dynamic repeating row regions through region clustering analysis, this only solved the problem of where the data boundaries are, not the semantic problem of what the data represents. In the underlying original cell matrix, business data still depends on abstract physical coordinates, such as row 5, column 3. The low-code engine's operating logic is based on an object model, requiring explicit field names such as unit price or quantity to drive business processes. If a mapping relationship between physical column indexes and natural language headers cannot be established, the subsequent formula parsing module will be unable to transform the coordinate-dependent calculation logic into attribute-dependent business rules. Therefore, extracting header text from the original cell matrix and performing natural language cleaning can retrieve the lost business semantic context from the layout through intelligent spatial search methods, translating the cold grid coordinates into business field names that can be understood by the system, thereby obtaining a coordinate field mapping dictionary and building a key semantic index for realizing the generalization transformation of logic.

[0029] Specifically, in one feasible solution, the coordinate field mapping module 130 includes: an original header text extraction unit 131, used to locate dynamically repeating row regions using a layout region set, and to perform anchoring search in the original cell matrix using a non-empty nearest neighbor backtracking algorithm to extract the original header text sequence; an original header text normalization unit 132, used to perform illegal character removal, deduplication, and standardized transcribing on the original header text sequence based on a regular expression engine and business naming conventions to generate a normalized field name sequence; and a total binding construction unit 133, used to construct a total binding between the normalized field name sequence and the physical column coordinates of the original cell matrix through column index association logic to output a coordinate field mapping dictionary.

[0030] The implementation is as follows: The original header text extraction unit 131 initiates a traversal and filtering process on the layout area set to accurately pinpoint the definition source of the business fields. Static header and footer objects are filtered out, and the target objects specifically targeted are those marked as dynamic repeating row areas. In the previous embodiment, the system identified rows 5 to 10 as the dynamic quotation details area, so this unit extracts the starting row number of this area as 5 as the baseline anchor point. Considering that in users' actual Excel template drawing habits, the header text may not be adjacent to the data rows, and there may be blank lines or white space for aesthetic purposes, this unit does not simply read the starting row number - 1. Instead, it sets a flexible backtracking search range, which is set from the starting row number - 1 to the starting row number - k, where k is a preset backtracking depth, for example, a value of 3, i.e., searching rows 4 to 2, aiming to cover most common header layout patterns. After establishing the search range, the execution logic enters the core non-empty nearest neighbor backtracking algorithm stage. This unit traverses each column of physical index belonging to the dynamic area in the original cell matrix along the horizontal direction. Taking column j as an example, if it is column 3 of a quotation (physical index 2), the algorithm starts from the row above the starting row (row 4) and probes upwards row by row. First, it checks the cell at coordinates (4,2) in the matrix to determine if it contains a non-empty text value. If the cell contains valid content such as the unit price, it is considered a match, the search for that column is immediately stopped, and the unit price is extracted as the original header of that column. If (4,2) is empty, such as if the user inserted an empty row for separation, the algorithm automatically backtracks to the next higher level, checking coordinates (3,2), and so on, until the preset backtracking depth (starting row number - 3) is reached. If no non-empty value is found in the entire search range, the column is marked as an anonymous column or automatically assigned a default index name such as Column_2. This process applies to each column covered by the dynamic area, i.e., from... arrive Execution can be parallel or serial. If the dynamic region spans physical column indices 0 to 4, corresponding to the serial number, product name, unit price, quantity, and total amount respectively, the algorithm can accurately capture the semantic description closest to the data through the above non-empty nearest neighbor backtracking, regardless of whether the header is neatly arranged in row 4, or the product name is in row 3 due to merged cells while the unit price is in row 4. Finally, all extracted text content is assembled into an ordered one-dimensional array according to its corresponding column index order, i.e., the original header text sequence. This sequence directly reflects the original definition of each column data in the Excel template.

[0031] In its implementation, the original header text normalization unit 132 first takes over the original header text sequence output by the previous unit. This sequence may contain elements with noise and potential conflicts, such as ["Serial Number", "Product Name\n(Required)", "Unit Price (Yuan)", "Quantity", "Amount", "Amount"]. To convert these unstructured strings into system-recognizable variable names, this unit initiates a cleaning process based on a regular expression engine. The engine loads a preset set of character filtering rules and scans each text element in the sequence character by character. First, it uses regular expressions (e.g., \([^)]*\)|([^)]*)) to identify and remove all parentheses and their internal remarks, cleaning the product name (required) to the product name and the unit price (Yuan) to the unit price. Next, it executes special character removal logic, using regular expression matching patterns to remove newline characters \n, spaces, and all symbols except Chinese characters, English letters, and Arabic numerals, ensuring the purity of the basic text. After initial text cleaning, the processing logic enters the stage of transcribing natural language into programming code. At this point, the unit calls the built-in business dictionary. This business dictionary is a semantic mapping knowledge graph pre-installed in the system backend or cloud, its architecture consisting of a standard term index layer and a mapping rule layer. It can be obtained through importing industry-standard terms or by mining and training historical price list data based on machine learning algorithms. The dictionary stores a massive amount of key-value pairs between industry terms and their corresponding standard English variable names. The calculation unit traverses the cleaned text. Taking product names as an example, it performs a key value search in the dictionary, matching the corresponding value as ProductName; for unit price, it matches UnitPrice; for quantity, it matches Quantity. If it encounters uncommon words not included in the dictionary, the system uses a fallback strategy, that is, using a pinyin conversion engine or online translation interface to convert them into corresponding English words and enforce camelCase naming conversion, that is, capitalizing the first letter of the word and concatenating them, such as converting total amount to TotalAmount. Next, the unit executes the crucial deduplication logic. In programming standards, the attribute names of the same object must be unique. The system maintains a set of occupied field names in memory. When processing the first amount in the sequence, the dictionary translates it as "Amount." A search reveals that this name is not yet occupied, so it is added to the set and confirmed as the final field name. When processing the second amount in the sequence (which may be the after-tax amount, but not specified in the header), the translation result is still "Amount." At this point, the system detects a conflict and triggers the conflict resolution algorithm, appending an underscore and an incrementing numeric suffix to the base name, renaming it to "Amount_1."After full-sequence cleaning, translation, and deduplication, the original jumbled text was transformed into an ordered array ["Index","ProductName","UnitPrice","Quantity","Amount","Amount_1"] that strictly adheres to programming conventions. This output is the normalized field name sequence, which not only eliminates all syntax errors and naming conflicts but also achieves a precise semantic mapping from human natural language to machine object language.

[0032] In its specific implementation, the total binding construction unit 133 first receives the normalized field name sequence output by the original header text normalization unit, and the physical column index range of the dynamic repeating row region determined by the layout region generation unit. Based on the previous embodiment, the normalized field sequence is ["Index","ProductName","UnitPrice","Quantity","Amount","Amount_1"], and the corresponding physical column index range covers from column 0 (column A in Excel) to column 5 (column F in Excel). The unit first initializes a high-performance empty hash mapping structure in the memory heap, which is designed to store and retrieve key-value pairs in O(1) time complexity, serving as a container for the correspondence between the physical world and the semantic world. Then, the processing logic enters the core loop stage of formally constructing the mapping relationship. The unit starts an iterator from j=1 to N, where N represents the total number of columns in the dynamic region, N=6 in this example. In each iteration, the mapping generation function is executed to construct independent key-value association items. This construction process is based on the following mathematical logic formula: . In the formula, Represents the final generated coordinate field mapping dictionary; symbol This indicates that the set of key-value pairs generated from all columns is unioned, which means that the processing results of each column are accumulated into the complete dictionary. It is a key generation function used to convert physical column index j into a standardized coordinate key string, such as converting index 2 to Col_2 or directly using an integer index to represent the physical C column position in the Excel grid. This represents the value of the element with index j in the normalized field name sequence, which is the business attribute name corresponding to this column.

[0033] Let's take the physical indexes in columns 3 (j=2) and 4 (j=3) as examples for a specific explanation. When the iterator reaches j=2, the key generation function outputs physical key 2, extracts the second element "UnitPrice" from the sequence, constructs the key-value pair {"2":"UnitPrice"}, and injects it into the dictionary. When it reaches j=3, it outputs physical key 3, extracts the third element "Quantity" from the sequence, and constructs the key-value pair {"3":"Quantity"}. This process ensures that each physical column is uniquely identified by a semantic label through a holographic relationship. After the loop ends, the unit encapsulates the scattered key-value pairs into an immutable dictionary object, with contents in the form {"0":"Index","1":"ProductName","2":"UnitPrice","3":"Quantity","4":"Amount","5": "Amount_1"}. This output coordinate field mapping dictionary will be passed downstream as core metadata.

[0034] Specifically, the cell conversion and relation deconstruction module 140 is used to locate the formula cells in the original cell matrix based on the layout area set, and to perform generalized conversion and dependency deconstruction on the operands inside the formula in the formula cells from absolute physical coordinates to relative business fields using a coordinate field mapping dictionary to obtain an abstract logic graph. It is understandable that the calculation logic in spreadsheet software naturally relies on the absolute physical position of the Cartesian coordinate system; for example, the formula "=C5*D5" rigidly points to a specific cell in the grid. However, low-code web applications follow an object-oriented data model, and their business logic must be decoupled from specific view locations, manifested as semantic attribute operations such as "total price = unit price × quantity". If physical formulas are directly migrated, once dynamic row additions or deletions occur on the web side, the original coordinate references will immediately become invalid or point to incorrect data rows. Therefore, by using the cell transformation and relationship destructuring module to locate the formula cells in the original cell matrix based on the layout area set, and by using the coordinate field mapping dictionary to perform generalized transformation and dependency destructuring on the operands inside the formula in the formula cells from absolute physical coordinates to relative business fields, the rigid grid position calculation rules are "upgraded" into abstract business logic that is associated through semantic indexing. This ensures that the generated online application has adaptive calculation capabilities that are free from the limitations of the original Excel physical layout.

[0035] Specifically, Figure 3 This is a block diagram of the cell conversion and relationship destructuring module in a low-code-based quotation management system according to an embodiment of this application. Figure 3 As shown, in one feasible solution, the cell transformation and relation deconstruction module 140 includes: a formula descriptor generation unit 141, used to perform syntax tree parsing and reference type identification on formulas located within the layout area set in the original cell matrix to obtain an intermediate formula descriptor list; a text cleaning identifier generation unit 142, used to perform semantic text cleaning and field identifier generation on the intermediate formula descriptor list to obtain a generalized business logic object; and a circular dependency detection unit 143, used to perform circular dependency detection and computation link assembly on the generalized business logic object to obtain an abstract logic graph.

[0036] The implementation is as follows: To extract core calculation rules from massive amounts of grid data, the formula descriptor generation unit 141 first initiates a layout constraint-based filtering procedure. This unit traverses the entire original cell matrix, but only locks those cells falling within the boundaries of the dynamic repeating row area, such as rows 5 to 10 in the aforementioned embodiment. Within these specific areas, cell objects containing formula definitions in their attributes are further filtered out. Taking the total amount column in row 5, column 4 (physical coordinate E5) as an example, this unit extracts the original formula string stored within it, such as "=C5*D5". At this point, this string is just a normal text sequence, and the machine cannot yet understand its internal operation priority and dependencies. Subsequently, the processing logic calls the built-in high-precision formula parsing engine to perform structured processing on the extracted string. This parsing engine adopts a classic compiler front-end architecture, including a lexical analyzer and a syntax analyzer. First, the lexical analyzer performs a character stream scan on "=C5*D5", dividing it into the smallest semantic units such as "REF(C5)", "OP(MULTIPLY)", and "REF(D5)". Next, the parser uses a recursive descent algorithm or a shift-reduce algorithm, following the associative rules of mathematical operations, to construct an Abstract Syntax Tree (AST) from these tokens. In this tree, the root node represents the multiplication operator, while the left and right child nodes (leaf nodes) carry reference information for operands C5 and D5, respectively. The parsing engine traverses all leaf nodes of the AST, accurately identifying all node objects of type CellReference, thus transforming the flat text into a traversable topological structure. After parsing out the specific physical reference targets, this unit uses a pre-built coordinate field mapping dictionary to perform semantic attribute identification and type classification on these operands. For operands C5 and D5 extracted from the AST, the processing logic first reads their row index (both 5) and column indices (2 and 3 respectively). Then, the target row number is compared with the row number 5 of the current formula. Since they are equal, the system determines that the reference is an intra-row relative reference, meaning that this is a horizontal calculation for the same business data. Subsequently, the processing logic uses column indices 2 and 3 as keys to query the corresponding semantic values ​​in the coordinate field mapping dictionary, retrieving UnitPrice and Quantity respectively. If the formula contains references to areas outside the dynamic region, such as referencing a tax rate cell H1 outside the table header, the processing logic detects that the target row number (1) is not within the current dynamic region (5-10), so it marks it as a global absolute reference and retains its physical address or maps it to a global variable. After completing the above analysis, the unit encapsulates the AST structure of the formula, the semantic mapping relationship of the operands, such as Operand_1->UnitPrice, and the type marker (relative / absolute) of the reference into a standardized metadata object.This process executes all formulas in parallel within the dynamic region, and the resulting list of intermediate formula descriptors records in detail the data source and logical structure of each calculation rule, completely stripping away the original specific line number restrictions.

[0037] In its implementation, the text cleaning identifier generation unit 142 first receives an intermediate formula descriptor list and a coordinate field mapping dictionary. The intermediate formula descriptor list stores formula structures that have undergone preliminary syntax parsing, but their internal operand nodes still point to physical coordinates such as C5 and D5, lacking general business meaning. The processing logic initiates a deep traversal and reconstruction process for each descriptor object in the list. The core of this process lies in performing a decoordinate-free logical generalization transformation, i.e., replacing the physical index with semantic mapping relationships. For operand nodes marked as inline relative references in the descriptors, the unit first reads the original physical column index recorded by that node. Taking the scenario continued in the aforementioned embodiment as an example, if the current processing involves the total amount calculation formula for the 5th row of data, which includes operands pointing to column 2 (physical column C), the processing logic uses column index 2 as the key to search the coordinate field mapping dictionary. This dictionary is a mapping set generated using the business dictionary library in the previous steps. The business dictionary library itself is a pre-built knowledge graph containing industry terminology mapping relationships such as unit price, ensuring the standardization of search results. The retrieval returns the corresponding semantic field name, UnitPrice. At this point, the cell no longer retains the original C5 identifier, but instead constructs a new attribute access path string in the format Item.UnitPrice, where Item represents the current row data object instance. This transformation generalizes the physical second cell from the left to the logical unit price attribute of the current object. For globally absolute reference nodes that may exist in the formula, such as a tax rate cell H1 located outside the header area, the cell detects that this coordinate does not belong to the row range of the dynamically repeating area, and therefore will not look it up in the row-level mapping dictionary. Instead, it points the reference to a global parameter set, generating an identifier such as GlobalParams.TaxRate. Based on this, the cell applies a generalization transformation algorithm to construct a general logical expression recursively. Its core transformation logic follows the following formal formula: In this formula, This represents the final generated generalized logical expression. Represents a generalization transformation function; An abstract syntax tree structure for the original formula; This refers to a dictionary mapping coordinate fields. The summation symbol here represents a traversal and reorganization operation across all nodes in the syntax tree; The k-th operator (such as addition, subtraction, multiplication, and division) remains unchanged. This is the kth reference node. The function performs the core mapping operation, converting physical references into semantic field names. This is a Dirac decision function used to ensure that a reference is converted to a relative property within the Item scope only if the row number of the target is equal to the row number of the currently calculated row; otherwise, it is converted to a global reference. After the reconstruction of the computational chain described above, the original physical syntax tree is transformed into a completely new semantic syntax tree. For example, the original AST tree structure Multiply->[Node(C5),Node(D5)] is reconstructed into Multiply->[PropertyAccess(Item,UnitPrice),PropertyAccess(Item,Quantity)]. Finally, the text cleaning identifier generation unit encapsulates this reconstructed syntax tree and the derived text logic expressions, such as Item.Amount=Item.UnitPrice*Item.Quantity, into a generalized business logic object. This object completely eliminates the dependency on row 5 or column C, ensuring consistent application regardless of how many rows the data is instantiated into in the future, thus achieving standardized output of business logic.

[0038] The circular dependency detection unit 143 receives a set of generalized business logic objects. Although these objects have completed the semantic transformation from C5*D5 to Item.UnitPrice*Item.Quantity, in their current state, they are merely discrete and fragmented computational rules, lacking an overall execution order and linkage mechanism. To build an executable computational engine, this processing logic first initiates a topological analysis of all dependencies. Internally, the unit constructs a directed graph data structure G=(V,E) by parsing the input parameters and output targets in each generalized logic object. Here, the vertex set V represents all normalized business fields, such as UnitPrice, Quantity, Amount, and Total, while the directed edge set E represents the computational dependency flow between fields. If the calculation formula of field A references field B, a directed edge (B→A) is established in the graph from B to A, indicating the propagation direction of data change. After the mathematical model is constructed, the unit uses the Karn algorithm or the depth-first search (DFS) algorithm to perform topological sorting of graph G and its core circular dependency detection. The computation engine first counts the in-degree of all vertices in the graph, i.e., how many edges point to that node. Initially, nodes with an in-degree of 0 (user-input fields such as UnitPrice and Quantity, which do not depend on other fields for calculation) are pushed into a processing queue. The algorithm iteratively removes nodes from the queue, adds them to the final computation execution sequence, removes the node and all its emanating edges from the graph logic, and updates the in-degree of the remaining nodes. If, after the algorithm finishes execution, there are still nodes with a non-zero in-degree in the graph, it indicates a closed loop exists, i.e., a deadlock logic similar to A depending on B, B depending on C, and C depending on A has occurred. In this case, the unit triggers an exception blocking mechanism, based on a preset loop-breaking strategy, such as retaining the earliest defined formula, cutting off the last added dependency for automatic correction, or reporting an error to the user, ensuring the directed acyclic property (DAG) of the computation logic. After establishing the acyclic computation order, the unit enters the computation link assembly stage, aiming to solve the runtime problem of when to trigger computation. The processing logic traverses the topologically sorted node sequence, applying the observer pattern to attach computation triggering conditions to each non-leaf node. For the aforementioned Item.Amount node, the system recognizes its dependencies on Item.UnitPrice and Item.Quantity, and thus generates the corresponding event listener configuration: ON(Change:UnitPrice, OR Change:Quantity)->Trigger(Calc:Amount). This means that regardless of changes in unit price or quantity, the total amount will be automatically recalculated. Furthermore, if a Global.GrandTotal field depends on Item.Amount across all rows, the system will construct a cross-level aggregation trigger.Ultimately, all field nodes, dependency edges, topology execution sequences, and bound trigger conditions are serialized uniformly, outputting an abstract logic graph. This graph is no longer a simple set of formulas, but a complete business logic state machine with self-driving capabilities.

[0039] Specifically, the data component fusion module 150 is used to fuse the layout region set, coordinate field mapping dictionary, and abstract logic graph into a low-code model and view components to obtain an application architecture package containing full view configuration and logic definitions. Correspondingly, in the previous series of processing steps, although the calculation logic has successfully deconstructed the original Excel file into a layout region set with clear distinctions between static and dynamic elements, a coordinate field mapping dictionary that implements the conversion from physical coordinates to business semantics, and an abstract logic graph with automatic calculation capabilities, these results currently exist only in the form of discrete metadata. The abstract logic graph cannot be directly rendered by the browser, and the independent field dictionary cannot support user interaction. A complete low-code application not only requires a backend data model and calculation rules but also a frontend visual interface to support this logic. If these fragmented metadata are not reorganized and encapsulated according to Web standards, what is generated is merely a collection of description files rather than executable software. Therefore, by using the data component fusion module to integrate the layout area set, coordinate field mapping dictionary and abstract logic graph into a low-code model and view components, the layout, logic and data generated in the previous steps are organically assembled and compiled into an application architecture package containing full view configuration and logic definition through a standardized protocol, thereby producing a final application that can be directly loaded, rendered and interacted with by the front-end engine.

[0040] Specifically, Figure 4 This is a schematic diagram illustrating the data flow in a data component fusion module of a low-code-based quotation management system according to an embodiment of this application. Figure 4 As shown, in one feasible solution, the data component fusion module 150 includes: a page view description file generation unit 151, used to generate a page view description file based on the layout area set and the style information of the original cell matrix; a data type inference unit 152, used to define field attributes using a coordinate field mapping dictionary and infer data type through sampling analysis of the original cell matrix to obtain a data model definition file; and a data fusion binding unit 153, used to fuse the abstract logic graph into the data model definition file through a logic injection mechanism and to bind the data model definition file and the page view description file bidirectionally to obtain an application architecture package.

[0041] The implementation is as follows: The core task of the page view description file generation unit 151 is to accurately map the structure of Excel—not just the data structure, but also its visual presentation and interaction—to the DOM (Document Object Model) structure of the web frontend. The processing flow begins with a deep traversal of the layout area set, which is an ordered list containing area objects such as static header areas, dynamic repeating row areas, and static footer areas. When processing specific areas, this unit first executes component matching logic based on the area type attribute. The processing logic incorporates a UI component template library that defines all standard controls supported by the low-code platform and their applicable scenarios. When an object marked as a static header area is scanned, the algorithm automatically selects a FormContainer or GridLayout as the carrier, because this area carries discrete input items; while when a dynamic repeating row area is scanned, given its business manifestation as multiple rows of details that can be added and deleted, the algorithm maps it to a more complex DataGrid or SubTable component. This type-based automated mapping ensures that different sections in Excel have the correct interaction form in the web application. After establishing the container component, the process delves deeper into the microstructure provided by the original cell matrix to construct the component's internal child elements. Taking a dynamic area mapped to a DataGrid as an example, this unit traverses the physical index of each column covered by that area. Utilizing the style fingerprint information stored in the original cell matrix, a style translation operation is performed. Excel's style data is stored as specific binary codes or proprietary properties, such as `Interior.Color=16777215`, `ColumnWidth=15.5`. This unit uses its built-in CSS transformation engine to translate these properties one by one into standard Web Cascading Style Sheets (CSS) descriptions. For example, it converts Excel's column width to pixel values ​​(`width: 120px`), center alignment to `text-align: center`, and background color to the hexadecimal code `background-color: #FFFFFF`. This process not only preserves the data's display format but also highly replicates the original file's visual style. Subsequently, this unit enters the hierarchical structure assembly stage. It constructs a tree-like JSON object, i.e., the page view description file, defining the parent-child nesting relationships between components. The root node is defined as Page, which has three first-level child nodes: HeaderContainer, BodyDataGrid, and FooterContainer. Inside the BodyDataGrid node, a Columns array is further defined, where each element corresponds to a column and contains the CSS style configuration and display title generated in the previous step.For example, for the unit price column, the generated description fragment might contain {"component":"InputNumber","style":{"textAlign":"right","width":"100px"},"label":"Unit Price"}. Finally, after all areas have been traversed and styles have been injected, this unit serializes the complete DOM structure description and outputs the page view description file. This file, as the core of the view layer of the application architecture package, specifies in detail how the browser should draw every pixel and control, realizing the visual reconstruction from static tables to dynamic web pages.

[0042] The data type inference unit 152 first loads the coordinate field mapping dictionary and the original cell matrix generated in the previous steps. Since Excel cells are inherently loosely typed—meaning a cell can store both numbers and text—while the target web application's data model requires strict field type definitions, the unit first iterates through the mapping dictionary to extract all named, normalized business fields. Taking UnitPrice mapped to the physical 2nd column (column C) and Quantity mapped to the physical 3rd column (column D) in the aforementioned embodiment as examples, this unit needs to determine whether these two fields should be stored as integers, floating-point numbers, or strings in the database. To make an accurate determination, a statistical sampling analysis strategy is adopted. Based on the row range of the dynamically repeating row area in the layout area set, such as rows 5 to 10, this unit extracts a set of non-empty values ​​as a sample set from the corresponding columns of the original cell matrix. For example, for the UnitPrice column, the extracted sample values ​​are ["100.00","250.50","99.00",""]. ​​The cell then inputs the sample set into the built-in data type inference engine. This engine uses a probabilistic model based on a scoring mechanism for decision-making, and its scoring formula is defined as: .in The total number of samples, As an indicator function, when the sample value The system returns 1 if the parser successfully passes the parser for a specific type (e.g., Number, Date, Boolean) without loss; otherwise, it returns 0. The system calculates the matching score for each candidate type sequentially. For the sample in the UnitPrice field, the number parser successfully parsed all non-empty strings, therefore... The score is approximately 1.0; however, the date parser cannot recognize these formats, and the score approaches 0. Based on this, the engine determines the data type of the field to be Number. If a column contains mixed data (such as 100 yuan and 200), causing the number parsing score to be lower than the preset confidence threshold such as 0.9, the engine will trigger a degradation strategy, broadly defining it as a String type to ensure that data reading does not result in errors. After determining the basic type, the processing logic further performs metadata attribute extraction. For numeric types, the algorithm analyzes the distribution of decimal places in the samples and finds that the samples generally retain two decimal places. Therefore, the Precision attribute is set to 2, and the Format attribute is set to currency format. For date type determination, the engine has a built-in multi-pattern matching regular expression library. If patterns such as 2026 / 01 / 19 or 19-Jan-2026 appear in the sample set, and the date type score is... If the first field is selected, it is defined as a Date type, and its input mask is automatically derived. Additionally, this unit scans the first row of the sampling region and extracts the value at that position as the field's DefaultValue. For example, if the user enters 1 in the quantity field in the first row, the default value for the Quantity field is set to 1. Finally, after the analysis process for all fields is complete, the data type inference unit encapsulates each field's name, basic type (String / Number / Date / Boolean), format constraints, precision settings, and default value configuration into a standardized entity description object. These objects are then compiled into a data model definition file in JSON or XML format.

[0043] The data fusion and binding unit 153 first loads three core files generated by the preceding units in parallel: the page view description file (describing the UI structure), the data model definition file (describing entity attributes), and the abstract logic graph (describing calculation rules). To ensure that the abstract logic can truly drive specific business data, the logic translation and injection subroutine is initiated first. This program reads each node and its dependencies in the abstract logic graph and uses the built-in code generation engine to convert general logical expressions into specific execution scripts supported by the target low-code platform. Taking the aforementioned total amount calculation as an example, the graph stores structured data such as `Make(Multiply,Ref(Item.UnitPrice),Ref(Item.Quantity))`. The code generation engine translates this into JavaScript closure functions or Excel-like expression strings, such as `return row.UnitPrice * row.Quantity`, based on a preset syntax template. After translation, this unit performs the logic injection operation. It opens the data model definition file and locates the definition block of the `Amount` field. Originally, this field was only marked as type Number during the type inference step. Now, the fusion unit dynamically inserts a new key-value pair, such as computationRule or triggerEvent, into the attribute list and injects the generated script code into it. This process upgrades the static data definition into a smart model with dynamic responsiveness. Simultaneously, the unit handles cross-field linkage logic. If the logic graph defines checking the budget threshold when the total amount changes, this rule is injected into the onChange hook configuration of the Amount field. Next, the processing logic enters the crucial view-model two-way binding stage. In this stage, the unit needs to establish physical connections between the fields in the data model and the UI components in the page view. The unit traverses the component tree in the page view description file, looking up the corresponding field identifier for each input component (such as the column editor in a DataGrid). For example, for the InputNumber component that displays the unit price on the interface, the unit adds the v-model or bindingPath property to its configuration object and sets its value to Item.UnitPrice. This binding operation establishes a two-way communication channel: when the user enters a number on the interface, the view layer directly updates the attribute values ​​of the data model through this channel; conversely, when the logic engine calculates a new attribute value, this channel ensures that the UI is refreshed in real time, without the need to write additional DOM manipulation code. After completing all logic injection and view binding, the data fusion binding unit performs the final complete assembly. It packages the updated data model file, page view file, and accompanying style sheets and static resource files according to a specific directory structure.To prevent application packages from being tampered with during transmission or storage, this unit uses a hash algorithm to perform digital signature calculations on the entire file content. The calculation logic is formally represented as follows: ,in Represents a join operation. This is the system private key. The generated hash signature is written into the package's metadata manifest. Finally, the unit outputs an application architecture package containing full information about the model, view, and logic in ZIP or JSON Bundle format.

[0044] Specifically, the application architecture package verification and testing module 160 is used to load the application architecture package into the low-code runtime engine to perform data node orphanage verification and passability testing to obtain an online quotation template object that supports dynamic row expansion calculation. In other words, the application architecture package is essentially still a collection of static JSON configurations and script code, and has not yet been verified in a real runtime environment. In complex business scenario transitions, ghost dependencies often exist, where certain intermediate variables are referenced in calculation formulas, such as pre-tax subtotals, but data flow is broken in the view layer due to lack of component binding, ultimately leading to runtime crashes. Furthermore, low-code applications running in a multi-tenant environment in the cloud require namespace isolation initialization and just-in-time (JIT) compilation of logic scripts to achieve high-performance execution efficiency. Therefore, loading the application architecture package into the low-code runtime engine for data node isolation verification and passability testing is to eliminate potential logical breakpoints and structural defects through simulated operation and automated repair mechanisms before the application is actually delivered to end users. This also completes the construction and activation of the runtime environment, thereby obtaining an online quotation template object that supports dynamic row expansion calculation, ensuring the absolute stability and real-time response of the system when users are interacting frequently.

[0045] Specifically, in one feasible solution, the architecture package verification and testing module 160 includes: a deployable application package generation unit 161, used to perform dependency graph traversal and link break self-healing repair on the application architecture package to obtain a verified deployable application package; an initialization and compilation unit 162, used to upload the deployable application package to the cloud environment for namespace initialization and logic script just-in-time compilation to obtain an activated application instance link; and a link loading and output unit 163, used to parse and load the activated application instance link, and output an online quotation template object when the user interaction triggers dynamic line expansion.

[0046] The implementation is as follows: The deployable application package generation unit 161 first loads the application architecture package output by the data component fusion module from the storage medium and decompresses it in memory into three core data flow branches: data model definition, page view description, and abstract logic script. To comprehensively evaluate the coupling consistency among these three, a definition-reference graph containing all metadata is constructed, denoted as... In the diagram In, vertex set It contains all the atomic elements involved in the application, divided into three categories: model field node collections Such as Amount, collection of view component nodes Such as Input_Amount and logical operation node sets For example, Calc_Amount. Edge set. This represents the relationship between elements, including binding relationships (model). Views and references (models) (Logic). After construction, the core isolated node detection algorithm is launched to perform a depth-first traversal of the graph. This algorithm aims to identify nodes n that meet specific anomaly conditions, and its discrimination logic can be described by the following set operation formula: Formula Explanation: Filter out models belonging to the model set. And by logical set Referencing (i.e., participating in the calculation) the node, while also checking the relationship between that node and the view collection. The binding degree is determined by the number of nodes in the data layer. If the binding degree is 0, it means that the field exists in the data layer and participates in the calculation, but there is no corresponding component on the interface. Taking a specific quotation scenario as an example, if the logic graph contains the formula "Total price including tax = Total price before tax * (1 + tax rate)," where the total price before tax is an intermediate calculation result, although the field is defined in the model and the logic script depends on it to calculate the final result, the user may have hidden this column when drawing the Excel template, resulting in the absence of a corresponding display component in the view description file. In this case, the field is judged as an orphan node. If not handled, the runtime logic engine will report an error when calculating the total price including tax because it cannot obtain or update the state of the pre-tax subtotal from the view layer. After detecting such a risk of disconnection, the unit immediately triggers the disconnection self-healing mechanism. Based on the type of the orphan node (Number / String), it automatically generates an auxiliary calculation component with the attribute hidden="true", such as HiddenFieldWidget, and dynamically adds it to the schema structure of the page view description file. At the same time, it establishes the binding relationship between this hidden component and the model field of the total price before tax. After a full traversal and repair, the unit repackages the repaired metadata to generate a verified, deployable application package, which at this point has logical completeness and robustness.

[0047] The initialization compilation unit 162 receives the validated deployable application package and begins the instantiation and deployment process from the code package to the cloud instance. This unit first uploads the application package to the distributed object storage cluster on the cloud server via an encrypted channel. To achieve data isolation in a multi-tenant architecture, a globally unique application identifier is assigned to the application in the cloud database, and combined with the current user's tenant ID, an independent storage namespace is initialized. For example, the generated namespace might be Tenant_1024_App_505, and the corresponding underlying database table structure or document collection is automatically created under this space, ensuring that data from different users does not interfere with each other. Subsequently, the just-in-time compilation phase begins. Since the logic scripts in the application package mainly consist of general, text-based expressions, such as Row.Amount=Row.Price*Row.Quantity, while directly interpreting and executing these texts on the browser side is feasible, it is inefficient when processing large price lists with hundreds or thousands of lines. Therefore, the initialization compilation unit starts a high-performance compiler on the server side to pre-compile these generalized text expressions into highly optimized machine code or WebAssembly modules. During this process, the compiler also performs static analysis optimizations, such as constant folding. For example, if the tax rate is found to be a fixed value of 0.13, the multiplication instruction is directly optimized to x*1.13, eliminating the overhead of repeated variable lookups. Furthermore, this unit injects a global environment variable context, linking system-level variables such as current user information and server timestamps with the compiled logic code. After compilation and environment configuration are complete, the system generates an access endpoint (URL) pointing to the application's runtime. This link contains an encrypted session token and version fingerprint. Finally, this link is encapsulated as the output of an activated application instance, signifying that the application has completed all server-side preparations and is ready to be activated by the frontend.

[0048] The link loading output unit 163, acting as the user interaction terminal for the entire process, is responsible for loading the application instance from the cloud into the user's browser and endowing it with core dynamic extensibility capabilities. When the user clicks the link to access the activated application instance in the browser, the front-end runtime engine immediately starts. This engine does not directly download the entire HTML page, but first retrieves the application's schema (model and view description) and the compiled Logic Binary. Based on the DOM structure description in the schema, the front-end engine first uses Virtual DOM technology to build the interface tree in the browser's memory and renders the price table, which includes the header area, initial dynamic area, and footer area, all at once. At this point, what is presented to the user is an interactive web application, but its core value lies in the handling of dynamically repeating rows. When the user clicks the "Add Row" button on the interface, the event handler inside this unit is triggered. Traditional web development may require sending a request to the server to obtain the HTML fragment for the new row, but this unit adopts a client-side instantiation strategy. Using the data model definition file generated in the preceding steps, the processing logic directly instantiates a new data object, NewRowData, in the browser's memory. The object automatically inherits all properties defined in the model (such as UnitPrice, Quantity, Amount) and their default values, such as 0. Next, the logic mounting step occurs. The processing logic calls the compiled generalized logic script, registering this new NewRowData object to the logic engine's observer list. Using previously generated generalized reference rules, such as Item.Amount=Item.Price*Item.Qty, the engine automatically attaches listeners to the new object's properties. This means that although this newly generated row has just been created, it already possesses complete computational intelligence—when the user enters a value in the unit price cell of the new row, the onChange event is triggered instantly. The logic engine does not need to communicate with the server; it directly executes the compiled calculation instructions locally, updating the amount field and the total field at the bottom of the row in milliseconds. Finally, the linked loading output unit encapsulates this complete runtime state, including the page rendering engine, the two-way data binding model, the pre-compiled calculation logic, and the dynamic row factory methods, into an online quotation template object. The object is no longer a static file, but an intelligent software entity that can infinitely self-replicate and evolve within the browser session, completely realizing the leap from Excel spreadsheets to modern SaaS forms with native application experience.

[0049] In summary, a low-code-based quotation management system 100 based on embodiments of this application is described, aiming to solve the semantic distortion problem when migrating from physical coordinate logic to object-oriented business logic. First, the input quotation data stream undergoes structured preprocessing, and regional clustering analysis technology is used to intelligently identify layout areas that distinguish between static displays and dynamically repeating rows, thereby accurately defining the iteration range of business data. Based on this, by establishing a field mapping relationship between physical coordinates and natural language table headers, and then employing cell transformation and relational deconstruction mechanisms, the absolute coordinate formulas tightly coupled to grid positions in Excel are automatically generalized into abstract logical graphs pointing to relative business fields, effectively breaking down the data addressing paradigm barrier between the Cartesian coordinate system and the Web object model. Finally, the identified view configuration and deconstructed business logic are deeply integrated to generate an application architecture package, which is then validated and tested. This processing method enables automated migration of local quotation documents to the online system without manual formula rewriting, ensuring the adaptability and correctness of the calculation logic of the online quotation template in dynamic row expansion scenarios.< / v> < / v> < / v> < / c> < / c> < / row>

Claims

1. A low-code-based quotation management system, characterized in that, include: The quotation data stream preprocessing module is used to perform raw data structuring and atomic object extraction on the binary data stream of the quotation to obtain a raw cell matrix containing physical coordinate attributes and style fingerprint features; The region clustering analysis module is used to perform region clustering analysis based on isomorphic features on the original cell matrix to identify the set of layout regions that distinguish between static regions and dynamic repeating row regions. The coordinate field mapping module is used to extract the header text and perform natural language cleaning on the original cell matrix based on the layout region set to obtain the coordinate field mapping dictionary; The cell conversion and relation deconstruction module is used to locate the formula cells in the original cell matrix based on the layout area set, and to use the coordinate field mapping dictionary to perform generalized conversion and dependency deconstruction on the operands inside the formula in the formula cell from absolute physical coordinates to relative business fields to obtain an abstract logic graph. The data component fusion module is used to fuse the layout area set, coordinate field mapping dictionary and abstract logic graph with low-code model and view components to obtain an application architecture package containing full view configuration and logic definition; The architecture package verification and testing module is used to load the application architecture package into the low-code runtime engine to perform data node orphanage verification and pass / fail tests to obtain an online quotation template object that supports dynamic row expansion calculation.

2. The low-code-based quotation management system according to claim 1, characterized in that, The quotation data stream preprocessing module includes: The data stream filtering and extraction unit is used to unpack, filter, and extract the structured data from the binary data stream of the quotation sheet to obtain a sparse cell dataset containing valid coordinates and original values. The multidimensional attribute dimensionality reduction feature calculation unit is used to perform multidimensional attribute dimensionality reduction and feature instantiation calculation on elements in the sparse cell dataset to obtain a feature-enhanced cell list injected with style fingerprint feature values. The enhanced cell mapping redundancy processing unit is used to perform spatial mapping and redundancy removal processing on the feature-enhanced cell list to obtain the original cell matrix.

3. The low-code-based quotation management system according to claim 1, characterized in that, The region clustering analysis module includes: The topological signature feature unit is used to extract the topological signature and vectorize the features of each row of the original cell matrix to obtain a row feature descriptor sequence. The isomorphic decision generation unit is used to calculate the isomorphism determination index and filter the continuity threshold for adjacent rows in the row feature descriptor sequence to obtain the isomorphic decision vector that reflects the logical breakpoint. The layout region generation unit is used to perform region segmentation and type labeling on the isomorphic decision vector and combine it with the original cell matrix to confirm the boundary to obtain the layout region set.

4. The low-code-based quotation management system according to claim 1, characterized in that, The region clustering analysis module includes: The topological signature feature unit is used to extract the topological signature and vectorize the features of each row of the original cell matrix to obtain a row feature descriptor sequence. The decision isomorphism measurement unit is used to perform a dual-kernel fuzzy isomorphism measurement based on edit distance and Mahalanobis distance on adjacent rows in the row feature descriptor sequence to obtain isomorphic decision vectors that reflect logical breakpoints; The layout region generation unit is used to perform region segmentation and type labeling on the isomorphic decision vector and combine it with the original cell matrix to confirm the boundary to obtain the layout region set.

5. The low-code-based quotation management system according to claim 4, characterized in that, The decision isomorphism metric unit is used for: The similarity between the logical topological signatures of the i-th row and the (i+1)-th row in the row feature descriptor sequence is calculated based on Levenshtein edit distance to obtain a soft metric value for structural consistency between the i-th row and the (i+1)-th row. Perform a Riemann manifold measure of visual consistency on the combined style vectors of the i-th row and the (i+1)-th row to obtain the visual similarity probability between the i-th row and the (i+1)-th row. We perform a weighted geometric average and logical judgment on the structural consistency soft value and visual similarity probability between the i-th row and the (i+1)-th row to obtain the i-th isomorphic decision index in the isomorphic decision vector.

6. The low-code-based quotation management system according to claim 1, characterized in that, The coordinate field mapping module includes: The original header text extraction unit is used to locate the dynamically repeating row area using the layout area set, and to perform anchor search in the original cell matrix through a non-empty nearest neighbor backtracking algorithm to extract the original header text sequence. The original header text normalization unit is used to remove illegal characters, deduplicate, and standardize the original header text sequence based on the regular expression engine and business naming conventions to generate a normalized field name sequence. The total binding construction unit is used to construct a total binding between the normalized field name sequence and the physical column coordinates of the original cell matrix through column index association logic, so as to output a coordinate field mapping dictionary.

7. The low-code-based quotation management system according to claim 1, characterized in that, The cell conversion and relation deconstruction module includes: The formula descriptor generation unit is used to perform syntax tree parsing and reference type identification on formulas located within the layout area set in the original cell matrix to obtain an intermediate formula descriptor list; The text cleaning identifier generation unit is used to perform semantic text cleaning and field identifier generation on the intermediate formula descriptor list to obtain a generalized business logic object. The circular dependency detection unit is used to perform circular dependency detection and computation link assembly on generalized business logic objects to obtain an abstract logic graph.

8. The low-code-based quotation management system according to claim 1, characterized in that, The data component fusion module includes: The page view description file generation unit is used to generate a page view description file based on the style information of the layout area set and the original cell matrix; The data type inference unit is used to define field attributes using a coordinate field mapping dictionary and to infer data type from the original cell matrix to obtain the data model definition file. The data fusion binding unit is used to fuse the abstract logic graph into the data model definition file through the logic injection mechanism, and to bind the data model definition file and the page view description file in two directions to obtain the application architecture package.

9. The low-code-based quotation management system according to claim 1, characterized in that, The architecture package verification and testing module includes: The deployable application package generation unit is used to perform dependency graph traversal and self-healing of broken links in the application architecture package to obtain a verified deployable application package. The initialization compilation unit is used to upload the deployable application package to the cloud environment for namespace initialization and real-time compilation of logic scripts to obtain links to activated application instances. The link loading output unit is used to parse and load links of activated application instances and output online quotation template objects when user interaction triggers dynamic row expansion.

Images