An assembly level collaborative editing control method and system

Abstract

The application provides a component-level collaborative editing control method applied to a multi-user collaborative editing control system, the system comprising: a plurality of front-end engines and a back-end server. The front-end engine acquires user editing operation data and a back-end real-time version snapshot, performs component structure difference comparison, and generates a component operation list; component conflict determination is performed based on the operation list, and according to the conflict determination result, the editing operation data is combined according to a preset conflict resolution strategy to generate a processed version snapshot which is then sent to the back-end; and the back-end server stores and sends to each front-end engine. Compared with the prior art, the application reduces data transmission volume and back-end server load through front-end component-level difference comparison and a preset conflict resolution strategy in a lightweight architecture, without the need for frequent requests to the back-end server for conflict resolution and data combination, thereby significantly improving response speed and collaborative editing efficiency and providing better user experience for users. The system has the same beneficial effects.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of computer, in particular to a component-level collaborative editing control method and system. BACKGROUND

[0002] Low-code development platforms are being widely applied due to their high development efficiency and high visualization. In a low-code platform, users can quickly build a front-end page by dragging and dropping components, configuring components, and binding logic. As the application range of the platform continues to expand, the number of users is also growing. In the context of fast business iteration, the demand for multiple users or multiple devices to edit the same page simultaneously is increasingly common. Users want to support multiple members to add, modify, or delete components at different locations simultaneously, and maintain the consistency of page data, the smoothness of editing, and the accuracy of the final result during collaboration.

[0003] Existing solutions have a coarse-grained locking mechanism, which allows only one user to edit one component or page at the same time, and other users only read or queue. Locking the components of a low-code page (such as using Redis locks or database marker locks), and only when unlocked can it be edited by other users. This solution is low in cost but low in efficiency, and does not essentially support real-time collaboration by multiple users. Another solution is to implement it together with the front and back ends, where all editing operations are synchronized to the server and broadcast to other terminals, the front end listens to and broadcasts operations (non-saved content), and the back end maintains operation flow and version synchronization, using WebSocket communication for real-time transmission of changes. This solution can truly support real-time conflict-free editing by multiple users, but has high implementation costs, complex technical implementation, especially real-time merging of component structured JSON, and high performance requirements.

[0004] In view of this, it is a technical problem for those skilled in the art to provide a lightweight component-level collaborative editing control method and system suitable for low-code platform multi-user simultaneous editing with low transmission cost. SUMMARY

[0005] To solve the above technical problems, the purpose of the present application is to provide a component-level collaborative editing control method, in which each user corresponds to an independent front-end engine for simultaneous editing, and the component-level structured difference comparison is performed by the front-end engine, and then the editing operation is merged based on the component-level difference and transmitted to the back-end server according to the preset conflict resolution strategy. The present application reduces the amount of data transmission and the load of the back-end server through front-end component-level difference comparison and preset conflict resolution strategy, and does not need to frequently request the back-end server for conflict resolution and data merging, which significantly improves the response speed and collaborative editing efficiency, and brings better user experience to users

[0006] The application aims to provide an assembly-level collaborative editing control method;

[0007] The technical scheme provided by the application is as follows:

[0008] An assembly-level collaborative editing control method is applied to a multi-user collaborative editing control system, and the multi-user collaborative editing control system comprises a plurality of front-end engines and a back-end server.

[0009] Obtaining editing operation data of components submitted by a user;

[0010] Receiving a real-time version snapshot sent by the back-end server;

[0011] Differentially comparing each component of the real-time version snapshot with a component in the editing operation data to generate a component operation list;

[0012] Performing component conflict determination on the component operation list to obtain a conflict determination result;

[0013] According to the conflict determination result, performing processing on the real-time version snapshot and the editing operation data according to a preset conflict processing strategy to obtain a processed version snapshot;

[0014] Sending the processed version snapshot to the back-end server as a latest version snapshot, so that the back-end server sends the latest version snapshot to each front-end engine.

[0015] Preferably, according to the conflict determination result, performing processing on the real-time version snapshot and the editing operation data according to a preset conflict processing strategy to obtain a processed version snapshot comprises:

[0016] If the conflict determination result is that the components do not conflict, directly merging the real-time version snapshot and the editing operation data to obtain a directly merged version snapshot.

[0017] Preferably, according to the conflict determination result, performing processing on the real-time version snapshot and the editing operation data according to a preset conflict processing strategy to obtain a processed version snapshot further comprises:

[0018] If the conflict determination result is that the components conflict, merging the real-time version snapshot and the editing operation data according to a preset priority processing strategy to obtain a version snapshot merged based on the preset priority processing strategy.

[0019] Preferably, the preset priority processing strategy comprises a preset operation type priority rule and a current front-end engine editing priority rule, and if the conflict determination result is component conflict, the real-time version snapshot and the editing operation data are merged according to the preset priority processing strategy to obtain a version snapshot based on preset priority processing strategy merging, which comprises:

[0020] According to the preset operation type priority rule, it is determined whether each component in the component operation list contains multiple editing operation types of the same priority, and a determination result is obtained.

[0021] If the determination result is that multiple editing operation types of the same priority are not contained, the editing operation data and the real-time version snapshot are merged according to the preset operation type priority rule to obtain a version snapshot based on preset operation type priority rule merging.

[0022] If the determination result is that multiple editing operation types of the same priority are contained, the editing operation data and the real-time version snapshot are merged according to the current front-end engine editing priority rule to obtain a version snapshot based on current front-end engine editing priority rule merging.

[0023] Preferably, the preset operation type priority rule is specifically:

[0024] Component deletion operation>component editing operation>component addition operation.

[0025] Preferably, before the processed version snapshot is sent to the back-end server as a latest version snapshot, so that the back-end server sends the latest version snapshot to each front-end engine, the method further comprises:

[0026] Performing component structure consistency verification on the processed version snapshot.

[0027] If the component structure consistency verification is qualified, the processed version snapshot is taken as a version snapshot to be sent.

[0028] A second object of the application is to provide a component-level collaborative editing control system.

[0029] A component-level collaborative editing control system comprises a plurality of front-end engines and a back-end server.

[0030] The front-end engine is configured to obtain editing operation data of components submitted by a user, receive a real-time version snapshot sent by the back-end server, perform a difference comparison between each component of the real-time version snapshot and a component in the editing operation data, generate a component operation list, perform component conflict determination on the component operation list to obtain a conflict determination result, perform processing on the real-time version snapshot and the editing operation data according to a preset conflict processing strategy based on the conflict determination result, obtain a processed version snapshot, and send the processed version snapshot to the back-end server.

[0031] The back-end server is configured to receive the processed version snapshot sent by the front-end engine, store the processed version snapshot as a latest version snapshot, and send the latest version snapshot to each front-end engine.

[0032] Preferably, when performing the processing on the real-time version snapshot and the editing operation data according to the preset conflict processing strategy based on the conflict determination result to obtain the processed version snapshot, the front-end engine is specifically configured to:

[0033] If the conflict determination result is that the components do not conflict, the real-time version snapshot and the editing operation data are directly merged to obtain a directly merged version snapshot.

[0034] Preferably, when performing the processing on the real-time version snapshot and the editing operation data according to the preset conflict processing strategy based on the conflict determination result to obtain the processed version snapshot, the front-end engine is further configured to:

[0035] If the conflict determination result is that the components conflict, the real-time version snapshot and the editing operation data are merged according to a preset priority processing strategy to obtain a version snapshot merged based on the preset priority processing strategy.

[0036] Preferably, the front-end engine is further configured to:

[0037] perform structure consistency verification on the processed version snapshot;

[0038] If the structure consistency verification of the components is qualified, the processed version snapshot is taken as a version snapshot to be sent.

[0039] The application provides a component-level collaborative editing control method applied to a multi-user collaborative editing control system, and the system comprises a plurality of front-end engines and a back-end server. The front-end engine acquires user editing operation data and a back-end real-time version snapshot, performs component structure difference comparison, and generates a component operation list; component conflict determination is performed based on the operation list, and according to the conflict determination result, the editing operation data is merged according to a preset conflict resolution strategy to generate a processed version snapshot which is then sent to the back-end, and the back-end server stores and sends to each front-end engine. Compared with the prior art, the front-end component-level difference comparison and the preset conflict resolution strategy are used to reduce the data transmission amount and the back-end server load in a light-weight architecture, and frequent requests for the back-end server for conflict resolution and data merging are not needed, so that the response speed and the collaborative editing efficiency are significantly improved, and better user experience is brought to users.

[0040] The application also provides a component-level collaborative editing control system. Since the system and the component-level collaborative editing control method solve the same technical problem and belong to the same technical concept, the system should have the same beneficial effects as the component-level collaborative editing control method, and thus will not be described here. BRIEF DESCRIPTION OF DRAWINGS

[0041] In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the drawings needed in the embodiments or the prior art description will be briefly introduced as follows. Obviously, the drawings in the following description only represent some embodiments of the present application, and other drawings can be obtained by those skilled in the art without any creative effort.

[0042] Figure 1 A flowchart of a component-level collaborative editing control method in an embodiment of the present application;

[0043] Figure 2 A structural schematic diagram of a component-level collaborative editing control system in an embodiment of the present application. DETAILED DESCRIPTION

[0044] In order to enable those skilled in the art to better understand the technical solutions in the present application, the technical solutions in the embodiments of the present application will be clearly and completely described as follows. Obviously, the described embodiments only represent some of the embodiments of the present application, rather than all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without any creative effort fall within the scope of protection of the present application.

[0045] As shown in Figure 1 The application provides a component-level collaborative editing control method applied to a multi-user collaborative editing control system, and the system comprises a plurality of front-end engines and a back-end server. The front-end engine acquires user editing operation data and a back-end real-time version snapshot, performs component structure difference comparison, and generates a component operation list; component conflict determination is performed based on the operation list, and according to the conflict determination result, the editing operation data is merged according to a preset conflict resolution strategy to generate a processed version snapshot which is then sent to the back-end, and the back-end server stores and sends to each front-end engine. Compared with the prior art, the front-end component-level difference comparison and the preset conflict resolution strategy are used to reduce the data transmission amount and the back-end server load in a light-weight architecture, and frequent requests for the back-end server for conflict resolution and data merging are not needed, so that the response speed and the collaborative editing efficiency are significantly improved, and better user experience is brought to users.

[0046] S1, obtaining editing operation data of a component submitted by a user;

[0047] It should be noted that the component structure in the multi-user collaborative editing control system can be a tree structure, a table structure, a list structure, a card structure, etc.

[0048] As an implementation, the method can be applied in a multi-user collaborative editing scenario of a low-code platform / zero-code platform. In actual use, a page is composed of a component tree structure of multiple components, represented by a JSON hierarchical structure, which can nest container components and sub-components, and each node of the component tree is a component. Before step S1, when a user first enters the page, a real-time version snapshot of the page is obtained from a backend server as a historical version snapshot. The editing operation data in step S1 is a component tree snapshot formed after the user edits on the basis of the historical version snapshot of the component tree structure, which contains all change operations of the user on the current front-end engine that have not been submitted to the backend server. The editing operation of the component in step S1 includes an adding operation, a deleting operation, an editing operation, and a sorting operation.

[0049] S2, receiving a real-time version snapshot sent by a backend server;

[0050] It should be noted that the real-time version snapshot is the full version data of the latest page component tree stored in the current backend server, which can completely restore the page state.

[0051] S3, comparing each component of the real-time version snapshot with the components in the editing operation data to generate a component operation list;

[0052] In actual use, the difference comparison is performed in step S3, and the difference comparison result is saved in the form of a component operation list. The component operation list can specifically include an adding list, a deleting list, and an editing list.

[0053] As an implementation, the component operation list is saved in the form of a temporary operation list, each record of which only contains a unique identifier of a component (component ID) and necessary difference description, without full data storage.

[0054] As an implementation, taking the component tree structure as an example, the difference comparison of each component of the real-time version snapshot with the components in the editing operation data in step S3 is specifically a difference comparison of the component tree of the real-time version snapshot and the component tree structure of the editing operation data, which includes the following rules:

[0055] Special component difference comparison rules, corresponding special different comparison means are adopted for container switching components, carousel container components and ordinary container components, specifically: container switching components (Tab components): ignore the active state attribute and the running state subcomponent content in the container switching component, only the structural meta information of the container switching component is retained to participate in the difference comparison. Carousel container components (Banner components): ignore the current carousel index and the subcomponent content in the carousel container component, only the carousel item structural meta information is retained to participate in the comparison. Ordinary container components (Container components): ignore the subcomponent content of the ordinary container component, only the structural information of the container itself is retained to participate in the comparison.

[0056] Recursive traversal and deep difference detection rules, specifically: recursive processing of nested components using depth-first traversal to ensure that deep-level differences can be identified. In Tab components, Banner components, Container components and other container component types, recursively enter the sub-containers (tabs, banners, components) to perform structural comparison.

[0057] Parent-child relationship difference tracking rules, specifically: when detecting changes in subcomponent structure, recursively find and record all parent containers (Tab components, Banner components, Container components) through parentId to ensure that the state of the container component can also be correctly processed.

[0058] Difference classification identification rules, specifically including: added differences: component IDs that exist in the editing operation data but do not exist in the real-time version snapshot. deleted differences: component IDs that exist in the real-time version snapshot but are missing in the editing operation data. edited differences: differences in structural field values for the same component ID. sorting differences: changes in the position index of the same component ID within the parent container.

[0059] Repeated change cleaning rules, specifically: for component IDs that appear in both the added and deleted, edited and added, etc. operation sets, clean them according to the preset cleaning rules to eliminate redundant or contradictory operation records.

[0060] After processing by the above rules, the component operation list in S3 is obtained.

[0061] It should be noted that in actual application process, before the difference comparison in step S3, attribute filtering processing is also included. The attribute filtering processing is used to eliminate the non-structural attributes in the real-time version snapshot and the editing operation data, specifically: before the difference comparison, the temporary attributes generated dynamically by the low-code platform runtime which are irrelevant to the component structure are removed in advance to avoid misjudgment. After attribute filtering, only the structural key fields of the component are retained as the basis for difference identification, including: component unique identifier, component attribute, component type, child node, etc.

[0062] S4, component conflict judgment is performed on the component operation list to obtain a conflict judgment result;

[0063] It should be noted that in step S4, the component conflict judgment is performed on the component operation list, specifically:

[0064] The component operation list is used as a unit to judge whether there is an editing conflict, a sorting conflict and a combination operation conflict between the real-time version snapshot and the editing operation data. If one or more of the editing conflict, the sorting conflict and the combination operation conflict exist, the conflict judgment result is component conflict, otherwise the conflict judgment result is component non-conflict.

[0065] The editing conflict is specifically: the fields of the components in the component operation list are judged one by one in the real-time version snapshot and the editing operation data, if there is a field value difference, it is judged as an editing conflict;

[0066] The sorting conflict is specifically: the index positions of the components in the component operation list in the parent container are judged one by one in the real-time version snapshot and the editing operation data, if there is an index position difference, it is judged as a sorting conflict; if the positions are consistent, the sorting change record is removed.

[0067] The combination operation conflict is specifically: whether the components in the component operation list appear in the addition operation list and the deletion operation list at the same time, or appear in the addition operation list and the editing operation list at the same time is judged one by one, if the components appear in the above two component operation lists at the same time, it is judged as a combination operation conflict.

[0068] S5, according to the conflict judgment result, the real-time version snapshot and the editing operation data are processed according to the preset conflict processing strategy to obtain a processed version snapshot;

[0069] Preferably, according to the conflict judgment result, the real-time version snapshot and the editing operation data are processed according to the preset conflict processing strategy to obtain a processed version snapshot, including:

[0070] If the conflict judgment result is component non-conflict, the real-time version snapshot and the editing operation data are directly combined to obtain a directly combined version snapshot.

[0071] If the conflict determination result is component conflict, the real-time version snapshot is combined with the editing operation data according to a preset priority processing strategy to obtain a version snapshot combined based on the preset priority processing strategy.

[0072] It should be noted that in actual application, if the conflict determination result is component conflict, the version snapshot can also be combined according to manual confirmation to obtain a version snapshot combined by manual confirmation.

[0073] In actual application, the preset priority processing strategy is specifically: according to the operation type priority of the same component: the priority order of the operation types is as follows: delete operation > edit operation > sort operation > add operation; when there are multiple operations with the same priority for the same component, the editing operation data is combined according to the current front-end engine editing priority rule, that is, the editing operation priority corresponding to the current user is set as the highest priority for combination. In addition, the priority of the editing operation combination can also be combined by manual confirmation or set according to user permissions, and the operation data combination mode of the front-end engine of the present application is a flexible configuration mode.

[0074] Preferably, the preset priority processing strategy includes: a preset operation type priority rule and a current front-end engine editing priority rule, if the conflict determination result is component conflict, the real-time version snapshot is combined with the editing operation data according to the preset priority processing strategy to obtain a version snapshot combined based on the preset priority processing strategy, which includes:

[0075] According to the preset operation type priority rule, it is determined whether each component in the component operation list contains multiple editing operation types with the same priority, and a determination result is obtained;

[0076] If the determination result is that the component operation list does not contain multiple editing operation types with the same priority, the editing operation data is combined with the real-time version snapshot according to the preset operation type priority rule to obtain a version snapshot combined based on the preset operation type priority rule;

[0077] Preferably, the preset operation type priority rule is specifically:

[0078] Component delete operation > component edit operation > component add operation.

[0079] If the determination result is that the component operation list contains multiple editing operation types with the same priority, the editing operation data is combined with the real-time version snapshot according to the current front-end engine editing priority rule to obtain a version snapshot combined based on the current front-end engine editing priority rule.

[0080] In actual application process, the version snapshot processed in step S5 is the front-end version snapshot after the current user editing operation data is merged. Taking the component tree structure as an example, the front-end version snapshot structure generation rule includes:

[0081] A component insertion position rule, specifically: for a Container component, a nearest sibling component position in a components array is preferentially searched, and the component is inserted. If there is no sibling component, the component is inserted at the beginning of the components array. The same rule applies to a Tab component and a Banner component.

[0082] A sorting generation rule, specifically: a combined order is generated based on local sorting changes and server data; unchanged elements are retained, and relative positions are adjusted as needed; duplicates are removed to ensure list uniqueness and order correctness.

[0083] A structure-dependent sorting rule: in the same type of operation, a container component (parent node) is preferentially processed, and then its child components are processed, to avoid structure suspension.

[0084] A component identifier and parent-child relationship generation rule, specifically: a unique identifier is assigned to a newly added component; a correct parent-child relationship is established and maintained; and the component identifier of a nested component is recursively updated to a backend server to ensure global uniqueness and correct relationship.

[0085] Various sub-operation execution rules:

[0086] A component deletion operation execution rule, specifically: a deletion queue is traversed, and if a target component exists in a current component tree, a safe deletion is performed; if the target component has been deleted by another operation, the operation is skipped and marked as invalid.

[0087] An editing component operation execution rule, specifically: an editing queue is traversed, and if a component exists, affected fields of the component are replaced, and unchanged fields remain unchanged; if the component does not exist: a parent container exists, and the component is automatically inserted into an original position of the parent container; the parent container does not exist, and a container component is automatically created as a new parent node based on a real-time version snapshot.

[0088] A new component operation execution rule, specifically: a new component queue is traversed, and whether a target position is a root level or inside a container component is determined; a nearest sibling component position inside the container is preferentially searched and the component is inserted; if there is no sibling component, the component is inserted at the beginning of a root array; if the container does not exist, a container is automatically created based on a local snapshot and the component is inserted.

[0089] Preferably, before the processed version snapshot is sent to a backend server as a latest version snapshot, so that the backend server sends the latest version snapshot to each front-end engine, it further includes:

[0090] A component structure consistency check is performed on the processed version snapshot;

[0091] If the structural consistency check of the component is qualified, the processed version snapshot is taken as the version snapshot to be sent.

[0092] As an implementation, the structural consistency check of the processed version snapshot is taken as an example, which can specifically include:

[0093] The parent-child relationship legality check is specifically: checking whether the parent node identifier of all components points to an effectively existing parent node. For the detected isolated node (such as the parent component has been deleted), it is automatically removed or restored to the default parent container according to the rule.

[0094] The reference integrity check is specifically: checking whether all component attribute values such as data source references still exist and are available.

[0095] The structural integrity check of special components is specifically: the child node set of the container component should be complete and accessible.

[0096] If the structural consistency check is unqualified, data rollback is performed. The data rollback specifically includes:

[0097] Complete rollback: all editing operations of this submission are revoked, and the version snapshot before the operation is restored to ensure data consistency.

[0098] Partial rollback: the successfully executed sub-operations in the current editing operation are retained; the failed sub-operations are marked as “abnormal items”, which are highlighted or provided with error prompts in the interface; the user can manually repair (such as reselecting the container, adjusting the component attribute, etc.) and submit again based on the prompts.

[0099] S6, the processed version snapshot is sent to the backend server as the latest version snapshot, so that the backend server sends the latest version snapshot to each front-end engine.

[0100] In actual application process, the backend server of the backend persistently stores the latest version snapshot into the database, and generates the corresponding version number or timestamp, which is used for subsequent version comparison and rollback. At the same time, the backend server returns the submission result and version information, and the front-end engine updates the front-end component tree structure according to the feedback result and the received latest version snapshot.

[0101] In actual application process, the front-end engine is also used for performing secondary difference comparison, secondary conflict determination and secondary conflict processing operation. The secondary difference comparison is specifically as follows: when the front-end engine of user A submits the processed version snapshot A to the back-end server, the real-time version snapshot B of the back-end server is acquired again and compared with the real-time version snapshot O acquired before the conflict processing operation of user A, if the version snapshot B is inconsistent with the version snapshot O, at this time, the processed version snapshot A submitted by user A and the version snapshot B exist difference.

[0102] The secondary conflict processing strategy includes:

[0103] After the processed version snapshot A submitted by user A and the version snapshot B perform difference comparison, the secondary conflict determination result is obtained, secondary merging is performed according to steps S4 and S5, the version snapshot after secondary conflict processing is obtained, or a pop-up window is prompted, and the version snapshot reserved by the user is confirmed as the version snapshot after secondary conflict processing, or the user performs manual merging, and the version snapshot obtained by manual merging is taken as the version snapshot after secondary conflict processing.

[0104] In actual application process, after the secondary conflict processing operation, before the version snapshot after secondary conflict processing is replaced as the latest version snapshot of the back-end server, the front-end engine still performs difference comparison and conflict processing operation between the version snapshot after secondary conflict processing and the real-time version snapshot of the back-end server, until the real-time version snapshot acquired by the version snapshot after conflict processing is consistent with the current version snapshot of the back-end server, the version snapshot after conflict processing is sent to the back-end server as the latest version snapshot.

[0105] The beneficial effects of the application are as follows:

[0106] The front-end engine realizes the core logic of multi-person editing, the architecture is light and convenient to deploy, the front-end independently processes the addition, editing and deletion logic, frequent requests to the back-end server are not needed, the response speed and user experience are improved. The system architecture is decoupled, the back-end server only serves as a data persistent storage channel and does not bear real-time collaboration logic, the system complexity is reduced. Different user operations on different components can take effect, different users on the same component take the latest submitted user editing operation data content as the standard, and the data consistency and reliability are guaranteed.

[0107] Compared with the prior art, the front-end component level difference comparison and the preset conflict resolution strategy are used in the application, the data transmission amount and the load of the back-end server are reduced in the light architecture, frequent requests to the back-end server for conflict resolution and data merging are not needed, the response speed and collaborative editing efficiency are significantly improved, and better user experience is brought to the user.

[0108] In order to facilitate understanding of the specific process of the scheme, the following is an example of two specific application scenarios of the application.

[0109] Scenario 1: Two users edit different components simultaneously (no conflict)

[0110] 1) User A's specific input (uncommitted stage)

[0111] User A

[0112] 1. Edit: Modify the URL of single-image component Id=37562cf530344970b8fc89abf362acf9 to newA.png

[0113] 2. Add: Add a rich text component at the end of container component Id=447d654ba6b64029be9d71187b7e49eb

[0114] User B

[0115] 1. Edit: Modify the text field of rich text component Id=7686bdfafef24fd4b29ebc7ff16953fc to "" Welcome "

[0116] 2. Delete: Delete root layer placeholder blank component Id=2668

[0117] 2) How does the front-end engine collect / classify / process

[0118] Front-end engine:

[0119] 1. Initialization: Initialize real-time version snapshot History=Vn (from backend server), Current_A=Vn, Current_B=Vn

[0120] 2. User A's local operations apply to Current_A; User B's local operations apply to Current_B

[0121] Based on the difference comparison between History and Current_*, get the component operation list

[0122] User A

[0123] Add list addList: ["A_new_1"]

[0124] Edit list editList: ["37562cf530344970b8fc89abf362acf9"]

[0125] Delete list delList: []

[0126] 2. User B

[0127] addList: []

[0128] editList: ["7686bdfafef24fd4b29ebc7ff16953fc"]

[0129] delList: ["2668"]

[0130] 3) Submit and Merge

[0131] a. User A submits

[0132] 1. Frontend engine pulls real-time version snapshot Vs

[0133] 2. Change detection: Calculate difference component operation list A' based on (History vs Current_A)

[0134] 3. Conflict handling: Check conflicts based on component ID + field difference (A changes single image, B changes rich text and deletes placeholder, non-overlapping fields), no conflicts

[0135] 4. Frontend engine execution (delete operation -> edit operation -> add operation)

[0136] (1) Delete: empty

[0137] (2) Edit: Update single image 37562cf5... url = newA.png

[0138] (3) Add: Insert A_new_1 inside container 447d654b...

[0139] (4) Send the processed complete snapshot to the backend server, and the backend service stores it as the latest version snapshot Vs+1

[0140] (5) User A frontend engine update: History = Vs+1, Current_A = Vs+1

[0141] b. B submits (later than A)

[0142] 1. Frontend engine pulls real-time version snapshot Vs+1

[0143] 2. Change detection: Calculate difference component operation list B' based on (History vs Current_B)

[0144] 3. Conflict handling: Check conflicts based on component ID + field difference (B's edit target 7686bd... is different from A's changed field; 2668 still exists), no conflicts

[0145] 4. Front-end engine performs (delete operation -> edit operation -> add operation)

[0146] (1) Delete: delete 2668

[0147] (2) Edit: update the text field of rich text 7686bd... = " Welcome "

[0148] (3) Add: empty

[0149] 4) Final merge result

[0150] a. Single image (37562cf5...) url = newA.png (A takes effect)

[0151] b. Container (447d654b...) adds child A_new_1 (A takes effect)

[0152] c. Rich text (7686bd...) text field = " Welcome " (B takes effect)

[0153] d. Placeholder blank (2668) is deleted (B takes effect)

[0154] e. No conflict, both users' modifications are retained, and the processed complete snapshot is sent to the back-end server, which stores the latest version snapshot Vs+2; the back-end server stores Vs, Vs+1, and Vs+2 three version snapshots.

[0155] Scenario two: two users edit the same component at the same time (field conflict)

[0156] 1) Specific input of user operation (front-end unsubmitted stage)

[0157] User A: edit the url of single image component Id=37562cf530344970b8fc89abf362acf9 =

[0158] "newA.png"

[0159] User B: edit the url of the same component Id=37562cf530344970b8fc89abf362acf9 =

[0160] "newB.png"

[0161] 2) Front-end engine collection / classification

[0162] 1. User A

[0163] addList:[]

[0164] editList: ["37562cf530344970b8fc89abf362acf9"]

[0165] delList:[]

[0166] 2、User B

[0167] addList:[]

[0168] editList: ["37562cf530344970b8fc89abf362acf9"]

[0169] delList:[]

[0170] 3) Submit and Conflict Handling

[0171] a. User A submits

[0172] 1, Pull the backend server real-time complete snapshot Vs

[0173] 2, Change detection: generate component operation list A' based on (History vs Current_A)

[0174] 3, Conflict handling: the component url in Vs is still the old value, A modifies the field to url, no one else has effective changes, no conflict

[0175] 4, Front-end engine executes edit operation: url = "newA.png"

[0176] 5, Send the processed complete snapshot to the backend server, and the backend service stores it as the latest version snapshot Vs+1

[0177] 6, State management module (A side) update: History = Vs+1, Current_A = Vs+1

[0178] b. User B submits (later than A)

[0179] 1, Pull the real-time version snapshot Vs+1

[0180] 2, Change detection: generate B' based on (History vs Current_B)

[0181] 3, Conflict handling (same component ID + same field):

[0182] Found field-level conflict: url has been changed to newA.png by A in Vs+1, B wants to change it to newB.png

[0183] Pre-set priority handling strategy:

[0184] a. Default: Current Frontend Engine Edit takes priority, take B's newB.png

[0185] b. Or manual confirmation (popup to choose to keep A or B's value)

[0186] 4. Frontend Engine performs edit: url = "newB.png"

[0187] 5. Send the processed complete snapshot to the backend server, and the backend service persists it as the complete snapshot Vs+2

[0188] 6. Frontend Engine update: History = Vs+2, Current = Vs+2

[0189] 4) Final merge result (field conflict has been resolved)

[0190] Single image (37562cf5…) final url = "newB.png"

[0191] Other components remain unchanged

[0192] User A's modification takes effect at Vs+1, but is overwritten by User B's modification at Vs+2

[0193] Send the processed complete snapshot to the backend server, and the backend service persists it as the latest version snapshot Vs+2; the backend server saves three version snapshots Vs, Vs+1, and Vs+2.

[0194] Scenario Three: Two users edit simultaneously, and User A transmits the frontend version snapshot to the backend server for storage, but the backend server's real-time version snapshot has been updated (concurrent submission conflict)

[0195] 1) User's specific input

[0196] • User A: Edit the url of single image component Id=37562cf530344970b8fc89abf362acf9

[0197] "newA.png"

[0198] • User B: After user A pulls the real-time version snapshot Vs (but before A transmits the front-end version snapshot to the back-end server storage), B's front-end version snapshot has updated the real-time version snapshot of the back-end server, and the back-end server real-time version snapshot becomes Vs+1, B's operation is to modify the text field of the rich text component Id=7686bdfafef24fd4b29ebc7ff16953fc to " welcome ".

[0199] 5) Front-end engine collects / classifies (operation list only stores ID)

[0200] 1. User A (based on History=Vn):

[0201] addList: []

[0202] editList: ["37562cf530344970b8fc89abf362acf9"]

[0203] delList: []

[0204] 2. User B (based on History=Vn):

[0205] addList: []

[0206] editList: ["7686bdfafef24fd4b29ebc7ff16953fc"]

[0207] delList: []

[0208] 3) Submission process

[0209] 1. User A pulls the back-end server snapshot Vs.

[0210] 2. User A generates operation list A' based on (History vs Current_A) (i.e. update single image url).

[0211] 3. When user A applies A' to Vs and prepares to send to the back-end server, the front-end engine obtains the current real-time version snapshot of the back-end server, and finds that the current latest version is Vs+1 (B user operation Vs+1 has been sent to the back-end server), not Vs based on which A performs the difference comparison.

[0212] 4) Conflict determination

[0213] • The system finds that A's submission is based on an outdated snapshot (Vs), at which time the conflict handling operation is triggered:

[0214] • Target component of A (single image) still exists in Vs+1, and B only modified the rich text component

[0215] • Solution: System merges user A's modification based on Vs+1 again.

[0216] 5) Conflict handling and merge

[0217] 1. Server loads the latest snapshot Vs+1 first.

[0218] 2. Frontend engine merges A's modification with Vs+1:

[0219] • Rich text component (7686bd..) keeps B's modification = " Welcome "

[0220] • Single image component (37562cf5..) updates url = "newA.png"

[0221] 3. Merge result generates a new snapshot Vs+2.

[0222] 6) Final result

[0223] • Single image (37562cf5.) url = "newA.png" (A takes effect)

[0224] • Rich text (7686bd.) textHtmlStr = " Welcome " (B takes effect)

[0225] • Final server stored snapshot sequence: Vs (old) -> Vs+1 (B submission) -> Vs+2. Send the processed complete snapshot to the backend server, and the backend service is persisted as the latest version snapshot Vs+2; the backend server saves three version snapshots of Vs, Vs+1 and Vs+2.

[0226] The second object of the present application is to provide a component-level collaborative editing control system.

[0227] In one embodiment, as shown in Figure 2 , a component-level collaborative editing control system, comprising: a plurality of front-end engines and a back-end server;

[0228] The front-end engine is configured to obtain editing operation data of components submitted by a user, receive a real-time version snapshot sent by a back-end server, compare each component of the real-time version snapshot with a component in the editing operation data, generate a component operation list, perform component conflict determination on the component operation list to obtain a conflict determination result, perform processing on the real-time version snapshot and the editing operation data according to a preset conflict processing strategy based on the conflict determination result, obtain a processed version snapshot, and send the processed version snapshot to the back-end server.

[0229] The back-end server is configured to receive the processed version snapshot sent by the front-end engine, store the processed version snapshot as a latest version snapshot, and send the latest version snapshot to each front-end engine.

[0230] Preferably, when performing processing on the real-time version snapshot and the editing operation data according to the preset conflict processing strategy based on the conflict determination result to obtain the processed version snapshot, the front-end engine is specifically configured to:

[0231] If the conflict determination result is that the components do not conflict, the real-time version snapshot and the editing operation data are directly merged to obtain a directly merged version snapshot.

[0232] Preferably, when performing processing on the real-time version snapshot and the editing operation data according to the preset conflict processing strategy based on the conflict determination result to obtain the processed version snapshot, the front-end engine is further configured to:

[0233] If the conflict determination result is that the components conflict, the real-time version snapshot and the editing operation data are merged according to a preset priority processing strategy to obtain a version snapshot merged based on the preset priority processing strategy.

[0234] Preferably, the front-end engine is further configured to:

[0235] perform structure consistency verification on the processed version snapshot;

[0236] If the structure consistency verification of the components is qualified, the processed version snapshot is taken as a version snapshot to be sent.

[0237] For specific limitations of the component-level collaborative editing control system, refer to the limitations of the component-level collaborative editing control method in the foregoing, which will not be described here again. Each module in the component-level collaborative editing control system can be realized by software, hardware, or a combination thereof, in whole or in part. Each module can be embedded in or independent of a processor in a computer device in hardware form, or can be stored in a memory in a computer device in software form, so as to be called and executed by a processor to perform operations corresponding to each module.

[0238] In the embodiments of the present application, it should be understood that the disclosed method and system can be implemented in other manners. The above described system embodiments are merely schematic, for example, the division of the modules is only a logical function division, and there can be another division manner in actual implementation, for example, a plurality of modules or components can be combined or integrated into another system, or some features can be ignored or not executed. In addition, the coupling or direct coupling or communication connection between the above described components can be indirect coupling or communication connection through some interfaces, devices or modules, and can be electrical, mechanical or other forms.

[0239] In addition, each of the functional modules in each of the embodiments of the present application can be integrated in one processor, or each of the modules can be a separate device, or two or more modules can be integrated in one device; each of the functional modules in each of the embodiments of the present application can be realized in the form of hardware or in the form of hardware plus software functional units.

[0240] Those skilled in the art can understand that all or part of the steps of the above method embodiments can be completed by program instructions and related hardware, and the above program instructions can be stored in a computer readable storage medium, and the program instructions are executed to perform the steps of the above method embodiments; and the above storage medium includes mobile storage devices, read only memory (ROM), magnetic discs or optical discs and various storage media that can store program codes.

[0241] It should be understood that if "system", "device", "unit" and / or "module" are used in the present application, it is only a method for distinguishing different components, elements, parts, portions or assemblies at different levels. However, if other words can achieve the same purpose, the words can be replaced by other expressions.

[0242] As shown in the present application and claims, unless the context clearly indicates otherwise, "one", "a", "an" and / or "the" do not refer to the singular, but also include the plural. Generally, the terms "comprise" and "include" only indicate that the steps and elements explicitly identified are included, and these steps and elements do not constitute an exclusive list, and the method or device can also include other steps or elements. The element defined by the statement "comprising a" does not exclude the presence of another identical element in the process, method, product or device comprising the element.

[0243] Furthermore, the terms "first", "second", etc. are used herein only to describe one implementation, and do not imply either an actual temporal sequence or an order of importance, unless specifically stated otherwise. Thus, a feature defined with a "first" and a "second" can implicitly or explicitly include one or more of these features. The meaning of "a", "an", and "the" includes singular and plural referents unless the context clearly dictates otherwise.

[0244] If flow diagrams are used herein, the flow diagrams are used to illustrate the operations according to embodiments of the present application. It will be understood that each block of the flow diagram, and combinations of blocks in the flow diagram, can be implemented by various means, such as hardware, software, firmware, or any combination thereof. It will also be understood that each block of the flow diagram and / or combinations of blocks in the flow diagram can be implemented by an isolated article of manufacture that executes the operations specified in the block and / or combinations of blocks. Furthermore, it will be understood that each block of the flow diagram and / or combinations of blocks in the flow diagram can be implemented by various means including hardware, software, firmware, or any combination thereof.

[0245] The previous description of the disclosed embodiments is provided to enable any person skilled in the art to make or use the present application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein can be applied to other embodiments without departing from the spirit or scope of the application. Thus, the present application is not intended to be limited to the embodiments shown herein but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. An assembly-level collaborative editing control method, characterized by, The application is applied to a multi-user collaborative editing control system, and the multi-user collaborative editing control system comprises a plurality of front-end engines and a back-end server, and a method executed by each front-end engine comprises: obtaining editing operation data of components submitted by a user; receiving a real-time version snapshot sent by the back-end server; differentially comparing each component of the real-time version snapshot with a component in the editing operation data to generate a component operation list; performing component conflict determination on the component operation list to obtain a conflict determination result; according to the conflict determination result, performing processing on the real-time version snapshot and the editing operation data according to a preset conflict processing strategy to obtain a processed version snapshot; sending the processed version snapshot to the back-end server as a latest version snapshot, so that the back-end server sends the latest version snapshot to each front-end engine; the conflict determination result is that the components are not in conflict, and the real-time version snapshot and the editing operation data are directly merged to obtain a directly merged version snapshot; if the conflict determination result is that the components are in conflict, the real-time version snapshot and the editing operation data are merged according to a preset priority processing strategy to obtain a version snapshot merged based on the preset priority processing strategy; the preset priority processing strategy comprises a preset operation type priority rule and a current front-end engine editing priority rule; if the conflict determination result is that the components are in conflict, the real-time version snapshot and the editing operation data are merged according to the preset priority processing strategy to obtain a version snapshot merged based on the preset priority processing strategy, which comprises: determining whether each component in the component operation list contains a plurality of editing operation types of the same priority according to the preset operation type priority rule to obtain a determination result; if the determination result is that the plurality of editing operation types of the same priority are not contained, the editing operation data and the real-time version snapshot are merged according to the preset operation type priority rule to obtain a version snapshot merged based on the preset operation type priority rule; if the determination result is that the plurality of editing operation types of the same priority are contained, the editing operation data and the real-time version snapshot are merged according to the current front-end engine editing priority rule to obtain a version snapshot merged based on the current front-end engine editing priority rule. The preset operation type priority rule is specifically:

2. The component-level collaborative editing control method of claim 1, wherein, component deletion operation > component editing operation > component addition operation. Before the processed version snapshot is sent to the back-end server as a latest version snapshot, so that the back-end server sends the latest version snapshot to each front-end engine, the method further comprises:

3. The component-level collaborative editing control method of claim 1, wherein, performing structure consistency verification of components on the processed version snapshot; if the structure consistency verification of the components is qualified, the processed version snapshot is taken as a version snapshot to be sent. ​ 4. An assembly level collaborative editing control system, characterized by, ​ A plurality of front-end engines and a plurality of back-end servers; The front-end engine is configured to acquire editing operation data of components submitted by a user, receive a real-time version snapshot sent by the back-end server, perform a difference comparison between each component of the real-time version snapshot and a component in the editing operation data, generate a component operation list, perform component conflict determination on the component operation list to obtain a conflict determination result, perform processing on the real-time version snapshot and the editing operation data according to a preset conflict processing strategy based on the conflict determination result, obtain a processed version snapshot, and send the processed version snapshot to the back-end server. The back-end server is configured to receive the processed version snapshot sent by the front-end engine, store the processed version snapshot as a latest version snapshot, and send the latest version snapshot to each front-end engine. In the execution of the processing on the real-time version snapshot and the editing operation data according to the conflict determination result and the preset conflict processing strategy to obtain the processed version snapshot, the front-end engine is specifically configured to: If the conflict determination result is that the components do not conflict, directly merge the real-time version snapshot and the editing operation data to obtain a directly merged version snapshot. If the conflict determination result is that the components conflict, merge the real-time version snapshot and the editing operation data according to a preset priority processing strategy to obtain a version snapshot merged based on the preset priority processing strategy. The preset priority processing strategy includes a preset operation type priority rule and a current front-end engine editing priority rule. If the conflict determination result is that the components conflict, the real-time version snapshot and the editing operation data are merged according to the preset priority processing strategy to obtain a version snapshot merged based on the preset priority processing strategy, including: According to the preset operation type priority rule, determining whether each component in the component operation list contains a plurality of editing operation types of the same priority to obtain a determination result. If the determination result is that the plurality of editing operation types of the same priority are not contained, the editing operation data and the real-time version snapshot are merged according to the preset operation type priority rule to obtain a version snapshot merged based on the preset operation type priority rule. If the determination result is that the plurality of editing operation types of the same priority are contained, the editing operation data and the real-time version snapshot are merged according to the current front-end engine editing priority rule to obtain a version snapshot merged based on the current front-end engine editing priority rule.

5. The assembly-level co-authoring control system of claim 4, wherein, The front-end engine is further configured to: perform a structure consistency check on the processed version snapshot. If the structure consistency check on the component is qualified, the processed version snapshot is taken as a version snapshot to be sent.

Images