Code instance development method and device, development plug-in, equipment, medium and program product

Abstract

The invention provides a code instance development method which can be applied to the fields of computers and financial science and technology. The method comprises the steps that in response to a creation request for a code instance sent by a first development object, an interactive interface is called, so that the first development object screens a target template for creating the code instance in the interactive interface, and the creation request comprises a first object identifier of the first development object; generating a code instance name based on the first object identifier, the target template and a timestamp of the creation request; generating a local path for storing the code instance based on a root path matched with the target template and the code instance name in the code warehouse; and sending the local path to the first development object, so that the first development object develops a code instance based on the target template and the local path, and submits the code instance to a code repository. The invention further provides a code instance development device, a development plug-in, equipment, a storage medium and a program product.

Description

Technical Field

[0001] The present disclosure relates to the fields of computers and financial technology, and more specifically to a code instance development method, apparatus, development plug-in, device, medium, and program product. Background Art

[0002] In the field of software development, code examples are an important learning and communication tool. They provide a concrete, executable code snippet to show how to implement a specific technology or function in a real application.

[0003] In the process of implementing the embodiments of the present disclosure, it was found that in the process of developing code examples, developers selected a development template on a web page and downloaded it. Although the function of creating a template was realized, the function was relatively simple and the creation process was complicated, resulting in low development efficiency. Summary of the invention

[0004] In view of the above problems, the present disclosure provides a code instance development method, apparatus, development plug-in, device, medium and program product.

[0005] According to a first aspect of the present disclosure, a code instance development method is provided, comprising: in response to a creation request for a code instance sent by a first development object, calling an interactive interface so that the first development object can screen a target template for creating the code instance on the interactive interface, wherein the creation request includes a first object identifier of the first development object; generating a code instance name based on the first object identifier, the target template, and a timestamp of the creation request; generating a local path for storing the code instance based on a root path matching the target template in a code repository and the code instance name; and sending the local path to the first development object so that the first development object can develop the code instance based on the target template and the local path and submit it to the code repository.

[0006] According to an embodiment of the present disclosure, the code instance development method further includes: in response to a query request sent by a second development object, upon determining that the first development object is configured to configure a configuration file for jointly creating a code instance, obtaining a configuration file, wherein the query request includes a second object identifier of the second development object, and the configuration file includes the object identifiers of the jointly created objects; upon determining that the second object identifier exists in the object identifiers of the jointly created objects, obtaining a code instance from a code repository; and sending the code instance to the second development object so that the second development object re-develops the code instance.

[0007] According to an embodiment of the present disclosure, the code instance development method also includes: when it is determined that the second development object conflicts with the version of the code instance submitted to the code repository during the re-development of the code instance, a conflict warning is generated and the conflict warning is sent to the second development object; in response to a processing request for the conflict warning sent by the second development object, the re-developed code instance is merged with the code instance submitted to the code repository and stored in the code repository; or in response to a processing request for the conflict warning sent by the second development object, the re-developed code instance and the code instance submitted to the code repository are branched and stored in the code repository.

[0008] According to an embodiment of the present disclosure, in response to a creation request for a code instance sent by a first development object, an interactive interface is called so that the first development object can screen a target template for creating a code instance on the interactive interface, including: in response to the creation request for the code instance sent by the first development object, an interactive interface is called so that the first development object can screen a target template for creating a code instance on the interactive interface, including: in response to the creation request for the code instance sent by the first development object, a historical code instance associated with the first development object is obtained; based on the historical code instance and a preset condition, a template type for recommending to the first development object; and calling the interactive interface, and displaying multiple templates matching the template type on the interactive interface, so that the first development object can screen the target template on the interactive interface.

[0009] According to an embodiment of the present disclosure, a preset condition is used to indicate a trend in development technology; based on a historical code instance and the preset condition, a template type for recommendation to a first development object is determined, including: determining a technology stack of a historical template matching the historical code instance based on the historical code instance; and in a case where it is determined that the template type matching the technology stack satisfies the trend in development technology, determining the template type matching the technology stack as the template type for recommendation to the first development object.

[0010] According to an embodiment of the present disclosure, a local path for storing code instances is generated based on a root path and a code instance name that match a target template in a code repository, including: generating a local path for storing code instances based on a root path and a code instance name that match a target template in a code repository, including: determining the code instance name as a subpath of the root path; and generating a local path for storing code instances based on the root path and the subpath.

[0011] According to a second aspect of the present disclosure, a code instance development method is provided, comprising: sending a creation request to a server so that the server calls an interactive interface and generates a local path for storing the code instance, wherein the creation request includes a first object identifier of a first development object; screening a target template for creating the code instance in the interactive interface; receiving the local path sent by the server; and developing the code instance based on the target template and the local path, and submitting it to a code repository; wherein the local path is generated based on a root path in the code repository that matches the target template and a code instance name, and the code instance name is generated based on the first object identifier, the target template, and a timestamp of the creation request.

[0012] A third aspect of the present disclosure provides a code instance development device, including: a calling module, which is used to call an interactive interface in response to a creation request for a code instance sent by a first development object, so that the first development object can filter a target template for creating the code instance on the interactive interface, wherein the creation request includes a first object identifier of the first development object; a first generating module, which is used to generate a code instance name based on the first object identifier, the target template and the timestamp of the creation request; a second generating module, which is used to generate a local path for storing the code instance based on a root path matching the target template in a code repository and the code instance name; and a first sending module, which is used to send the local path to the first development object, so that the first development object can develop the code instance based on the target template and the local path, and submit it to the code repository.

[0013] A fourth aspect of the present disclosure provides a code instance development device, including: a second sending module, used to send a creation request to a server, so that the server calls an interactive interface and generates a local path for storing the code instance, wherein the creation request includes a first object identifier of a first development object; a screening module, used to screen a target template for creating a code instance in the interactive interface; a receiving module, used to receive a local path sent by the server; and a development module, used to develop the code instance based on the target template and the local path, and submit it to a code repository; wherein the local path is generated based on a root path matching the target template in the code repository and a code instance name, and the code instance name is generated based on the first object identifier, the target template, and the timestamp of the creation request.

[0014] A fifth aspect of the present disclosure provides a development plug-in for a code development tool, including a create control and a submit control; wherein the create control is used by a first development object to send a create request to a server so that the server calls an interactive interface and generates a local path for storing a code instance, wherein the create request includes a first object identifier of the first development object, the interactive interface is used by the first development object to filter a target template for creating a code instance, the local path is generated based on a root path and a code instance name that matches the target template in a code repository, and the code instance name is generated based on the first object identifier, the target template, and the timestamp of the create request; the submit control is used by the first development object to submit the code instance to the code repository after developing the code instance based on the target template and the local path.

[0015] According to an embodiment of the present disclosure, the development plug-in further includes: a query control; wherein the query control is used for the second development object to send a query request to the server so that the server sends a code instance to the second development object, and the query request includes a second object identifier of the second development object; wherein the code instance is obtained from the code repository when it is determined that the second object identifier exists in the object identifiers of the co-created objects, and the object identifiers of the co-created objects are obtained after obtaining the configuration file when it is determined that the first development object is configured with a configuration file for co-creating the code instance.

[0016] According to an embodiment of the present disclosure, the development plug-in also includes: a first processing control and a second processing control; the first processing control is used for the second development object to send a processing request for the conflict warning to the server when receiving the conflict warning sent by the server, so that the server merges the re-developed code instance with the code instance submitted to the code repository and stores them in the code repository; the second processing control is used for the second development object to send a processing request for the conflict warning to the server when receiving the conflict warning sent by the server, so that the server branch the re-developed code instance with the code instance submitted to the code repository and store them in the code repository; wherein the conflict warning is generated by the server when determining that the second development object conflicts with the version of the code instance submitted to the code repository during the re-development of the code instance.

[0017] A sixth aspect of the present disclosure provides an electronic device, comprising: one or more processors; and a memory for storing one or more computer programs, wherein the one or more processors execute the one or more computer programs to implement the steps of the above method.

[0018] The seventh aspect of the present disclosure further provides a computer-readable storage medium on which a computer program or instruction is stored, and the steps of the above method are implemented when the above computer program or instruction is executed by a processor.

[0019] The eighth aspect of the present disclosure also provides a computer program product, including a computer program or instructions, which implement the steps of the above method when the above computer program or instructions are executed by a processor. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] The above contents and other objects, features and advantages of the present disclosure will become more apparent through the following description of the embodiments of the present disclosure with reference to the accompanying drawings, in which:

[0021] Figure 1 Schematically illustrates an application scenario diagram of a code instance development method, apparatus, development plug-in, device, medium, and program product according to an embodiment of the present disclosure;

[0022] Figure 2 A flowchart of a code example development method according to an embodiment of the present disclosure is schematically shown;

[0023] Figure 3 A schematic diagram of code example development interaction according to an embodiment of the present disclosure is schematically shown;

[0024] Figure 4 A schematic diagram of code example development interaction according to another embodiment of the present disclosure is shown;

[0025] Figure 5 A flowchart of a code example development method according to another embodiment of the present disclosure is schematically shown;

[0026] Figure 6 A schematic diagram of a code development tool interface for installing a development plug-in according to an embodiment of the present disclosure is schematically shown;

[0027] Figure 7 A schematic diagram of a code development tool interface for installing a development plug-in according to another embodiment of the present disclosure is schematically shown;

[0028] Figure 8 A schematic diagram of a code development tool interface for installing a development plug-in according to another embodiment of the present disclosure is shown schematically;

[0029] Fig. 9 The structure block diagram of the code example development device according to the embodiment of the present disclosure is schematically shown;

[0030] Fig.10 A structural block diagram of a code example development device according to another embodiment of the present disclosure is schematically shown; and

[0031] Fig.11 A block diagram of an electronic device suitable for implementing a code example development method according to an embodiment of the present disclosure is schematically shown. DETAILED DESCRIPTION

[0032] Hereinafter, embodiments of the present disclosure will be described with reference to the accompanying drawings. However, it should be understood that these descriptions are exemplary only and are not intended to limit the scope of the present disclosure. In the following detailed description, for ease of explanation, many specific details are set forth to provide a comprehensive understanding of the embodiments of the present disclosure. However, it is apparent that one or more embodiments may also be implemented without these specific details. In addition, in the following description, descriptions of known structures and technologies are omitted to avoid unnecessary confusion of the concepts of the present disclosure.

[0033] The terms used herein are only for describing specific embodiments and are not intended to limit the present disclosure. The terms "comprise", "include", etc. used herein indicate the existence of features, steps, operations and / or components, but do not exclude the existence or addition of one or more other features, steps, operations or components.

[0034] All terms (including technical and scientific terms) used herein have the meanings commonly understood by those skilled in the art unless otherwise defined. It should be noted that the terms used herein should be interpreted as having a meaning consistent with the context of this specification and should not be interpreted in an idealized or overly rigid manner.

[0035] When using expressions such as "at least one of A, B, and C, etc.", they should generally be interpreted according to the meaning of the expression commonly understood by those skilled in the art (for example, "a system having at least one of A, B, and C" should include but is not limited to a system having A alone, B alone, C alone, A and B, A and C, B and C, and / or A, B, C, etc.).

[0036] In the technical solution of the present disclosure, the user information (including but not limited to user personal information, user image information, user device information, such as location information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved are all information and data authorized by the user or fully authorized by all parties, and the collection, storage, use, processing, transmission, provision, disclosure and application of the relevant data comply with relevant laws, regulations and standards, take necessary confidentiality measures, do not violate public order and good morals, and provide corresponding operation entrances for users to choose to authorize or refuse.

[0037] In the scenario of using personal information for automated decision-making, the methods, devices, and systems provided by the embodiments of the present disclosure provide users with corresponding operation portals for users to choose to agree or reject the automated decision-making results; if the user chooses to reject, the expert decision-making process will be entered. The expression "automated decision-making" here refers to the activity of automatically analyzing and evaluating a person's behavioral habits, interests and hobbies, or economic, health, credit status, etc. through computer programs, and making decisions. The expression "expert decision-making" here refers to the activity of making decisions by people who specialize in a certain field, have specialized experience, knowledge and skills, and have reached a certain level of professionalism.

[0038] In the process of implementing the embodiments of the present disclosure, it was found that in the process of developing code examples, developers selected a development template on a web page and downloaded it. Although the function of creating a template was realized, the function was relatively simple and the creation process was complicated, resulting in low development efficiency.

[0039] An embodiment of the present disclosure provides a code instance development method, comprising: in response to a creation request for a code instance sent by a first development object, calling an interactive interface so that the first development object can screen a target template for creating the code instance on the interactive interface, wherein the creation request includes a first object identifier of the first development object; generating a code instance name based on the first object identifier, the target template, and a timestamp of the creation request; generating a local path for storing the code instance based on a root path matching the target template and the code instance name in a code repository; and sending the local path to the first development object so that the first development object can develop the code instance based on the target template and the local path and submit it to the code repository.

[0040] Figure 1 The application scenario diagram of the code instance development method, apparatus, development plug-in, device, medium and program product according to the embodiments of the present disclosure is schematically shown.

[0041] like Figure 1 As shown, the application scenario 100 according to this embodiment may include a first terminal device 101, a second terminal device 102, a third terminal device 103, a network 104, and a server 105. The network 104 is used to provide a medium for a communication link between the first terminal device 101, the second terminal device 102, the third terminal device 103, and the server 105. The network 104 may include various connection types, such as wired, wireless communication links, or optical fiber cables, etc.

[0042] The user can use the first terminal device 101, the second terminal device 102, and the third terminal device 103 to interact with the server 105 through the network 104 to receive or send messages, etc. Various communication client applications can be installed on the first terminal device 101, the second terminal device 102, and the third terminal device 103, such as code development tools, shopping applications, web browser applications, search applications, instant messaging tools, email clients, social platform software, etc. (only for example).

[0043] The first terminal device 101, the second terminal device 102, and the third terminal device 103 may be various electronic devices having display screens and supporting web browsing, including but not limited to smart phones, tablet computers, laptop computers, desktop computers, and the like.

[0044] The server 105 may be a server that provides various services, such as a background management server (only as an example) that provides support for websites browsed by users using the first terminal device 101, the second terminal device 102, and the third terminal device 103. The background management server may analyze and process the received data such as user requests, and feed back the processing results (such as web pages, information, or data obtained or generated according to user requests) to the terminal device.

[0045] It should be noted that the code example development method provided in the embodiment of the present disclosure can generally be executed by the server 105. Accordingly, the code example development device provided in the embodiment of the present disclosure can generally be set in the server 105. The code example development method provided in the embodiment of the present disclosure can also be executed by a server or server cluster that is different from the server 105 and can communicate with the first terminal device 101, the second terminal device 102, the third terminal device 103 and / or the server 105. Accordingly, the code example development device provided in the embodiment of the present disclosure can also be set in a server or server cluster that is different from the server 105 and can communicate with the first terminal device 101, the second terminal device 102, the third terminal device 103 and / or the server 105.

[0046] It should be understood that Figure 1 The number of terminal devices, networks and servers in the embodiment is only for illustration. Any number of terminal devices, networks and servers may be provided according to implementation requirements.

[0047] The following will be based on Figure 1 The scene described by Figure 2~Figure 5 The code example development method of the disclosed embodiment is described in detail.

[0048] Figure 2 The flowchart of the code example development method according to the embodiment of the present disclosure is schematically shown.

[0049] like Figure 2 As shown, the code example development method of this embodiment includes operations S210 to S240, and the transaction processing method can be executed by the server side.

[0050] In operation S210, in response to a creation request for a code instance sent by a first development object, an interactive interface is called so that the first development object can screen a target template for creating a code instance on the interactive interface.

[0051] In operation S220 , a code instance name is generated based on the first object identifier, the target template, and the timestamp of the creation request.

[0052] In operation S230 , a local path for storing the code instance is generated based on a root path and a code instance name in the code repository that matches the target template.

[0053] In operation S240 , the local path is sent to the first development object, so that the first development object develops a code instance based on the target template and the local path, and submits the code instance to the code repository.

[0054] According to an embodiment of the present disclosure, the creation request may include a first object identifier of a first development object. The first development object may include a code developer who creates a code instance. The first object identifier may be used to indicate a unique identifier of the first development object.

[0055] According to an embodiment of the present disclosure, the interactive interface may include a panel for displaying a template for creating a code instance in the code development tool. The template may be a template of a common different technology stack associated with a code developer, and the template includes an internal unified syntax configuration. The template may indicate a predefined code framework for guiding the development process.

[0056] According to an embodiment of the present disclosure, the interactive interface may display multiple templates, and the first development object may randomly select a target template from the multiple templates.

[0057] According to an embodiment of the present disclosure, the timestamp of the creation request may be a timestamp automatically generated when the first development object sends the creation request to the server.

[0058] For example, the first object identifier, the type of the target template, and the timestamp of the creation request may be combined to obtain the code instance name.

[0059] According to an embodiment of the present disclosure, a code repository may be used to store developed code instances and paths of the developed code instances.

[0060] For example, the developed code instance matching the target template can be determined according to the category of the target template, and the root path matching the target template can be determined according to the path of the developed code instance. The code instance name is used as the file name of the subpath under the root path. The root path and the subpath are combined to obtain a local path for storing the code instance.

[0061] According to the embodiment of the present disclosure, the first development object can store resource files in a local path, perform coding according to the target template and resource files, and realize specific functional requirements. After the development is completed, the code instance can be submitted to the code warehouse.

[0062] According to an embodiment of the present disclosure, when creating a code instance on the code development tool side, the code instance name and local path are generated based on the template selected by the development object by calling the interactive interface. Since the code instance name and local path are automatically generated by the server side, on the code development tool side, the development object only needs to filter the target template, and there is no need to manually fill in information such as the name path, which simplifies the creation process and improves development efficiency. In addition, since the code instance name is generated based on the first object identifier, the target template, and the timestamp of the creation request, it is unique, and thus the local path is also unique, avoiding the problem of path conflicts.

[0063] In the process of implementing the embodiments of the present disclosure, it was found that since the number of templates displayed on the interactive interface will be affected by the size of the panel, if the existing template types are displayed randomly, the code developer may not be able to filter the required templates, or may need to filter the template types multiple times before confirming whether they meet the requirements, which will increase the code development time and reduce the code development efficiency. In addition, if the screened template types do not meet the requirements, the code developer's experience will be poor.

[0064] Figure 3 The diagram schematically shows a code example development interaction diagram according to an embodiment of the present disclosure.

[0065] like Figure 3 As shown, the code reuse interaction process in this embodiment may include operations S301 to S309.

[0066] In operation S301, a first development object sends a creation request for a code instance to a server.

[0067] In operation S302, after receiving the creation request, the server obtains a historical code instance associated with the first development object.

[0068] In operation S303, the server determines a template type to be recommended to the first development object based on the historical code instance and the preset condition.

[0069] In operation S304, the server side calls an interactive interface and displays a plurality of templates matching the template type on the interactive interface.

[0070] In operation S305 , the first development object selects a target template from a plurality of templates of the interactive interface.

[0071] In operation S306, the server generates a code instance name based on the first object identifier, the target template, and the timestamp of the creation request;

[0072] In operation S307 , the server generates a local path for storing the code instance based on the root path and the code instance name matching the target template in the code repository.

[0073] In operation S308, the server sends the local path to the first development object.

[0074] In operation S309 , the first development object develops a code instance based on the target template and the local path.

[0075] According to an embodiment of the present disclosure, the first development object may submit the developed code instance to the code repository.

[0076] According to an embodiment of the present disclosure, the historical code instance may include multiple ones. The server may count the number of template types and each template type in the multiple historical code instances, and determine the template type whose number is greater than a preset number and whose template type meets preset conditions as the template type recommended to the first development object.

[0077] According to an embodiment of the present disclosure, by introducing templates for intelligent recommendation display, the template type that is highly associated with the development object is determined based on the historical code instances associated with the development object, and then multiple templates matching the template type are displayed in the interactive interface, thereby shortening the code development time and improving the code development efficiency. In addition, by improving the matching degree between the template and the development object, the experience of code developers is enhanced.

[0078] According to one embodiment of the present disclosure, the server side can also configure a preview function for multiple templates that match the template type, so that the first development object can view the template's structure, main code files, and examples of some key functions through the preview window when screening templates, which facilitates the first development object to screen the target template that meets the needs.

[0079] According to an embodiment of the present disclosure, by configuring the preview function, the development object can be more intelligent when screening templates, reducing unnecessary trials and errors.

[0080] According to an embodiment of the present disclosure, a preset condition can be used to indicate a trend of development technology. Based on the historical code instance and the preset condition, determining a template type for recommendation to a first development object may include the following operations: determining a technology stack of a historical template matching the historical code instance according to the historical code instance; and determining that the template type matching the technology stack meets the trend of development technology, determining the template type matching the technology stack as a template type for recommendation to the first development object.

[0081] According to an embodiment of the present disclosure, by determining the technology stack of the historical template that matches the historical code instance, the technology stack preference of the first development object can be determined, and the technology stack preference and technology trend are combined to determine the recommended template type, thereby increasing the degree of consistency with the technology stack preference of the first development object and improving the matching accuracy of the template type with the first development object.

[0082] According to the embodiments of the present disclosure, for the above Figure 2 The operation S230 shown generates a local path for storing the code instance based on the root path and code instance name that match the target template in the code repository, and may include the operations of: determining the code instance name as a subpath of the root path; and generating a local path for storing the code instance based on the root path and the subpath.

[0083] According to an embodiment of the present disclosure, a root path and a sub-path are combined to obtain a local path for storing a code instance.

[0084] According to an embodiment of the present disclosure, after the development of the code instance is completed and submitted to the code repository, the code instance is stored in a local path.

[0085] According to an embodiment of the present disclosure, by determining the code instance name as a sub-path, the uniqueness of the path can be ensured, which is beneficial to ensure the consistency of the local path and the path in the code repository.

[0086] According to one embodiment of the present disclosure, after the development is completed and the code instance is submitted to the code repository, the path of the code instance in the code repository and the local path can be detected through a monitoring thread. When it is detected that the path of the code instance in the code repository is inconsistent with the local path or there is a path conflict, a prompt can be sent to the first development object, and the path can be automatically repaired to ensure path consistency.

[0087] According to the embodiments of the present disclosure, path detection, path repair, and path sharing in the code repository can effectively solve the problem of inconsistent paths during multi-person collaborative development. Team development objects can ensure path consistency through a unified path configuration and synchronization mechanism to prevent path problems from affecting development progress.

[0088] In the process of implementing the embodiments of the present disclosure, it was found that when multiple people collaborate on development, the development object needs to manually obtain the code from the code repository after obtaining the code repository address. During this process, problems such as path errors and version conflicts may be encountered, which increases the complexity of code development and the possibility of errors.

[0089] Figure 4 A schematic diagram of code instance development interaction according to another embodiment of the present disclosure is schematically shown.

[0090] like Figure 4 As shown, the code instance development interaction process in this embodiment may include operations S401 to S405.

[0091] In operation S401, the second development object sends a query request to the server.

[0092] In operation S402, after receiving the query request, the server determines whether there is a second object identifier in the object identifiers of the jointly created objects.

[0093] In operation S403, when it is determined that the second object identifier exists in the object identifiers of the jointly created objects, the server obtains a code instance from the code repository.

[0094] In operation S404, the server sends the code instance to the second development object.

[0095] In operation S405 , after receiving the code instance, the second development object redevelops the code instance.

[0096] According to an embodiment of the present disclosure, the query request may include a second object identifier of the second development object.

[0097] According to an embodiment of the present disclosure, the configuration file may include the object identification of each of the co-created objects. The configuration file may be configured by the first development object according to requirements after creating a code instance.

[0098] According to the embodiments of the present disclosure, for collaborative development objects, code instances can be obtained directly from the code repository without the need for the development object to manually obtain the code from the code repository, thereby reducing the possibility of encountering problems such as path errors and version conflicts during the acquisition process, simplifying the collaborative development process, and improving code development efficiency.

[0099] According to an embodiment of the present disclosure, when a second development object collaborates to develop a code instance, a pre-configured collaborative path configuration function can be enabled to ensure that all co-created objects use a unified path when pulling the code instance. Through this mechanism, all co-created objects can avoid the problem of inconsistent paths, further simplifying the collaborative development process.

[0100] According to an embodiment of the present disclosure, the collaborative path configuration function can be implemented by generating a path sharing configuration file when the first development object creates a code instance and saving it on the server side. This can ensure that the paths of all co-created objects are consistent with the code repository when pulling projects. At the same time, the first development object can share the path settings through the configuration file to avoid manual path configuration by other development objects.

[0101] According to an embodiment of the present disclosure, the code example development method may include the above Figure 2 In addition to the operations S210 to S240 shown, the following operations may also be included: when it is determined that a code instance version conflict occurs between the code instance version submitted to the code repository and the code instance version redeveloped by the second development object, a conflict warning is generated and sent to the second development object; in response to a request for processing the conflict warning sent by the second development object, the redeveloped code instance is merged with the code instance submitted to the code repository and then stored in the code repository; or in response to a request for processing the conflict warning sent by the second development object, the redeveloped code instance is branched from the code instance submitted to the code repository and then stored in the code repository.

[0102] According to an embodiment of the present disclosure, a code instance version conflict may be used to indicate a conflict that occurs when multiple development objects modify the same code instance on different branches, and these modifications affect the same code line or adjacent lines.

[0103] According to an embodiment of the present disclosure, the code instance version conflict information can be used as a conflict warning. For example, modifications affecting the same code line or adjacent lines can be merged or branched.

[0104] According to the embodiments of the present disclosure, by intelligently detecting whether the current instance is consistent with the warehouse storage instance and providing conflict warning and processing strategies, it is ensured that the code instances developed by all developers do not conflict.

[0105] According to an embodiment of the present disclosure, when it is determined that the first development object is configured with a configuration file for jointly creating a code instance, a collaboration management page can be called based on the object identifiers of the jointly created objects, and information such as a list of jointly created objects, permission settings, and collaboration progress can be displayed on the collaboration management page. The jointly created objects can communicate and discuss in real time on the collaboration management page, share development experiences and problem solutions, etc.

[0106] According to an embodiment of the present disclosure, in response to a collaboration request from a second development object, an approval message may be pushed to a first development object based on the collaboration request, so that the first development object enters a collaboration management page for approval and management after receiving the approval message.

[0107] According to another embodiment of the present disclosure, function commands can also be constructed in the sidebar of the code development tool, such as configuring enterprise software warehouses, installing dependencies, starting code instances, building analysis, etc. When a function command is clicked, a terminal window can be created to automatically execute the built-in command script of the corresponding target template.

[0108] According to the embodiments of the present disclosure, not only can code templates be quickly created according to the needs of the development object, but after the code instance is created, the development object can also configure the enterprise software warehouse, install dependencies, start the project, build analysis and other operations with one click through the function area.

[0109] Figure 5 The flowchart of a code example development method according to another embodiment of the present disclosure is schematically shown.

[0110] like Figure 5 As shown, the code instance development method of this embodiment may include operations S510 to S540, and the code instance development method may be executed by the development object end.

[0111] In operation S510, a creation request is sent to a server so that the server calls an interactive interface and generates a local path for storing a code instance.

[0112] In operation S520, a target template for creating a code instance is screened in the interactive interface.

[0113] In operation S530, a local path sent by the server is received.

[0114] In operation S540 , a code instance is developed based on the target template and the local path, and submitted to the code repository.

[0115] According to an embodiment of the present disclosure, the creation request may include a first object identifier of the first development object.

[0116] According to an embodiment of the present disclosure, the local path may be generated based on a root path and a code instance name matching a target template in a code repository.

[0117] According to an embodiment of the present disclosure, the code instance name may be generated based on the first object identifier, the target template, and the timestamp of the creation request.

[0118] It should be noted that the description of the code instance development method executed by the development object side can be specifically referred to the code instance development method executed by the server side, and will not be repeated here.

[0119] Figure 6 A schematic diagram of a code development tool interface for installing a development plug-in according to an embodiment of the present disclosure is schematically shown.

[0120] According to an embodiment of the present disclosure, a development plug-in of a code development tool may include a creation control and a submission control.

[0121] According to an embodiment of the present disclosure, a creation control may be used by a first development object to send a creation request to a server, so that the server calls an interactive interface and generates a local path for storing a code instance.

[0122] According to an embodiment of the present disclosure, a creation request may include a first object identifier of a first development object, an interactive interface may be used for the first development object to filter a target template for creating a code instance, a local path is generated based on a root path and a code instance name in a code repository that matches the target template, and the code instance name is generated based on the first object identifier, the target template, and a timestamp of the creation request.

[0123] According to an embodiment of the present disclosure, the submission control may be used by a first development object to submit a code instance to a code repository after developing the code instance based on a target template and a local path.

[0124] According to an embodiment of the present disclosure, a development plug-in of a code development tool may be installed in the code development tool, such as Figure 6 The code development tool interface 600 shown may include a create control 601, a submit control 602, and a code editing area 603. When the development object is editing the code in the code editing area 603, the development object may click the create control 601 to filter the target template and obtain the local path, and may click the submit control 602 to submit the code snippet of the code instance developed based on the target template and the local path.

[0125] Figure 7 A schematic diagram of a code development tool interface for installing a development plug-in according to another embodiment of the present disclosure is schematically shown.

[0126] According to an embodiment of the present disclosure, the development plug-in of the code development tool may further include a query control.

[0127] According to an embodiment of the present disclosure, a query control can be used for a second development object to send a query request to a server so that the server sends a code instance to the second development object, and the query request includes a second object identifier of the second development object. The code instance is obtained from a code repository when it is determined that the second object identifier exists in the object identifiers of the co-created objects. The object identifiers of the co-created objects are obtained after obtaining the configuration file when it is determined that the first development object is configured to co-create the code instance.

[0128] According to an embodiment of the present disclosure, when the development plug-in of the code development tool is installed in the code development tool, in addition to the above Figure 6The code development tool interface 600 shown in FIG. 6 may include a creation control 601, a submission control 602, and a code editing area 603, and may also include a query control 701, such as Figure 7 shown.

[0129] When the development object is editing the code in the code editing area 603, the development object can click the query control 701 to determine whether there is a code instance that needs to be jointly created. If so, the code instance can be received by clicking the query control 701 and the code instance can be redeveloped.

[0130] Figure 8 A schematic diagram of a code development tool interface for installing a development plug-in according to yet another embodiment of the present disclosure is schematically shown.

[0131] According to an embodiment of the present disclosure, the development plug-in of the code development tool may further include a first processing control and a second processing control.

[0132] According to an embodiment of the present disclosure, the first processing control can be used for the second development object to send a processing request for the conflict warning to the server when receiving the conflict warning sent by the server, so that the server merges the redeveloped code instance with the code instance submitted to the code repository and stores them in the code repository. The second processing control can be used for the second development object to send a processing request for the conflict warning to the server when receiving the conflict warning sent by the server, so that the server merges the redeveloped code instance with the code instance submitted to the code repository and stores them in the code repository after branching. The conflict warning is generated by the server when it is determined that the second development object has a conflict with the version of the code instance submitted to the code repository during the redevelopment of the code instance.

[0133] According to an embodiment of the present disclosure, when the development plug-in of the code development tool is installed in the code development tool, in addition to the above Figure 6 and Figure 7 The code development tool interface 600 shown in FIG. 6 may include a first processing control 801 and a second processing control 802 in addition to the creation control 601, the submission control 602, the code editing area 603 and the query control 701. Figure 8 shown.

[0134] When the co-created object is editing code in the code editing area 603 and receives a conflict warning sent by the server, the redeveloped code instance can be merged or branched with the code instance submitted to the code repository and stored in the code repository by clicking the first processing control 801 or the second processing control 802.

[0135] It should be noted that the above disclosure Figure 6~Figure 8This is only a schematic illustration of how to use the plug-in, and does not limit the number, shape, position, size, etc. of the controls disclosed in the present invention. The code development tool interface may also include other components besides the above examples.

[0136] According to an embodiment of the present disclosure, the development plug-in of the code development tool may include, in addition to the controls in the above embodiments of the present disclosure, functional commands such as configuring enterprise software repositories, installing dependencies, starting code instances, and building analysis.

[0137] Based on the above code example development method executed by the server, the present disclosure also provides a code example development device. Fig. 9 The device is described in detail.

[0138] Fig. 9 The structure block diagram of the code example development device according to the embodiment of the present disclosure is schematically shown.

[0139] like Fig. 9 As shown, the code example development device 900 of this embodiment includes a calling module 910 , a first generating module 920 , a second generating module 930 , and a first sending module 940 .

[0140] The calling module 910 is used to call the interactive interface in response to a creation request for a code instance sent by the first development object, so that the first development object can screen a target template for creating the code instance in the interactive interface, wherein the creation request includes a first object identifier of the first development object.

[0141] The first generating module 920 is used to generate a code instance name based on the first object identifier, the target template and the timestamp of the creation request.

[0142] The second generating module 930 is used to generate a local path for storing the code instance based on the root path and the code instance name matching the target template in the code repository.

[0143] The first sending module 940 is used to send the local path to the first development object, so that the first development object develops a code instance based on the target template and the local path, and submits the code instance to the code repository.

[0144] According to an embodiment of the present disclosure, the code instance development device 900 further includes: a first acquisition module, a second acquisition module, and a second sending module. The first acquisition module is used to respond to a query request sent by the second development object, and when it is determined that the first development object is configured to jointly create a configuration file of the code instance, obtain the configuration file, wherein the query request includes the second object identifier of the second development object, and the configuration file includes the object identifiers of the jointly created objects. The second acquisition module is used to obtain the code instance from the code repository when it is determined that the second object identifier exists in the object identifiers of the jointly created objects. The second sending module is used to send the code instance to the second development object so that the second development object can redevelop the code instance.

[0145] According to an embodiment of the present disclosure, the code instance development device 900 further includes: a third generation module, a merging module or a branching module. The third generation module is used to generate a conflict warning and send a conflict warning to the second development object when it is determined that the second development object has a conflict with the version of the code instance submitted to the code repository during the re-development of the code instance. The merging module is used to respond to a processing request for the conflict warning sent by the second development object, merge the re-developed code instance with the code instance submitted to the code repository, and store them in the code repository. The branching module is used to respond to a processing request for the conflict warning sent by the second development object, branch the re-developed code instance with the code instance submitted to the code repository, and store them in the code repository.

[0146] Based on the above code instance development method executed by the development object end, the present disclosure also provides a code instance development device. Fig.10 The device is described in detail.

[0147] Fig.10 The structural block diagram of a code example development device according to another embodiment of the present disclosure is schematically shown.

[0148] like Fig.10 As shown, the code example development device 1000 of this embodiment includes a second sending module 1010 , a screening module 1020 , a receiving module 1030 and a development module 1040 .

[0149] The second sending module 1010 is used to send a creation request to the server so that the server calls the interactive interface and generates a local path for storing the code instance, wherein the creation request includes the first object identifier of the first development object. The screening module 1020 is used to screen the target template for creating the code instance in the interactive interface; the receiving module is used to receive the local path sent by the server. The receiving module 1030 is used to receive the local path sent by the server. The development module 1040 is used to develop the code instance based on the target template and the local path, and submit it to the code repository; wherein the local path is generated based on the root path and the code instance name that matches the target template in the code repository, and the code instance name is generated based on the first object identifier, the target template and the timestamp of the creation request.

[0150] According to an embodiment of the present disclosure, any multiple modules among the calling module 910, the first generating module 920, the second generating module 930 and the first sending module 940 or the second sending module 1010, the screening module 1020, the receiving module 1030 and the developing module 1040 can be combined into one module for implementation, or any one of the modules can be split into multiple modules. Alternatively, at least part of the functions of one or more of these modules can be combined with at least part of the functions of other modules and implemented in one module. According to an embodiment of the present disclosure, at least one of the calling module 910, the first generating module 920, the second generating module 930 and the first sending module 940 or the second sending module 1010, the screening module 1020, the receiving module 1030 and the developing module 1040 can be at least partially implemented as a hardware circuit, such as a field programmable gate array (FPGA), a programmable logic array (PLA), a system on a chip, a system on a substrate, a system on a package, an application-specific integrated circuit (ASIC), or can be implemented by hardware or firmware such as any other reasonable way of integrating or packaging the circuit, or implemented in any one of the three implementation methods of software, hardware and firmware or in any appropriate combination of any of them. Alternatively, at least one of the calling module 910, the first generating module 920, the second generating module 930 and the first sending module 940 or the second sending module 1010, the screening module 1020, the receiving module 1030 and the developing module 1040 can be at least partially implemented as a computer program module, and when the computer program module is run, the corresponding function can be executed.

[0151] Fig.11 A block diagram of an electronic device suitable for implementing a code example development method according to an embodiment of the present disclosure is schematically shown.

[0152] like Fig.11As shown, the electronic device 1100 according to an embodiment of the present disclosure includes a processor 1101, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 1102 or a program loaded from a storage part 1108 to a random access memory (RAM) 1103. The processor 1101 may include, for example, a general-purpose microprocessor (such as a CPU), an instruction set processor and / or a related chipset and / or a special-purpose microprocessor (for example, an application-specific integrated circuit (ASIC)), etc. The processor 1101 may also include an onboard memory for caching purposes. The processor 1101 may include a single processing unit or multiple processing units for performing different actions of the method flow according to an embodiment of the present disclosure.

[0153] In RAM 1103, various programs and data required for the operation of electronic device 1100 are stored. Processor 1101, ROM 1102 and RAM 1103 are connected to each other through bus 1104. Processor 1101 performs various operations of the method flow according to the embodiment of the present disclosure by executing the program in ROM 1102 and / or RAM 1103. It should be noted that the program can also be stored in one or more memories other than ROM 1102 and RAM 1103. Processor 1101 can also perform various operations of the method flow according to the embodiment of the present disclosure by executing the program stored in one or more memories.

[0154] According to an embodiment of the present disclosure, the electronic device 1100 may further include an input / output (I / O) interface 1105, which is also connected to the bus 1104. The electronic device 1100 may further include one or more of the following components connected to the input / output (I / O) interface 1105: an input portion 1106 including a keyboard, a mouse, etc.; an output portion 1107 including a cathode ray tube (CRT), a liquid crystal display (LCD), etc., and a speaker, etc.; a storage portion 1108 including a hard disk, etc.; and a communication portion 1109 including a network interface card such as a LAN card, a modem, etc. The communication portion 1109 performs communication processing via a network such as the Internet. A drive 1110 is also connected to the input / output (I / O) interface 1105 as needed. A removable medium 1111, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc., is installed on the drive 1110 as needed, so that a computer program read therefrom is installed into the storage portion 1108 as needed.

[0155] The present disclosure also provides a computer-readable storage medium, which may be included in the device / apparatus / system described in the above embodiments; or may exist independently without being assembled into the device / apparatus / system. The above computer-readable storage medium carries one or more programs, and when the above one or more programs are executed, the method according to the embodiment of the present disclosure is implemented.

[0156] According to an embodiment of the present disclosure, a computer-readable storage medium may be a non-volatile computer-readable storage medium, for example, may include but is not limited to: a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination thereof. In the present disclosure, a computer-readable storage medium may be any tangible medium containing or storing a program, which may be used by or in combination with an instruction execution system, an apparatus, or a device. For example, according to an embodiment of the present disclosure, a computer-readable storage medium may include the ROM 1102 and / or RAM 1103 described above and / or one or more memories other than ROM 1102 and RAM 1103.

[0157] The embodiment of the present disclosure also includes a computer program product, which includes a computer program, and the computer program contains program code for executing the method shown in the flowchart. When the computer program product is run in a computer system, the program code is used to enable the computer system to implement the method provided by the embodiment of the present disclosure.

[0158] The above functions defined in the system / device of the embodiment of the present disclosure are performed when the computer program is executed by the processor 1101. According to the embodiment of the present disclosure, the system, device, module, unit, etc. described above can be implemented by a computer program module.

[0159] In one embodiment, the computer program may rely on tangible storage media such as optical storage devices, magnetic storage devices, etc. In another embodiment, the computer program may also be transmitted and distributed in the form of signals on a network medium, and downloaded and installed through the communication part 1109, and / or installed from a removable medium 1111. The program code contained in the computer program may be transmitted using any appropriate network medium, including but not limited to: wireless, wired, etc., or any suitable combination of the above.

[0160] In such an embodiment, the computer program can be downloaded and installed from the network through the communication part 1109, and / or installed from the removable medium 1111. When the computer program is executed by the processor 1101, the above functions defined in the system of the embodiment of the present disclosure are performed. According to the embodiment of the present disclosure, the system, device, means, module, unit, etc. described above can be implemented by a computer program module.

[0161] According to an embodiment of the present disclosure, the program code for executing the computer program provided by the embodiment of the present disclosure can be written in any combination of one or more programming languages. Specifically, these computing programs can be implemented using high-level process and / or object-oriented programming languages, and / or assembly / machine languages. Programming languages ​​include, but are not limited to, Java, C++, python, "C" language or similar programming languages. The program code can be executed entirely on the user computing device, partially on the user device, partially on the remote computing device, or entirely on the remote computing device or server. In the case of a remote computing device, the remote computing device can be connected to the user computing device through any type of network, including a local area network (LAN) or a wide area network (WAN), or can be connected to an external computing device (for example, using an Internet service provider to connect through the Internet).

[0162] The flow charts and block diagrams in the accompanying drawings illustrate the possible architecture, functions and operations of the systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each box in the flow chart or block diagram can represent a module, a program segment, or a part of a code, and the above-mentioned module, program segment, or a part of a code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in a different order from the order marked in the accompanying drawings. For example, two boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram or flow chart, and the combination of the boxes in the block diagram or flow chart can be implemented with a dedicated hardware-based system that performs a specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

[0163] It will be appreciated by those skilled in the art that the features described in the various embodiments of the present disclosure may be combined and / or combined in a variety of ways, even if such combinations or combinations are not explicitly described in the present disclosure. In particular, without departing from the spirit and teachings of the present disclosure, the features described in the various embodiments of the present disclosure may be combined and / or combined in a variety of ways. All of these combinations and / or combinations fall within the scope of the present disclosure.

[0164] The embodiments of the present disclosure are described above. However, these embodiments are only for illustrative purposes and are not intended to limit the scope of the present disclosure. Although the embodiments are described above, this does not mean that the measures in the various embodiments cannot be used in combination to advantage. Without departing from the scope of the present disclosure, those skilled in the art may make a variety of substitutions and modifications, which should all fall within the scope of the present disclosure.

Claims

1. A code instance development method, characterized in that: The method comprises: In response to a creation request for a code instance sent by a first development object, calling an interactive interface so that the first development object can screen a target template for creating the code instance on the interactive interface, wherein the creation request includes a first object identifier of the first development object; generating a code instance name based on the first object identifier, the target template, and a timestamp of the creation request; Based on a root path in a code repository that matches the target template and the code instance name, generating a local path for storing the code instance; and The local path is sent to the first development object, so that the first development object develops the code instance based on the target template and the local path, and submits the code instance to the code repository.

2. The method according to claim 1, characterized in that The method further comprises: In response to a query request sent by the second development object, if it is determined that the first development object is configured with a configuration file for co-creating the code instance, obtaining the configuration file, wherein the query request includes a second object identifier of the second development object, and the configuration file includes the object identifiers of the co-created objects; When it is determined that the second object identifier exists in the object identifiers of the jointly created objects, acquiring the code instance from the code repository; and The code instance is sent to the second development object so that the second development object redevelops the code instance.

3. The method according to claim 2, characterized in that The method further comprises: When it is determined that the second development object conflicts with the version of the code instance submitted to the code repository during the redevelopment of the code instance, a conflict warning is generated and sent to the second development object; In response to the processing request for the conflict warning sent by the second development object, merging the redeveloped code instance with the code instance submitted to the code repository and storing them in the code repository; or In response to the processing request for the conflict warning sent by the second development object, the redeveloped code instance and the code instance submitted to the code repository are branched and stored in the code repository.

4. The method according to any one of claims 1 to 3, characterized in that The step of calling an interactive interface in response to a creation request for a code instance sent by the first development object so that the first development object can select a target template for creating the code instance on the interactive interface includes: In response to the creation request for the code instance sent by the first development object, obtaining a historical code instance associated with the first development object; Based on the historical code instance and preset conditions, determining a template type for recommending to the first development object; and The interactive interface is called, and a plurality of templates matching the template type are displayed on the interactive interface, so that the first development object can filter the target template on the interactive interface.

5. The method according to claim 4, characterized in that The preset conditions are used to indicate the trend of the development technology; The determining, based on the historical code instance and the preset condition, a template type for recommending to the first development object comprises: Determine, according to the historical code instance, a technology stack of a historical template matching the historical code instance; as well as In the case where it is determined that the template type matching the technology stack meets the trend of the development technology, the template type matching the technology stack is determined as the template type for recommendation to the first development object.

6. The method according to any one of claims 1 to 3, characterized in that: The generating a local path for storing the code instance based on the root path matching the target template in the code repository and the code instance name includes: Determine the code instance name as a subpath of the root path; and A local path for storing the code instance is generated according to the root path and the sub-path.

7. A code instance development method, characterized in that: The method comprises: Sending a creation request to a server so that the server calls an interactive interface and generates a local path for storing a code instance, wherein the creation request includes a first object identifier of a first development object; Filtering a target template for creating a code instance in the interactive interface; receiving the local path sent by the server; and Based on the target template and the local path, develop the code instance and submit it to the code repository; The local path is generated based on a root path and a code instance name in a code repository that matches the target template, and the code instance name is generated based on the first object identifier, the target template, and a timestamp of the creation request.

8. A code example development device, characterized in that: The device comprises: a calling module, configured to call an interactive interface in response to a creation request for a code instance sent by a first development object, so that the first development object can screen a target template for creating the code instance on the interactive interface, wherein the creation request includes a first object identifier of the first development object; A first generating module, configured to generate a code instance name based on the first object identifier, the target template and the timestamp of the creation request; a second generating module, configured to generate a local path for storing the code instance based on a root path in a code repository that matches the target template and the code instance name; and The first sending module is used to send the local path to the first development object, so that the first development object develops the code instance based on the target template and the local path, and submits it to the code repository.

9. A code example development device, characterized in that: The device comprises: A second sending module is used to send a creation request to the server so that the server calls the interactive interface and generates a local path for storing the code instance, wherein the creation request includes a first object identifier of the first development object; A screening module, used for screening target templates for creating code instances in the interactive interface; A receiving module, configured to receive the local path sent by the server; and A development module, used to develop the code instance based on the target template and the local path, and submit it to the code repository; The local path is generated based on a root path and a code instance name in a code repository that matches the target template, and the code instance name is generated based on the first object identifier, the target template, and a timestamp of the creation request.

10. A development plug-in for a code development tool, characterized in that: The developing plug-in includes creating a control and submitting a control; The creation control is used for the first development object to send a creation request to the server so that the server calls the interactive interface and generates a local path for storing the code instance, wherein the creation request includes a first object identifier of the first development object, the interactive interface is used for the first development object to filter a target template for creating the code instance, the local path is generated based on a root path matching the target template in the code repository and a code instance name, and the code instance name is generated based on the first object identifier, the target template and a timestamp of the creation request; The submit control is used by the first development object to submit the code instance to the code repository after developing the code instance based on the target template and the local path.

11. The development plug-in according to claim 10, characterized in that: The development plug-in also includes: a query control; The query control is used for the second development object to send a query request to the server, so that the server sends the code instance to the second development object, and the query request includes the second object identifier of the second development object; Among them, the code instance is obtained from the code repository when it is determined that the second object identifier exists in the object identifiers of the jointly created objects, and the object identifiers of the jointly created objects are obtained after obtaining the configuration file when it is determined that the first development object is configured to jointly create the code instance.

12. The development plug-in according to claim 11, characterized in that: The development plug-in further includes: a first processing control and a second processing control; The first processing control is used for the second development object to send a processing request for the conflict warning to the server when receiving the conflict warning sent by the server, so that the server merges the redeveloped code instance with the code instance submitted by the code repository and stores them in the code repository; The second processing control is used for the second development object to send the processing request for the conflict warning to the server when receiving the conflict warning sent by the server, so that the server branches the redeveloped code instance and the code instance submitted by the code repository and stores them in the code repository; The conflict warning is generated by the server when it is determined that the second development object has a conflict with the version of the code instance submitted to the code repository during the re-development of the code instance.

13. An electronic device comprising: one or more processors; a memory for storing one or more computer programs, It is characterized in that the one or more processors execute the one or more computer programs to implement the steps of the method according to any one of claims 1 to 7.

14. A computer-readable storage medium having a computer program or instruction stored thereon, characterized in that: When the computer program or instruction is executed by a processor, the steps of the method according to any one of claims 1 to 7 are implemented.

15. A computer program product comprising a computer program or instructions, characterized in that When the computer program or instruction is executed by a processor, the steps of the method according to any one of claims 1 to 7 are implemented.

Images