Method and device for issuing and processing contract template

Abstract

The embodiment of the invention provides a contract template publishing processing method and device, and the method comprises the steps: carrying out the abnormality verification of a contract template, and correcting the abnormal content obtained through verification; loading a dynamic parameter instance corresponding to the scene dimension of the contract template from a dynamic parameter instance library; performing dynamic parameter rendering on the contract template based on a loading result, and performing archiving verification on the rendered contract template; and if the archiving verification is passed, issuing the contract template in a gray level issuing mode.

Description

[0001] This application is a divisional application of the Chinese invention patent application with the application date of May 20, 2021, application number CN202110551337.1, and name “Contract Template Publishing Processing Method and Device”. Technical Field

[0002] This document relates to the field of data processing technology, and in particular to a method and device for publishing and processing contract templates. Background Art

[0003] With the continuous development of e-commerce, electronic contracts have gradually replaced paper contracts with the advantages of convenience and easy preservation. Many companies that attach importance to the development of informatization are increasingly inclined to adopt electronic contracts to quickly lock in customers, reduce costs, and enhance competitiveness. As an important carrier that directly reflects the business situation of the enterprise, electronic contracts are often used as an important node for standardized management and control. However, with the update of data and changes in customer scenarios, contract upgrades and changes are required in many cases to meet customer needs, which puts higher requirements on the maintenance of contract changes. Summary of the invention

[0004] One or more embodiments of the present specification provide a method for processing the publication of a contract template. The method for processing the publication of a contract template includes: performing an abnormality check on the contract template and correcting the abnormal content obtained by the check. Loading the dynamic parameter instance corresponding to the scenario dimension of the contract template from the dynamic parameter instance library. Performing dynamic parameter rendering on the contract template based on the loading result, and performing archiving verification on the rendered contract template. If the archiving verification passes, the contract template is published in a grayscale publishing manner.

[0005] One or more embodiments of the present specification provide a contract template publishing and processing device, including: a template anomaly correction module, configured to perform an anomaly check on the contract template and correct the abnormal content obtained by the check. A dynamic parameter instance loading module, configured to load the dynamic parameter instance corresponding to the scene dimension of the contract template from the dynamic parameter instance library. A rendering and archiving verification module, configured to perform dynamic parameter rendering on the contract template based on the loading result, and to perform archiving verification on the rendered contract template. A grayscale publishing module, configured to publish the contract template in a grayscale publishing manner if the archiving verification passes.

[0006] One or more embodiments of the present specification provide a contract template publishing and processing device, including: a processor; and a memory configured to store computer executable instructions, wherein when the computer executable instructions are executed, the processor: performs an abnormality check on the contract template, and corrects the abnormal content obtained by the check. Load the dynamic parameter instance corresponding to the scenario dimension of the contract template from the dynamic parameter instance library. Perform dynamic parameter rendering on the contract template based on the loading result, and perform archive verification on the rendered contract template. If the archive verification passes, the contract template is published in a grayscale publishing manner.

[0007] One or more embodiments of the present specification provide a storage medium for storing computer executable instructions, which implement the following process when executed: perform an exception check on the contract template and correct the abnormal content obtained by the check. Load the dynamic parameter instance corresponding to the scenario dimension of the contract template from the dynamic parameter instance library. Perform dynamic parameter rendering on the contract template based on the loading result, and perform archive verification on the rendered contract template. If the archive verification passes, the contract template is published in a grayscale publishing manner. BRIEF DESCRIPTION OF THE DRAWINGS

[0008] In order to more clearly illustrate one or more embodiments of the present specification or the technical solutions in the prior art, the drawings required for use in the embodiments or the prior art descriptions are briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in the present specification. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative labor. Figure 1 A processing flow chart of a method for publishing a contract template provided for one or more embodiments of this specification; Figure 2 A process flow chart of a contract template determination process provided for one or more embodiments of this specification; Figure 3 A processing flow chart of a contract template publishing method applied to an electronic contract template publishing scenario provided by one or more embodiments of this specification; Figure 4 A schematic diagram of a publishing and processing device for a contract template provided for one or more embodiments of this specification; Figure 5 A schematic diagram of the structure of a contract template publishing and processing device provided for one or more embodiments of this specification. DETAILED DESCRIPTION

[0009] In order to enable those skilled in the art to better understand the technical solutions in one or more embodiments of this specification, the technical solutions in one or more embodiments of this specification will be clearly and completely described below in conjunction with the drawings in one or more embodiments of this specification. Obviously, the described embodiments are only part of the embodiments of this specification, not all of them. Based on one or more embodiments of this specification, all other embodiments obtained by ordinary technicians in this field without creative work should fall within the scope of protection of this document.

[0010] This specification provides a method for publishing a contract template: Reference Figure 1 , which shows a processing flow chart of a method for publishing a contract template provided in this embodiment, referring to Figure 2 , which shows a processing flow chart of a contract template determination process provided by this embodiment, referring to Figure 3 , which shows a processing flow chart of a contract template publishing method provided by this embodiment and applied to an electronic contract template publishing scenario.

[0011] Reference Figure 1 The contract template publishing processing method provided in this embodiment specifically includes steps S102 to S108.

[0012] Step S102, perform an abnormality check on the contract template and correct the abnormal content obtained by the check.

[0013] The contract template publishing processing method provided in this embodiment first verifies and corrects the abnormal content in the contract template, and builds a dynamic parameter instance library through model training during the debugging of the contract template, and then dynamically renders and archives the contract template based on the dynamic parameter instance in the dynamic parameter instance library, thereby improving the efficiency of contract template debugging through automated and intelligent verification. At the same time, in the process of publishing the contract template, the contract template is published in a grayscale publishing manner, which reduces the risks brought by the online publication of the contract template and ensures the compliance and security of the contract template.

[0014] The contract template described in this embodiment refers to a template file of an electronic contract that has not been written with the data of the two or more parties involved in the contract and has not been signed. After the data of the two or more parties involved in the contract are written and signed, the contract template generates an electronic contract with binding force of the agreement. Here, the type of electronic contract is not limited, and it can be a transaction contract, a loan contract, an insurance contract, etc. The form of the electronic contract is also not limited. For example, it can be an electronic contract rendered by the Velocity template engine and displayed to customers in HTML format.

[0015] In actual applications, contract template changes include creating new contract templates and updating contract templates. For creating new contract templates, the contract templates are often created and edited in text format. Therefore, the abnormality check of the contract template in this step is performed on the basis of the contract template in HTML format. Therefore, before the abnormality check of the contract template, if the file format of the contract template is in text format, the file format of the contract template is converted to HTML format, such as converting the contract template from Word format to HTML format. For changing the contract template, since the update of the contract template is often based on the contract template in HTML format generated after the conversion, no processing is required.

[0016] In this embodiment, a verification rule base is formed through historical experience, the contract template content is pre-verified based on the verification rule base, and the abnormal content verified in the contract template is corrected to ensure the correctness of the contract template. In an optional implementation provided by this embodiment, the contract template is verified for abnormality, and the abnormal content obtained by the verification is corrected, which specifically includes: Verifying the tag items included in the contract template based on the verification rules in the pre-built verification rule library; If the verification result shows that the label item is abnormal, the label item is corrected according to the reference label mapped by the verification rule.

[0017] For example, the verification rules in the pre-built verification rule library are shown in Table 1 below:

[0018] Table 1 The first verification rule in Table 1 above is used to verify whether the abnormal character "&&" exists in the contract template converted from Word format to HTML format. If it exists, it indicates that the "&&" character in the contract template is converted into the abnormal character "&&" during the process of converting the contract template from Word format to HTML format. The abnormal character "&&" in the contract template in HTML format needs to be corrected to the character "&&"; The second verification rule in Table 1 above is used to verify whether the abnormal character "##" exists in the contract template in HTML format. If it exists, the abnormal character can be deleted; The third validation rule in Table 1 above is used to verify whether there is a separate start tag in the HTML contract template. , or a separate closing tag , if present, is required in the contract template for a separate start tag Add the corresponding end tag , or for a separate closing tag Add the corresponding start tag.

[0019] Step S104: Load the dynamic parameter instance corresponding to the scenario dimension of the contract template from the dynamic parameter instance library.

[0020] The dynamic parameter instance library described in this embodiment is composed of dynamic parameter instances. Specifically, each dynamic parameter instance in the dynamic parameter instance library corresponds to a scenario dimension, that is, the dynamic parameter instance library is composed of dynamic parameter instances corresponding to each scenario dimension; and the dynamic parameter instance corresponding to each scenario dimension is obtained by training the dynamic parameter field of the scenario dimension. Dynamic parameters refer to the fields or texts that are dynamically displayed in the electronic contract due to actual needs. This part of the logic needs to be displayed in a programming language with certain rules. The code of this part in the electronic contract is called a dynamic parameter.

[0021] The dynamic parameter instance library is shown in Table 2 below:

[0022] Table 2 The scenario dimension is determined by "Contract Template Number + Product Code", and the dynamic parameter field corresponding to "Contract Template Number + Product Code" is the dynamic parameter instance corresponding to the scenario dimension.

[0023] In an optional implementation manner provided in this embodiment, the dynamic parameter instance corresponding to the scene dimension is trained in the following manner: Classify transaction data according to scenario dimensions to obtain transaction data of each scenario dimension; Extract dynamic parameter fields of each scenario dimension from transaction data of each scenario dimension; Determine whether a model training condition is triggered; the model training condition includes at least one of the following: product condition, template condition and time condition; If so, perform model training for each scenario dimension based on the extracted dynamic parameter fields to obtain dynamic parameter instances for each scenario dimension; If not, no action is required.

[0024] For example, obtain the event data obtained after a production event (such as a transaction event) occurs, as well as the event data obtained offline, and then classify the two parts of the event data. Specifically, divide the scenario dimensions according to the contract template and the product, and then classify the two parts of the event data according to the scenario dimensions to obtain the event data for each scenario dimension. Secondly, detect whether the model training conditions composed of product conditions, template conditions and time conditions (such as training every 5 minutes) are triggered. If triggered, perform model training for each scenario dimension based on the event data of each scenario dimension. Finally, use the model instances of each scenario dimension obtained through training as dynamic parameter instances of each scenario dimension, and persist the dynamic parameter instance library composed of the dynamic parameter instances of each scenario dimension.

[0025] During specific implementation, in the process of dynamically rendering and archiving the contract template, based on the dynamic parameter instance library obtained through training, the dynamic parameter instance corresponding to the scenario dimension of the contract template is loaded from the dynamic parameter instance library, so as to perform dynamic rendering and archiving verification according to the loaded dynamic parameter instance. In order to reduce the probability of risks occurring after the contract template is released online and improve the availability of the contract template after it is released online, in an optional implementation manner provided by this embodiment, in the process of loading the dynamic parameter instance corresponding to the scenario dimension of the contract template from the dynamic parameter instance library, at least one scenario dimension of the contract template is determined, and the dynamic parameter instance corresponding to each of the at least one scenario dimension is queried in the dynamic parameter instance library, and then the queried dynamic parameter instance is loaded.

[0026] In addition, in order to further improve the usability of the contract template after it is published online, the full set of dynamic parameter instances in the dynamic parameter instance library can be loaded, and the contract template can be verified using the full set of dynamic parameter instances, so as to enhance the comprehensiveness of the dynamic rendering and archiving verification of the contract template, thereby controlling the risk of contract changes within a certain range.

[0027] Step S106, dynamically rendering the contract template based on the loading result, and archiving and verifying the rendered contract template.

[0028] In specific implementation, the contract template is dynamically rendered based on the loading result, and the rendered contract template is archived and verified, which specifically includes: Performing dynamic parameter rendering based on the loaded dynamic parameter instance and the contract template; Convert the file format of the rendered contract template into an archive file format for archiving.

[0029] For example, for multiple scenario classifications involved in contract template A, dynamic parameter instances corresponding to multiple scenario classifications are loaded from a pre-trained dynamic parameter instance library. On this basis, the dynamic parameter rendering and archiving verification of contract template A specifically includes: dynamic parameter rendering is performed according to the loaded dynamic parameter instance and contract template A, and the loaded dynamic parameter instance is written into contract template A, and the contract template A after the dynamic parameter instance is written is converted from HTML format to PDF format for archiving. If the dynamic parameter rendering and archiving are successful, it indicates that the contract template A has passed the dynamic parameter rendering and archiving verification; conversely, if the dynamic parameter rendering or archiving fails, it indicates that the contract template A has not passed the dynamic parameter rendering and archiving verification.

[0030] Step S108: If the archive verification passes, the contract template is published in a grayscale publishing manner.

[0031] After the above steps dynamically render and archive the contract template according to the loaded dynamic parameter instance, if the verification is passed, the contract template is published. Specifically, during the publishing process, in order to reduce the risks brought by the online publishing of the contract template and control the risk of contract changes within a certain range, the grayscale publishing method is used to publish the verified contract template online.

[0032] In an optional implementation manner provided by this embodiment, the contract template is released in a grayscale release manner, including: Classifying a preset proportion of customers from a customer cluster as grayscale customers, and / or writing target customers in the customer cluster into a grayscale whitelist; The contract template is published online, and the use rights of the contract template are opened to the grayscale customers and / or target customers in the grayscale whitelist.

[0033] In actual applications, after the contract template is published online in a grayscale publishing manner, the online published contract template is used to generate and archive the contract according to the customer's needs when a transaction occurs. In this process, it is necessary to determine the contract template used for contract generation and archiving, that is, to use the contract template in the grayscale publishing state or the contract template that has been published online (historical contract template). In an optional implementation manner provided in this embodiment, the contract template used by the customer is determined in the following manner: Determine whether the execution environment is an online execution environment based on the customer's contract template access request; If it is an online execution environment, determine whether there is a contract template in a grayscale release state; if so, determine the grayscale type of the contract template in a grayscale release state, perform a grayscale access test on the customer according to the grayscale type, and return the corresponding contract template if the test passes; if not, return the historical contract template to the customer in response to the contract template access request; If it is not an online execution environment, returning the historical contract template to the client in response to the contract template access request.

[0034] In the process of performing a grayscale access test on the customer according to the grayscale type and returning the corresponding contract template if the test passes, if the grayscale type is proportional grayscale, determining whether the customer is a grayscale customer; if so, returning the contract template in the grayscale release state to the customer to respond to the contract template access request; if not, returning the historical contract template to the customer to respond to the contract template access request; Similarly, if the grayscale type is whitelist grayscale, determine whether the customer is in the grayscale whitelist; if so, return the contract template in the grayscale release state to the customer in response to the contract template access request; if not, return the historical contract template to the customer in response to the contract template access request.

[0035] For example, Figure 2 The contract template shown is determined by: Step S202: Obtain a contract template access request.

[0036] Step S204, determining whether the execution environment is an online execution environment; If yes, execute step S206; If not, execute step S208.

[0037] Step S206, determining whether there is a contract template in a grayscale release state; If yes, execute step S210 and step S212; If not, execute step S208.

[0038] Step S208, returning the historical contract template that has been published in the online execution environment.

[0039] Step S210, determining the grayscale type of the contract template in the grayscale release state.

[0040] Step S212, if the grayscale type is proportional grayscale, determine whether the customer is a grayscale customer; If yes, execute step S216; If not, execute step S208.

[0041] Step S214, if the grayscale type is grayscale according to whitelist, determine whether the customer is on the grayscale whitelist; If yes, execute step S216; If not, execute step S208.

[0042] Step S216, returning the contract template in the grayscale release state to respond to the contract template access request.

[0043] On the basis of the contract template used for contract generation and archiving determined above, contract generation and archiving are performed based on the determined contract template, and the specific implementation is as follows: extracting transaction keywords from the transaction data of the customer; Performing dynamic parameter rendering based on the transaction keyword and the contract template of the grayscale release status; The transaction keyword is written into the rendered contract template, and the file format of the transaction contract obtained after writing is converted into an archive file format for archiving.

[0044] It should be noted that, when the contract template returned by the above-mentioned contract template access request for the customer is a historical contract template that has been published online, it is also necessary to generate and archive the contract based on the historical contract template, which specifically includes: first, extracting transaction keywords from the customer's transaction data; then, performing dynamic parameter rendering based on the transaction keywords and the historical contract template; finally, writing the transaction keywords into the rendered historical contract template, and converting the file format of the transaction contract obtained after writing into an archive file format for archiving.

[0045] The following uses the application of a contract template publishing method provided in this embodiment in an electronic contract template publishing scenario as an example to further illustrate the contract template publishing method provided in this embodiment. Figure 3 , a contract template publishing processing method applied to an electronic contract template publishing scenario specifically includes steps S302 to S316.

[0046] Step S302: If the file format of the contract template is text format, convert the contract template from Word format to HTML file format.

[0047] Step S304: verify the tag items included in the contract template based on the verification rules in the pre-built verification rule library.

[0048] Step S306: If the verification result shows that an abnormal label item exists, the abnormal label item is corrected according to the reference label mapped by the verification rule.

[0049] Step S308, determining at least one scenario dimension of the contract template, searching for and loading dynamic parameter instances corresponding to at least one scenario dimension in the dynamic parameter instance library.

[0050] Step S310, performing dynamic parameter rendering based on the loaded dynamic parameter instance and contract template.

[0051] Step S312, converting the file format of the rendered contract template into PDF format for archiving.

[0052] Step S314: a preset proportion of customers are divided from the customer cluster as grayscale customers, and the target customers in the customer cluster are written into the grayscale whitelist.

[0053] Step S316, publish the contract template online, and open the use rights of the contract template to the grayscale customers and the target customers in the grayscale whitelist.

[0054] An embodiment of a contract template publishing and processing device provided in this specification is as follows: In the above-mentioned embodiment, a method for publishing and processing a contract template is provided, and correspondingly, a device for publishing and processing a contract template is also provided, which will be described below with reference to the accompanying drawings.

[0055] Reference Figure 4 , which shows a schematic diagram of a contract template publishing and processing device provided in this embodiment.

[0056] Since the device embodiment corresponds to the method embodiment, the description is relatively simple, and the relevant parts can refer to the corresponding description of the method embodiment provided above. The device embodiment described below is only illustrative.

[0057] This embodiment provides a contract template publishing processing device, including: The template anomaly correction module 402 is configured to perform an anomaly check on the contract template and correct the anomaly content obtained by the check; A dynamic parameter instance loading module 404 is configured to load a dynamic parameter instance corresponding to the scenario dimension of the contract template from a dynamic parameter instance library; The rendering and archiving verification module 406 is configured to perform dynamic parameter rendering on the contract template based on the loading result, and perform archiving verification on the rendered contract template; The grayscale publishing module 408 is configured to publish the contract template in a grayscale publishing manner if the archive verification passes.

[0058] An embodiment of a contract template publishing and processing device provided in this specification is as follows: Corresponding to the above-described method for publishing a contract template, based on the same technical concept, one or more embodiments of this specification further provide a contract template publishing device, which is used to execute the above-described method for publishing a contract template. Figure 5 A schematic diagram of the structure of a contract template publishing and processing device provided for one or more embodiments of this specification.

[0059] This embodiment provides a contract template publishing and processing device, including: like Figure 5 As shown, the contract template publishing processing device may have relatively large differences due to different configurations or performances, and may include one or more processors 501 and memory 502, and the memory 502 may store one or more storage applications or data. Among them, the memory 502 may be a short-term storage or a persistent storage. The application stored in the memory 502 may include one or more modules (not shown in the figure), and each module may include a series of computer executable instructions in the contract template publishing processing device. Furthermore, the processor 501 may be configured to communicate with the memory 502, and execute a series of computer executable instructions in the memory 502 on the contract template publishing processing device. The contract template publishing processing device may also include one or more power supplies 503, one or more wired or wireless network interfaces 504, one or more input / output interfaces 505, one or more keyboards 506, etc.

[0060] In a specific embodiment, the contract template publishing processing device includes a memory and one or more programs, wherein the one or more programs are stored in the memory, and the one or more programs may include one or more modules, and each module may include a series of computer executable instructions in the contract template publishing processing device, and the one or more programs are configured to be executed by one or more processors, including computer executable instructions for performing the following: Perform abnormality check on the contract template and correct the abnormal content obtained during the check; Loading a dynamic parameter instance corresponding to the scenario dimension of the contract template from a dynamic parameter instance library; Performing dynamic parameter rendering on the contract template based on the loading result, and performing archiving verification on the rendered contract template; If the archive verification passes, the contract template will be released in a grayscale release manner.

[0061] An embodiment of a storage medium provided in this specification is as follows: Corresponding to the above-described method for publishing and processing a contract template, based on the same technical concept, one or more embodiments of this specification also provide a storage medium.

[0062] The storage medium provided in this embodiment is used to store computer executable instructions, and the computer executable instructions implement the following process when executed: Perform abnormality check on the contract template and correct the abnormal content obtained during the check; Loading a dynamic parameter instance corresponding to the scenario dimension of the contract template from a dynamic parameter instance library; Performing dynamic parameter rendering on the contract template based on the loading result, and performing archiving verification on the rendered contract template; If the archive verification passes, the contract template will be released in a grayscale release manner.

[0063] It should be noted that the embodiment of the storage medium in this specification and the embodiment of the method for publishing and processing contract templates in this specification are based on the same inventive concept. Therefore, the specific implementation of this embodiment can refer to the implementation of the corresponding method mentioned above, and the repeated parts will not be repeated.

[0064] The above is a description of a specific embodiment of the specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recorded in the claims can be performed in an order different from that in the embodiments and still achieve the desired results. In addition, the processes depicted in the drawings do not necessarily require the specific order or continuous order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0065] In the 1930s, it was very clear whether the improvement of a technology was hardware improvement (for example, improvement of the circuit structure of diodes, transistors, switches, etc.) or software improvement (improvement of the method flow). However, with the development of technology, many improvements of the method flow today can be regarded as direct improvements of the hardware circuit structure. Designers almost always obtain the corresponding hardware circuit structure by programming the improved method flow into the hardware circuit. Therefore, it cannot be said that the improvement of a method flow cannot be implemented with a hardware entity module. For example, a programmable logic device (PLD) (such as a field programmable gate array (FPGA)) is such an integrated circuit whose logical function is determined by the user's programming of the device. Designers can "integrate" a digital system on a PLD by programming themselves, without having to ask chip manufacturers to design and make dedicated integrated circuit chips. Moreover, nowadays, instead of manually making integrated circuit chips, this kind of programming is mostly implemented by "logic compiler" software, which is similar to the software compiler used when developing and writing programs, and the original code before compilation must also be written in a specific programming language, which is called hardware description language (HDL). There is not only one HDL, but many kinds, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, RHDL (Ruby Hardware Description Language), etc. The most commonly used ones are VHDL (Very-High-Speed ​​Integrated Circuit Hardware Description Language) and Verilog. Those skilled in the art should also know that it is only necessary to program the method flow slightly in the above-mentioned hardware description languages ​​and program it into the integrated circuit, and then it is easy to obtain the hardware circuit that implements the logic method flow.

[0066] The controller may be implemented in any suitable manner, for example, the controller may take the form of a microprocessor or processor and a computer-readable medium storing a computer-readable program code (e.g., software or firmware) executable by the (micro)processor, a logic gate, a switch, an application-specific integrated circuit (ASIC), a programmable logic controller, and an embedded microcontroller, examples of which include but are not limited to the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20, and Silicone Labs C8051F320, and the memory controller may also be implemented as part of the control logic of the memory. It is also known to those skilled in the art that, in addition to implementing the controller in a purely computer-readable program code manner, the controller may be implemented in the form of a logic gate, a switch, an application-specific integrated circuit, a programmable logic controller, and an embedded microcontroller by logically programming the method steps. Therefore, such a controller may be considered as a hardware component, and the devices for implementing various functions included therein may also be considered as structures within the hardware component. Or even, the devices for implementing various functions may be considered as both software modules for implementing the method and structures within the hardware component.

[0067] The systems, devices, modules or units described in the above embodiments may be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer. Specifically, the computer may be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

[0068] For the convenience of description, the above devices are described in terms of functions and are divided into various units. Of course, when implementing the embodiments of this specification, the functions of each unit can be implemented in the same or multiple software and / or hardware.

[0069] It should be understood by those skilled in the art that one or more embodiments of the present specification may be provided as a method, system or computer program product. Therefore, one or more embodiments of the present specification may take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware. Moreover, the present specification may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0070] This specification is described with reference to the flowcharts and / or block diagrams of the methods, devices (systems), and computer program products according to the embodiments of this specification. It should be understood that each process and / or block in the flowchart and / or block diagram, as well as the combination of processes and / or blocks in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the processes in the flowchart and / or block diagram. Figure 1 A process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0071] These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing device to operate in a specific manner, so that the instructions stored in the computer-readable memory produce an article of manufacture comprising an instruction device, which implements the process Figure 1 A process or multiple processes and / or boxes Figure 1 A function specified in one or more boxes.

[0072] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operating steps are executed on the computer or other programmable device to produce a computer-implemented process, thereby providing instructions for implementing the process. Figure 1 A process or multiple processes and / or boxes Figure 1 The steps for the functions specified in one or more boxes.

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

[0074] Memory may include non-permanent storage in a computer-readable medium, random access memory (RAM) and / or non-volatile memory in the form of read-only memory (ROM) or flash RAM. Memory is an example of a computer-readable medium.

[0075] Computer readable media include permanent and non-permanent, removable and non-removable media that can be implemented by any method or technology to store information. Information can be computer readable instructions, data structures, program modules or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disk read-only memory (CD-ROM), digital versatile disk (DVD) or other optical storage, magnetic cassettes, magnetic disk storage or other magnetic storage devices or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined in this article, computer readable media does not include temporary computer readable media (transitory media), such as modulated data signals and carrier waves.

[0076] It should also be noted that the term "includes", "comprising" or any other variation thereof is intended to cover non-exclusive inclusion, so that a process, method, commodity or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, commodity or device. In the absence of further restrictions, an element defined by the sentence "comprising a ..." does not exclude the existence of other identical elements in the process, method, commodity or device including the element.

[0077] One or more embodiments of the present specification may be described in the general context of computer-executable instructions executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform specific tasks or implement specific abstract data types. One or more embodiments of the present specification may also be practiced in distributed computing environments where tasks are performed by remote processing devices connected through a communication network. In a distributed computing environment, program modules may be located in local and remote computer storage media, including storage devices.

[0078] Each embodiment in this specification is described in a progressive manner, and the same or similar parts between the embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the system embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and the relevant parts can be referred to the partial description of the method embodiment.

[0079] The above description is only an embodiment of this document and is not intended to limit this document. For those skilled in the art, this document may have various changes and variations. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of this document should be included in the scope of the claims of this document.

Claims

1. A method for publishing a contract template, comprising: Perform abnormality check on the contract template and correct the abnormal content obtained during the check; Based on the dynamic parameter instances in the dynamic parameter instance library, dynamic parameter rendering and archiving verification are performed on the contract template; The dynamic parameter instance library is constructed by model training during the debugging process of the contract template; If the archive verification passes, the contract template will be released in a grayscale release manner.

2. According to the method for publishing and processing a contract template according to claim 1, the step of performing dynamic parameter rendering and archiving verification on the contract template based on the dynamic parameter instance in the dynamic parameter instance library comprises: Loading the dynamic parameter instance corresponding to the scenario dimension of the contract template from the dynamic parameter instance library; The contract template is dynamically rendered based on the loading result, and the rendered contract template is archived and verified.

3. According to the method for publishing and processing a contract template according to claim 1, the step of performing abnormality checking on the contract template and correcting the abnormal content obtained by the checking comprises: Verifying the tag items included in the contract template based on the verification rules in the pre-built verification rule library; If the verification result shows that the label item is abnormal, the label item is corrected according to the reference label mapped by the verification rule.

4. The method for publishing and processing contract templates according to claim 1, before the step of performing abnormality checking on the contract template and correcting the abnormal content obtained by the checking is performed, it also includes: If the file format of the contract template is a text format, convert the file format of the contract template into an HTML file format.

5. According to the contract template publishing processing method described in claim 1, the model training conditions of the model training include at least one of the following: product conditions, template conditions and time conditions.

6. According to the method for publishing and processing a contract template as claimed in claim 2, the step of loading the dynamic parameter instance corresponding to the scenario dimension of the contract template from the dynamic parameter instance library comprises: Determine at least one scenario dimension of the contract template, and query the dynamic parameter instance library for each corresponding dynamic parameter instance of the at least one scenario dimension; Load the queried dynamic parameter instance.

7. According to the method for publishing and processing a contract template according to claim 6, the step of dynamically rendering the contract template based on the loading result and performing archiving verification on the rendered contract template comprises: Performing dynamic parameter rendering based on the loaded dynamic parameter instance and the contract template; Convert the file format of the rendered contract template into an archive file format for archiving.

8. According to the method for publishing a contract template according to claim 1, the step of publishing the contract template in a grayscale manner comprises: Classifying a preset proportion of customers from a customer cluster as grayscale customers, and / or writing target customers in the customer cluster into a grayscale whitelist; The contract template is published online, and the use rights of the contract template are opened to the grayscale customers and / or target customers in the grayscale whitelist.

9. The method for publishing a contract template according to claim 1, further comprising: Determine whether the execution environment is an online execution environment based on the customer's contract template access request; If yes, determine whether there is a contract template in the grayscale release state; If so, determine the grayscale type of the contract template in the grayscale release state; If the grayscale type is proportional grayscale, determining whether the customer is a grayscale customer; If yes, returning the contract template in the grayscale release state to the customer in response to the contract template access request; If the grayscale type is whitelist grayscale, determine whether the customer is in the grayscale whitelist; If so, the contract template in the grayscale release state is returned to the customer in response to the contract template access request.

10. The method for publishing a contract template according to claim 9, further comprising: extracting transaction keywords from the transaction data of the customer; Performing dynamic parameter rendering based on the transaction keyword and the contract template of the grayscale release status; The transaction keyword is written into the rendered contract template, and the file format of the transaction contract obtained after writing is converted into an archive file format for archiving.

11. According to the contract template publishing processing method according to claim 9, if the execution result after executing the step of determining whether the execution environment is an online execution environment is no, or the result after executing the step of determining whether there is a contract template in a grayscale publishing state is no, the historical contract template is returned to the customer in response to the contract template access request.

12. The method for publishing a contract template according to claim 11, further comprising: extracting transaction keywords from the transaction data of the customer; Performing dynamic parameter rendering based on the transaction keywords and the historical contract template; The transaction keyword is written into the rendered historical contract template, and the file format of the transaction contract obtained after writing is converted into an archive file format for archiving.

13. A contract template publishing and processing device, comprising: The template anomaly correction module is configured to perform anomaly verification on the contract template and correct the anomaly content obtained by the verification; A dynamic parameter instance loading module is configured to perform dynamic parameter rendering and archive verification on the contract template based on the dynamic parameter instance in the dynamic parameter instance library; The dynamic parameter instance library is constructed by model training during the debugging process of the contract template; The grayscale publishing module is configured to publish the contract template in a grayscale publishing manner if the archive verification passes.

14. A contract template publishing and processing device, comprising: processor; and a memory configured to store computer executable instructions that, when executed, cause the processor to: Perform abnormality check on the contract template and correct the abnormal content obtained during the check; Based on the dynamic parameter instances in the dynamic parameter instance library, dynamic parameter rendering and archiving verification are performed on the contract template; The dynamic parameter instance library is constructed by model training during the debugging process of the contract template; If the archive verification passes, the contract template will be released in a grayscale release manner.

15. A storage medium for storing computer executable instructions, wherein the computer executable instructions implement the following process when executed: Perform abnormality check on the contract template and correct the abnormal content obtained during the check; Based on the dynamic parameter instances in the dynamic parameter instance library, the contract template is subjected to dynamic parameter rendering and archiving verification; the dynamic parameter instance library is constructed by model training during the debugging process of the contract template; If the archive verification passes, the contract template will be released in a grayscale release manner.

Images