System and method for dynamically defining digital forms - Patents.com

Abstract

A system and method for dynamically generating, defining, and customizing forms and workflows based on user input and design, facilitating content management through real-time artificial intelligence and machine learning processing across various field force industries, etc. The system and method may be used on a wide variety of physical devices, such as web browsers, mobile devices, smartphones, tablets, etc., and may also be embedded in software applications. The exemplary system and method enables the design, routing, completion, and recording of forms to update back-end systems, dramatically expanding the number of users who can design enterprise-grade forms and workflows for complex processes, thus lowering costs and accelerating adoption.

Description

[Technical field]

[0001] This patent application claims the benefit of U.S. Provisional Application No. 63 / 016,587, filed April 28, 2020, which is incorporated herein by reference.

[0002] The field of the invention generally relates to methods and systems for dynamically defining and generating forms and workflows based on user input to facilitate content management including real-time data collection and entry, data processing and analysis, data assimilation and display on a wide variety of devices including web browsers and mobile devices, and the incorporation of these methods and systems into other software applications. Additionally, the invention relates to systems and methods for managing and assimilating data content through artificial intelligence processing to efficiently accomplish various objectives. [Background technology]

[0003] Today, most data in field force industries (e.g., field sales, field service, inspections and reporting, etc.) is distributed and captured on paper-based forms that are then physically routed between various parties both in the office and in the field, with updates to back-end systems being a manual process. Digitizing these forms and automatically electronically routing between parties and automatically updating back-end systems would be of great business benefit. There have been many attempts to develop such forms, but current approaches are limited in what can be done before resorting to manual labor and complex coding. Current approaches are also designed based on the technical capabilities of the browser (e.g., web browser) rather than the needs of the user. They also use a combination of extensible markup languages ​​such as HyperText Markup Language (HTML) and style sheet languages ​​such as Cascading Style Sheets (CSS), and if complex logic is involved, these complex logic must be coded in JavaScript, requiring additional skills and therefore limiting who can create and design forms.

[0004] For example, conventional approaches are described in US Pat. No. 6,233,633, US Pat. No. 6,233,633 and US Pat. No. 6,233,633, which describe systems and methods for customizing mobile form applications for distribution to mobile devices. These documents describe the use of Extensible Markup Language (XML) schemas for use with digital forms, which are well known and conventional in the art, but are limited and inflexible. In particular, these documents describe the use of XForms, which utilizes XPath for calculations, for generating digital forms. Unfortunately, XForms was not designed for use with data forms, and furthermore, the data forms disclosed in these documents do not have a dedicated calculation engine and do not support dynamic styling. Furthermore, these conventional approaches do not provide fine-grained control over the layout of the form, except for basic grouping of controls. Rather than relying on the browser to determine the layout of the form using a combination of HTML and CSS, a richer set of features for layout control is needed, such as column and row sections, field heights and widths, margins, and other dynamic features such as tabs and collapsible areas. Although XForms works with XML-based data, most modern Web APIs use JSON because it is more compact and easier to parse and deliver the payload as well. As such, the design of XForms is significantly limited in its adaptability. Hence, there is a need to provide greater flexibility to form designers to work with a variety of formats, including JSON and XML, and to enable the creation of dynamic forms as described further herein.

[0005] It would therefore be desirable to have a system and method for designing, routing, filling, and recording digital forms across multiple computing platforms, with the ability to use data from those forms to update back-end systems, and to allow forms created by people who are not skilled in coding to design forms with sophisticated logic specifically designed for their individual needs. Further, it would be desirable to dramatically expand the number of users capable of designing complex enterprise digital forms and workflows for complex processes, thereby reducing costs and accelerating adoption. [Prior art documents] [Patent documents]

[0006] [Patent Document 1] U.S. Pat. No. 9,836,446 [Patent Document 2] U.S. Pat. No. 10,394,948 [Patent Document 3] U.S. Pat. No. 10,585,982 Summary of the Invention [Problem to be solved by the invention]

[0007] In summary, the present invention generally relates to methods and systems for dynamically generating forms and workflows based on user input to facilitate content management including real-time data collection and entry, data processing and analysis, data assimilation and display on various devices including web browsers and mobile devices, and the incorporation of these methods and systems into other software applications. Additionally, the present invention is directed to systems and methods for managing and assimilating data content through artificial intelligence processing to efficiently accomplish various objectives. [Means for solving the problem]

[0008] It is a further object of the present invention to provide a method for rendering a form using a declarative definition language to drive a presentation renderer, the method including the steps of: defining a form using a declarative definition language, the declarative definition language defining the form in terms of its fields and its presentation, generating runtime objects from the declarative definition language, inputting the form data, evaluating calculations against the form data and returning results, and rendering the form using a presentation renderer, the presentation renderer using the runtime objects and the form data.

[0009] It is yet another object of the present invention to provide a system for rendering a form using a declarative definition language to drive a presentation renderer, the system including a form defined using a declarative definition language that defines the form in terms of its fields and its presentation, runtime objects generated from the declarative definition language, form data, results returned from computations evaluated against the form data, and a presentation renderer that renders the form, the presentation renderer using the runtime objects and the form data.

[0010] These and other objects, features, and properties of the systems and / or methods disclosed herein, as well as the method of operation and function of the associated elements of structure, combination of parts, and economies of manufacture will become more apparent from a consideration of the following description and the appended claims, with reference to the accompanying drawings, all of which form a part hereof, and in which reference characters designate corresponding parts in the drawings. It is expressly understood, however, that the drawings are for purposes of illustration and description only, and are not intended to limit the invention to the particular embodiments. As used herein, the singular forms "a," "an," and "the" include plural references unless the context clearly dictates otherwise.

[0011] The above and / or other aspects of the present invention will become more apparent from the detailed description of exemplary embodiments of the present invention, taken in conjunction with the accompanying drawings. [Brief description of the drawings]

[0012] [Figure 1A] 1 is a diagram of a system according to one embodiment of the present invention whereby a computing device can access digital forms on a server over a network. [Figure 1B] FIG. 2 is a diagram of various modules of one embodiment of the present invention. [Figure 1C] 1 is a diagram of a system that uses a declarative definition language to drive a presentation renderer to render a form. [Diagram 2] FIG. 2 is a diagram of a declarative definition language to support the definition of forms according to one embodiment of the present invention. [Diagram 3] FIG. 2 is a diagram of a declarative definition language loading process according to one embodiment of the present invention. [Figure 4] FIG. 2 is a diagram of a computation engine according to one embodiment of the present invention. [Diagram 5] FIG. 2 is a diagram of a presentation renderer according to one embodiment of the present invention. [Figure 6]FIG. 2 is a diagram of a declarative definition language for supporting the definition of a workflow according to one embodiment of the present invention. [Figure 7] FIG. 2 is a diagram of a designer tool for designing a workflow according to an embodiment of the present invention. [Figure 8] FIG. 2 is a diagram of a forms repository according to one embodiment of the present invention. [Figure 9] FIG. 2 is a diagram of a computational learning engine according to one embodiment of the present invention. [Figure 10A] FIG. 2 illustrates a first page of an exemplary paper form that may be designed and generated into a digital format in accordance with one embodiment of the present invention. [Figure 10B] FIG. 2 illustrates a second page of an exemplary paper form that may be designed and generated into a digital format in accordance with one embodiment of the present invention. [Figure 11A] FIG. 13 shows a first example of a digital form generated from the paper form of FIGS. 10A and 10B in accordance with an embodiment of the present invention. [Figure 11B] FIG. 13 shows a second example of a digital form generated from the paper form of FIGS. 10A and 10B in accordance with an embodiment of the present invention. [Figure 11C] FIG. 13 shows a third example of a digital form generated by a system according to an embodiment of the present invention from the paper form of FIGS. 10A and 10B. [Figure 11D] FIG. 13 shows a fourth example of a digital form generated by a system according to an embodiment of the present invention from the paper form of FIGS. 10A and 10B. [Figure 11E] FIG. 16 shows a fifth example of a digital form generated from the paper form of FIGS. 10A and 10B according to an embodiment of the present invention. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0013] The present invention relates to a system and method for dynamically generating and storing forms using a declarative definition language, rendering the forms to a user, allowing the user to interact with the form (e.g., input data), deriving or obtaining data, and storing and analyzing the data.

[0014] Those skilled in the art will recognize that the embodiments described herein may be practiced without these specific details or in equivalent arrangements. In other instances, well-known structures and devices are shown in block diagram form in order to avoid unnecessarily obscuring the embodiments of the present invention.

[0015] FIG. 1A is a diagram of a system according to an embodiment of the present invention, whereby a computing device can access digital forms on a server over a network.

[0016] According to one embodiment of the present invention, the enterprise system 0a is connected to the server 0b via a network 0d. It will be appreciated that the network 0d may be any manner of wired or wireless connection known in the art, including over the Internet. The server 0b is also connected to a computing device 0c via a network 0e that includes applications, software, programs, or other processing devices for implementing the systems and methods of the present invention. In some embodiments, the network 0d and the network 0e are the same network, and the enterprise system 0a may be part of or a component within the server 0b.

[0017] The server 0b includes four separate components: a form processing module 0f, a form storage device 0g, a form designer module 0i, and a form repository 0h. The form processing 0f component refers to one or more devices that perform some or all of the processing required for the operation of the present invention, including but not limited to loading declarative definition languages, updating back-end systems, and operations for artificial intelligence or machine learning processing. The form storage device 0b component refers to one or more devices for storing processing instructions, declarative definition languages, and form data used in the present invention. The form designer module 0i component is for form designers to design forms and / or workflows without needing to know any of the underlying programming language, allowing a person to preview and edit a WYSIWYG version of a form. Finally, the form repository 0h is a cloud-based or on-premise repository that stores all of the data and definitions for use by the present system and method.

[0018] FIG. 1B is a diagram of various modules of one embodiment of the present invention.

[0019] Further according to an embodiment of the present invention, the form repository module 0j is a cloud-based or on-premise repository that contains all of the data and definitions used by the system and method and exposes a REST-ful API to enable access. The form repository module 0j is connected to the form designer module 0k, which accesses the form repository module 0j using the REST-ful API. All calls to the form repository module 0j go through user authentication and authorization. The form repository module 0j also controls which forms are assigned to which users and therefore which forms will be displayed and worked on by the users. The form repository module 0j can assign forms to zero, one or more individual users and zero, one or more user groups. A supervisor user can be given access to view and edit cases assigned to the workers they supervise. The form repository module 0j also contains definition-related items that are expected to be read frequently but not written to that often.

[0020] The form designer module 0k is connected to the form repository module 0j, the declarative definition module 0l, the declarative definition workflow module 0m, and the calculation engine module 0n, and uses a RESTful API to access the form repository module 0j. The form designer module 0j is made to be user-friendly so that forms can be created by people familiar with the operations and processes of their business without the need for form designers to know any underlying programming language. The form designer module 0k provides a form editor and can display a visual representation of the form. Users can add or remove fields, change attributes, etc. In some embodiments, the form designer module 0k also provides a graphical workflow editor that presents the workflow as either a flow chart or a "swim lane" style process, making the workflow easier to understand and modify. The form designer module 0k also allows users to visually view the form as it will appear on various screen sizes, input test data to ensure correct functionality, and run the workflow.

[0021] The declarative definition module 0l is connected to the form designer module 0k, the calculation engine module 0n, and the declarative definition loading module 0o, and defines fields (i.e., data fields) associated with the form and how the fields should be displayed on the screens of various computing devices. For example, the declarative definition module 0l includes instructions to display the fields associated with the form on a mobile device screen or a computer screen. When the form is loaded on a computing device (e.g., a smartphone, tablet, laptop, or desktop), a runtime object is created and populated with instance-specific data. In some embodiments, the form includes calculations and conditional logic such as auto-population of fields, control of visibility and appearance of fields, enabling and disabling of fields, etc. The declarative definition module 0l defines the data structure of the form based on the fields and presentation associated with the form. Such a data structure allows the data associated with the fields and the appearance of the form to be treated separately from each other, thereby allowing the form to be rendered for different screen sizes and capabilities, paper sizes, formats, etc., without writing rules or code. The declarative definition module 0l is versatile for use with various data formats, such as JSON and XML.

[0022] The declarative definition workflow module 0m is connected with the form designer module 0k, the calculation engine module 0n, and the declarative definition loading module 0o, and is made user-friendly so that workflows can be created by people who are familiar with the operations and processes of their business. The workflow designer does not need to know any of the underlying programming languages. The declarative definition workflow module 0m displays the workflow as a flowchart or "swim lane" style process so that the workflow is easy to understand and modify.

[0023] The calculation engine module 0n is connected to the form designer module 0k, the declarative definition module 0l, and the declarative definition workflow module 0m. In some embodiments, the calculation engine module 0n has a learning function that assists the user when working with calculations, recognizing and suggesting common usage patterns. The learning function uses machine learning to identify common patterns across all fields on all forms in the system and suggests appropriate calculations or calculation arguments within the context of the fields. This machine learning aspect allows the calculation engine module 0n to evolve over time as more calculations are entered or updated and forms are added to the system. Thus, the learning function results in faster, more efficient operation and improves the form designer experience.

[0024] In some embodiments, the declarative definition loading module 0o is connected to the declarative definition module 0l and downloads or loads data from the declarative definition module 0l, whether it is from a server, from local or networked storage, from a local cache, from a local database, from a remote database, or from other storage systems or architectures known in the art. In an exemplary embodiment of the present invention, JSON is used as the underlying text-based representation of the stored language text, although it can be understood that other formats such as YAML, XML, binary representation custom / proprietary formats, etc., may be used. In some embodiments, the stored language text is first parsed from JSON (or other) into a basic key-value nested dictionary structure. The key-value nested dictionary structure is then validated against a schema to ensure that the JSON data structure matches the expected structure, resulting in a validated structure if there is a match. Once the JSON data structure is validated, the runtime object generation module 0p generates runtime objects and methods that can be directly used by other components of the system, such as the presentation renderer module 0p and the calculation engine module 0n.

[0025] The presentation renderer module 0q converts the instructions of the declarative definition module 0l (including the calculations from the calculation engine module 0n) into instructions used by a user interface tool, such as HTML for a web browser. The presentation renderer module 0q allows the form to be displayed in a web browser, a mobile app, a desktop app, a plug-in installed in a third party application (thus adding form functionality to a third party system), or on a printed page. It may be understood that the printed page may be any form of physical or digital printing, including printing in Adobe PDF format.

[0026] FIG. 1C provides a diagram of a system that uses a declarative definition language to drive a presentation renderer to render a form.

[0027] In a first embodiment of the present invention, a form is defined based on a declarative definition language 9. The declarative definition language 9 defines the fields (i.e., data fields) associated with the form and how the fields are to be displayed on the screens of various computing devices. For example, the declarative definition language 9 includes instructions for displaying the fields associated with the form on a mobile device screen or a computer screen. When the form is loaded into a computing device, a runtime object is created and populated with instance-specific data. In some embodiments, the form includes calculations 8 and conditional logic such as auto-populating fields, controlling visibility and appearance of fields, enabling and disabling fields, etc.

[0028] According to this embodiment, a presentation renderer 6 converts instructions in a declarative definition language 9, including any calculations 8, into instructions used by a user interface tool 1a, for example HTML for a web browser 1. The form may be displayed in a web browser 1, a mobile app 2, a desktop app 3, a plug-in installed in a third party application 4 (thus adding form functionality to a third party system), or on a printed page 5. It may be understood that the printed page 5 may be any form of physical or digital printing, including printing in Adobe PDF format.

[0029] It should be understood that any communication medium 7 may be used to facilitate interaction between the different components of system 1b of FIG. 1C, including processor 1c, electronic storage device 1d, and image capture device 1e connected to user interface tool 1a. One or more components of system 1b may communicate with each other via hardwired communication, wireless communication, or both. For example, one or more components of the system may communicate with each other over a network. For example, processor 1c may wirelessly communicate with electronic storage 1d. As non-limiting examples, wireless communication may include one or more of radio communication, Bluetooth communication, Wi-Fi communication, cellular communication, infrared communication, or other wireless communication. Other types of communication are contemplated and not excluded by this disclosure.

[0030] In some implementations, the processor 1c includes multiple processing units, which may be located in the same physical device or may be multiple devices operating in conjunction. The processor 1c may be configured to execute one or more components by software, hardware, firmware, any combination of software, hardware, and / or firmware, and / or other mechanisms for configuring processing capabilities.

[0031] Additionally, while various instructions are illustrated in FIG. 1C as being collocated within a single processing unit, it should be understood that an implementation may also include multiple processing units with one or more instructions that may be executed remotely from the other instructions.

[0032] The description of functionality provided by different computer-readable instructions described herein is for illustrative purposes and is not intended to be limiting, as any of the instructions may provide more or less functionality than described. For example, one or more of the instructions may be deleted and some or all of its functionality may be provided by other instructions. As another example, the processor(s) 1c may be programmed with one or more additional instructions that may perform some or all of the functionality attributed to one of the computer-readable instructions herein.

[0033] Referring to FIG. 2, a diagram of a declarative definition language for assisting in defining forms is shown according to one embodiment of the present invention.

[0034] The declarative definition language 9 defines the data structure of the form based on the fields 11 and presentation 20 associated with the form. Such a data structure allows the data associated with the fields 11 and the appearance of the form to the user to be treated separately, thereby allowing the form to be rendered for different screen sizes & capabilities, paper sizes, formats, etc. without writing rules or code.

[0035] In other embodiments, the fields 11 include scalar fields 12 (text, numeric, image, etc.), group fields 14, and / or array fields 18. The form is extensible and new field types can be added as needed. The declarative definition language 9 is flexible to work with a variety of data formats such as JSON and XML.

[0036] Scalar fields 12 refer to field types that contain a single piece of information, such as text, numbers, dates, etc. These types have a typical way in which they are presented to the user, but may be presented in different ways depending on the needs of the form. For example, numbers may be presented with or without digit separators (commas), long text may be truncated with an ellipsis that the user can press to see more of the long text, and dates may be shown in any number of formats.

[0037] Group fields 14 allow a set of fields 11 (which themselves may be scalars, arrays, or groups) to be treated logically together. For example, an address may be a group consisting of text fields for street address, city, state, and zip code. A single enable operation on the address group can control all of the fields within it. Additionally, groups may be presented by shared attributes such as background color (which in this example might be used to distinguish shipping address from billing address), incorporating the group within a section that the user can open and close, perhaps conserving screen real estate, grouping the data into tabs that the user can switch between, or other ways of presenting the data.

[0038] Array fields 18 allow for repeating groups such as line items on an invoice. Display of the array may include options for the layout of each item, horizontal and vertical alignment, and display of data from the array in a graph or chart. Data in the array may also be filtered for display.

[0039] In some embodiments, a scalar field 12 specifies attributes associated with the data, an initial value, calculations to be performed on the field (such as causing the value of the field to be updated when the value of another field is changed), and validations that may be enforced (such as a minimum value). A scalar field 12 also includes presentation information 13 related to the layout, style, and / or label of the scalar field 12.

[0040] In some embodiments, group fields 14 allow for arbitrary nesting of data and the addition of additional presentation information 16. Group fields 14 replicate the data structure of the form as a whole, and their presentation blocks allow for similar flexibility as forms.

[0041] In some embodiments, the array fields 18 are homogenous or heterogeneous and include presentation information 19 for the entire array and presentation information for group fields 14 contained within the array.

[0042] Referring to FIG. 3, a diagram of a declarative definition language loading process is shown according to one embodiment of the present invention.

[0043] The declarative definition language 9 is downloaded from a server at 21, loaded from local or networked storage at 22, loaded from a local cache at 23, loaded from a local database at 23a, loaded from a remote database at 23b, or loaded from other storage systems or architectures known in the art. In an exemplary embodiment of the invention, JSON is used as the underlying text-based representation in the stored language text 24, although it will be appreciated that other formats such as YAML, XML, binary representation custom / proprietary formats may be used.

[0044] Stored language text 24 is first parsed at 25 from JSON (or other) into a basic key-value nested dictionary structure 26. The key-value nested dictionary structure 26 is then validated at 27 against a schema to ensure the JSON data structure matches the expected structure, resulting in a validated structure 28. Once the JSON data structure has been validated, runtime objects and methods 29 are created so that it may be directly used by other components of the system, such as a presentation renderer 30a and a computation evaluator 30b.

[0045] The operations of the loading process presented herein are intended to be illustrative and should not be considered limiting. In some implementations, the loading process is accomplished with one or more additional operations not described and / or without one or more of the operations described. In some embodiments, two or more operations are performed substantially simultaneously. The described operations may be accomplished using some or all of the system components described in detail above.

[0046] In some implementations, the loading process is implemented in one or more processing devices (e.g., digital processors, analog processors, digital circuits designed to process information, central processing units, graphics processing units, microcontrollers, analog circuits designed to process information, state machines, and / or other mechanisms that process information electronically). The one or more processing devices include one or more devices that perform some or all of the operations of the loading process in response to instructions electronically stored on one or more electronic storage media. The one or more processing devices may include one or more devices specifically designed for the performance of one or more operations of the loading process through hardware, firmware, and / or software.

[0047] In FIG. 4, a diagram of a computation engine according to one embodiment of the present invention is shown.

[0048] Even if a declarative definition language 9 is used, another embodiment of the invention provides that computations 31 are written. A computation evaluator runtime then evaluates arguments 32 against form data 36 and returns results 39. Computations 31 include computations using constants 35, retrieval of form data values ​​36, and map / filter / reduce 36a, string manipulation 36b, arithmetic 36c, and logical operations 36d for transforming large data sets. Computations 31 are designed with the data form in mind and are under the same control as the rest of the system, allowing new functions to be easily added.

[0049] In some embodiments, when the calculation 31 is evaluated, the first argument 32 needs to be evaluated. The type and meaning of the first argument 32 depends on the specifications of the calculation 31. In most cases, the first argument 32 may itself be an additional calculation to the calculation 31. When the calculation 31 references form data 36, ​​the references associated with the form data are collected and registered with the change broadcaster 37, along with information about the intent of the calculation 31. For example, if a user is allowed to enter a date range, the user may be allowed to enter a start date and edit the end date or number of days, and a change to the end date will change the number of days and vice versa. Such functionality allows the user to conveniently and efficiently edit form fields.

[0050] In some embodiments, a change broadcaster 37 monitors the form data 36 and, if the value of a field changes (via user input, a calculation, or anything else), callers associated with affected calculations 31 are notified that the value of the field may have changed.

[0051] FIG. 5 illustrates a diagram of a presentation renderer according to one embodiment of the present invention.

[0052] The presentation renderer 6 combines the presentation information 20 provided by the declarative definition language 9 with form data 69 to create layout and styling instructions for the rendered user interface 49. According to one aspect of the invention, the declarative definition includes declarative definition runtime objects 68.

[0053] Layout management 51 processes information to provide placement and sizing of controls, including dynamic features such as tabs and collapsible areas, while style management 56 pertains to the look of the form, such as fonts, colors, column and row sections, field heights and widths, margins, etc. Layout management 51 may also include the ability to dynamically show and hide controls, such as when a billing address is the same as a shipping address. It may also be appreciated that there are many other real world scenarios where such dynamic hiding and showing can be accomplished.

[0054] In some embodiments, form data 69 is entered directly by the user via the rendered user interface 49 or obtained by other means via a camera, microphone, Bluetooth thermometer, etc. This form data 69 is then routed back to the form via input routing 55.

[0055] In some embodiments, the form changes recorded by the change broadcaster 57 are broadcast back to the layout management 51, style management 56, and / or rendered user interface 49 as necessary, either directly or indirectly due to calculation evaluation in the calculation evaluator 65, so that the user always sees current data. This also allows a single data field to be rendered in multiple ways while remaining automatically synchronized. For example, according to one aspect of the invention, a "rating" field may be displayed and modified as a numeric value, a slider, a star set rating, or any combination of these and other field types known in the art. The display of the field will always show the same value regardless of how the field is rendered.

[0056] The rendered user interface 49 is most commonly rendered to HTML for display in a browser or built-in controls that work with HTML, but it can be appreciated that it can be rendered in many different ways. In one embodiment, the rendered user interface 49 is rendered to PostScript for printing or saving to a PDF document. In another embodiment, the rendered user interface 49 is rendered to a series of commands for a native user interface, such as CocoaTouch for iOS or WPF for Windows.

[0057] As shown in FIG. 6, there is an illustration of a declarative definition language to support the definition of a workflow according to an embodiment of the present invention.

[0058] The declarative definition language defines a workflow 70 as a collection of transitions 80. Each transition may include fields 71 ​​and presentations 81, form updates 82, assignment changes 83, and backend updates 84.

[0059] In some embodiments, the fields 71 ​​of the transitions 80 are defined similarly to the fields of a form. Often, the fields 71 ​​of the transitions 80 are initialized by copying values ​​from the fields of the form.

[0060] The presentation 81 associated with a transition 80 is optional and is defined similarly to a presentation associated with a form, with the addition of dialog elements, user prompts, and text for "OK" and "Cancel" buttons. A transition without a presentation is completed without any user interaction.

[0061] In some embodiments, form update 82 maps fields 71 ​​of transition 80 to fields of the form, copying values ​​from transition 80 to the form or appending new groups to an array associated with the form. This allows transition 80 to modify values ​​that a user would not normally be allowed to change, which can be used to enforce data consistency.

[0062] In some embodiments, change allocation 83 sets the allocation of a form to a set of users or groups, or selectively adds and removes users and groups from an existing allocation, which may use calculations 31.

[0063] In some embodiments, the transition 80 triggers a backend update 84 to the backend system. The transition definition includes multiple updates. Each update specifies fields to be exported to the backend system, exports the form as a PDF or other rendering, and makes multiple calls based on content array fields. In one aspect of the invention, these fields are filtered.

[0064] Referring to FIG. 7, a diagram of a designer tool 108 for designing a workflow according to one embodiment of the present invention is shown.

[0065] The designer tool 108 is built to make it easy for people familiar with the operations and processes of their business to create forms - the form designer does not need to know any underlying programming language.

[0066] In some embodiments, the designer tool provides a form editor 103. The form editor 103 presents a visual representation of the form. The user can add and remove fields and change their attributes.

[0067] In some embodiments, the designer tool 108 provides a graphical workflow editor 105. The graphical workflow editor 105 displays the workflow as either a flowchart or a "swim lane" style process so that the workflow is easy to understand and modify.

[0068] In some embodiments, the designer tool provides a previewer / tester 104 that allows users to view forms as they appear on various screen sizes, enter test data to ensure correct functionality, and execute workflows.

[0069] In some embodiments, the designer tool provides a specialized calculation editor 106. The specialized calculation editor 106 assists the user in working with calculations. The specialized calculation editor 106 has a learning function that recognizes and suggests common usage patterns. The learning function uses machine learning to identify common patterns across all fields on all forms in the system and suggests appropriate calculations or calculation arguments within the context of the fields. The machine learning aspect allows for evolution over time as more calculations are entered or updated and forms are added to the system. Thus, the learning function leads to faster and more efficient operation of the specialized calculation editor 106, enhancing the form designer experience.

[0070] FIG. 8 is a diagram of a forms repository according to one embodiment of the present invention.

[0071] All of the data and definitions used by the system are stored in a cloud-based or on-premise repository, exposing a RESTful API to allow access. Forms apps 86 (including browser-based, mobile, desktop, or embedded third-party applications), administration tools 90, and form designer tools 93 all use this API to access the repository. All calls must go through a user authentication and authorization process 85.

[0072] Assignment management 94 manages which cases are assigned to which users, and therefore which cases users are expected to see and work on. Forms may be assigned to zero, one, or more individual users, and zero, one, or more user groups. Supervisory users may be given access to view or edit cases assigned to workers they supervise.

[0073] Definitions and definition-related items are stored together in definition storage 101 with the assumption that they will be read frequently but not often written.

[0074] In some embodiments, forms app 86 reads and updates form data in forms data storage 96. Updates to forms data storage 96 can trigger calls to other backend systems through backend communications 98, such as email or messaging systems, database systems, or other business systems. Forms renderer 100 runs entirely in the cloud, allowing forms to be updated and even re-rendered.

[0075] FIG. 9 shows a diagram of a computational learning engine according to one embodiment of the present invention.

[0076] The computational learning engine 118 takes the computation arguments 116 predefined in the form by the form designer 114, examines them for patterns and possible extensions, and generates logic paradigms 120 that can be used when creating computation arguments for other forms and fields in the form designer 114. The computational learning engine 118 is constantly updating and releasing new logic paradigms 120 based on all of the form designers 114 using the form solution. Calculations 31 and computation arguments 116, like many programming paradigms, are pattern-based. These patterns are based on characteristics that are not self-evident but include (but are not limited to) data type, relative position to other fields, relationships to other fields, naming patterns of fields, fields on other forms, forms within a given industry, and so on. By continually analyzing these characteristics using machine learning, the computational learning engine 118 improves over time and is able to suggest calculations and computation arguments, and complete the calculations and computation arguments as the form designer begins to type the calculation. The results are similar to those of a word processing tool that analyzes grammar and context to suggest options to complete sentences as you type. In this manner, the computational learning engine 118 results in faster, more efficient operation, enhancing the form designer's experience.

[0077] FIG. 10A illustrates a first page of an exemplary paper form that may be designed and digitally generated in accordance with one embodiment of the present invention.

[0078] FIG. 10B illustrates a second page of an exemplary paper form that may be designed and generated into digital format in accordance with an embodiment of the present invention.

[0079] 10A and 10B are diagrams illustrating a typical paper form of the kind that is digitized and replaced by an exemplary embodiment of the present invention. As is common in field force industries such as infrastructure inspection, paper forms include many different fields and many different types of fields for editing and input by a user (in this case, a leak inspector). By way of example, the leak report shown in FIGS. 10A and 10B includes different fields for the leak's address, the date of inspection, checkboxes for leak characteristics, an area for additional user input and comments, and an area for sketching and drawing the leak, among others.

[0080] After being edited by a user, paper forms in the field force industry as shown in FIGS. 10A and 10B are manually distributed or routed through various parties. This routing may take hours to days or even weeks due to the need for manual processing. Furthermore, changes to such forms may not be instantly deployed across all users, resulting in outdated forms being handled, further contributing to processing inefficiencies. Furthermore, analysis or processing of underlying data across multiple different paper forms may be burdensome, requiring searching and reviewing all related forms to gather the required data.

[0081] FIG. 11A shows a first example of a digital form generated from the paper form of FIGS. 10A and 10B in accordance with an embodiment of the present invention.

[0082] FIG. 11B shows a second example of a digital form generated from the paper form of FIGS. 10A and 10B in accordance with an embodiment of the present invention.

[0083] FIG. 11C provides a third example of a digital form generated by a system according to an embodiment of the invention from the paper form of FIGS. 10A and 10B.

[0084] FIG. 11D provides a fourth example of a digital form generated by a system according to an embodiment of the invention from the paper form of FIGS. 10A and 10B.

[0085] FIG. 11E shows a fifth example of a digital form generated from the paper form of FIGS. 10A and 10B in accordance with an embodiment of the present invention.

[0086] 11A, 11B, 11C, 11D, and 11E show different examples of digital forms generated from the paper forms of FIGS. 10A and 10B using the systems and processes disclosed herein. It can be appreciated that the digital forms generated in FIGS. 11A-11E can be displayed consistently across a variety of different user interfaces, including web, mobile, and desktop applications. It can be further appreciated that many different fields and many different types of fields that would be manually addressed using the paper forms of FIGS. 10A and 10B can be designed and generated using the systems and methods of the present invention, such as, among others, the address of the leak, the date of the inspection, check boxes for the characteristics of the leak, areas for additional user input and comments, and areas for sketching and drawing the leak. Business users and form designers can easily generate such digital forms from the corresponding paper forms and do not need to be skilled in writing code. The use of such digital forms allows for quick and efficient processing by the various parties involved and also allows for advanced analysis of the underlying data. For example, it becomes easy to search for all leak inspection reports that occurred on a given day, or by the size and material of the water pipes. Additionally, any updates to the form itself are instantly deployed to all users without the need for manual updates.

[0087] According to one embodiment of the present invention, a user begins designing a form by operating a form designer tool using an application, software, or other program installed on a computing device or server. The user does not need to know any underlying programming language to operate the tool. The form designer tool includes a form editor that presents the user with a WYSIWYG view of the form, allowing the user to easily add and remove fields, change attributes, positions, orientations, and allowable input arguments. The machine learning process also suggests appropriate calculations and calculation arguments to the user as more calculations are entered or updated and forms are added to the system. Such a process allows these forms to be designed more efficiently and quickly. For example, a city water department supervisor may want to design a form for leak inspection that includes the address of the leak, the inspection date, a checkbox for the leak characteristics, an area for additional user input and comments, and an area for sketching and drawing the leak. If there are other forms already in the system, the machine learning process can also suggest adding fields, such as dates and checkboxes, as the supervisor edits and designs the form. Users can also design and review forms more quickly and efficiently by interacting with a graphical workflow editor that designs, manages forms and / or automates processes.

[0088] After the form is designed, either the form designer or additional users can enter and edit data into the form as determined by the form design. For example, a water leak inspector can edit the field for entering the address of the leak. It can be understood that the inspector can enter and edit these forms in any manner on a portable or stationary computing device, and the forms will automatically adjust and scale to display appropriately on those devices. Thus, the inspector can edit forms in a convenient manner, at the field, at home, at work, or any combination of various locations, at different times as needed. Once edited, the completed form will be automatically routed to various parties who need to review the details of the inspection. For example, the form can be automatically routed to a contractor who will provide an estimate for repairs. After the completed form is saved, it would be possible for a local water department supervisor to search for all such reports for a particular house number or block to assess the need for more extensive repairs or replacement of water pipes.

[0089] Implementations of the present disclosure may be implemented in hardware, firmware, software, or any suitable combination thereof. Aspects of the present disclosure may be implemented as instructions stored on a machine-readable medium that may be read and executed by one or more processors. A machine-readable medium may include any mechanism for storing or transmitting information in a form readable by a machine (e.g., a computing device). For example, tangible computer-readable storage media may include read-only memory, random access memory, magnetic disk storage media, optical storage media, flash memory devices, and the like, and machine-readable transmission media may include forms of propagated signals, such as carrier waves, infrared signals, digital signals, and the like. Firmware, software, routines, or instructions may be described herein to perform certain operations with respect to certain exemplary aspects and implementations of the present disclosure.

[0090] For purposes of explanation, numerous specific details are described to provide a thorough understanding of the present specification. However, it will be apparent to those skilled in the art that embodiments of the present disclosure may be practiced without these specific details. In some examples, modules, structures, processes, functions, and devices are shown in block diagram form to avoid obscuring the description. In other examples, functional block diagrams and flow diagrams are shown to represent data and logic flow. Components of the block diagrams and flow diagrams (e.g., modules, blocks, structures, devices, features, etc.) may be variously combined, separated, deleted, reordered, and substituted in ways other than those explicitly described and depicted herein.

[0091] References herein to "one implementation," "an implementation," "several implementations," "various implementations," "an implementation," "other implementations," "a series of implementations," or the like, mean that a particular feature, design, structure, or characteristic described in connection with an implementation is included in at least one implementation of the present disclosure. The appearances of phrases such as "in one implementation" or "in an implementation" in various places in this specification do not necessarily all refer to the same implementation, nor are separate or alternative implementations mutually exclusive of other implementations. Furthermore, various features are described, whether or not there is an explicit reference to "implementations," that may be variously combined or included in some implementations, but variously omitted in other implementations. Similarly, various features are described that may be preferences or requirements in some implementations but not in other implementations.

[0092] The language used herein has been selected primarily for ease of reading and explanation, and may not have been selected to impose boundaries or limitations on the inventive subject matter. Other embodiments, uses and advantages of the present invention will be apparent to those skilled in the art from consideration of the specification and embodiments of the invention disclosed herein. The specification is to be considered exemplary, and the scope of the invention is accordingly intended to be limited only by the claims. [Explanation of symbols]

[0093] 1. Web Browser 1a User Interface Tools 1b System 1c processor 2. Mobile Apps 3. Desktop App 4. Third Party Applications 5 Print Pages 6 Presentation Renderer 8 Calculation 9 Declarative definition language 11 Field 12 Scalar Fields 13, 16 Presentation Information 14 Group Fields 18. Alley Field 20 Presentations 31 Calculation 32 Arguments 35 Constants 36 Form Data 36a Map / Filter / Reduce 36b String operations 36c Arithmetic 36d Logical Operations 37 Change Broadcaster 49 User Interface 51 Layout Management 55 Input Routing 56 Style Management 65 Calculation Evaluator 68 Declaratively Defined Runtime Objects 69 Form Data 70 Workflow 71 Field 80 Transitions 81 Presentations 82 Form Update 83 Allocation Change 84 Backend Updates

Claims

1. 1. A method for rendering a form using a declarative definition language to drive a presentation renderer, comprising: defining a form using a declarative definition language, said declarative definition language defining said form in terms of its fields and presentation; generating run-time objects from the declarative definition language; Entering form data; evaluating a calculation against the form data and returning a result; collecting a plurality of reference values ​​for said calculation, said reference values ​​being related to said form data and referencing each other; registering said plurality of reference values ​​together with information related to said calculation; modifying, in response to a change in one of the plurality of reference values, other reference values ​​of the plurality of reference values ​​that are affected by the change, taking into account dependencies between the form data using the plurality of reference values ​​and the information related to the calculation; rendering the form with a presentation renderer, the presentation renderer using the runtime objects and the form data.

2. The method of claim 1 , wherein the field is a scalar field.

3. The method of claim 1 , wherein the field is a group field.

4. The method of claim 1 , wherein the field is an array field.

5. The method of claim 1 , further comprising the step of loading the declarative definition language.

6. 2. The method of claim 1, further comprising: identifying, at a change broadcaster, one or more callers affected by the change to the form data, and causing one or more notifications to be sent to the one or more callers that the form data has been changed.

7. The method of claim 1 , further comprising the step of modifying a layout of form controls.

8. The method of claim 1 , further comprising the step of modifying the appearance of the form.

9. 10. The method of claim 1, further comprising: using a computational learning engine to examine the form data for relative position to other fields, relationships to other fields, field naming patterns, fields on other forms, or patterns of forms within a given industry, and generate pattern-based suggestions based on the patterns in the form data.

10. 2. The method of claim 1, further comprising: using the declarative definition language to initialize a collection of transitions including fields, presentations, form updates, assignment changes, or back-end updates, and generating a workflow based on the collection of transitions by setting values ​​of the fields, the presentations, the form updates, the assignment changes, or the back-end updates.

11. 1. A system for rendering a form using a declarative definition language to drive a presentation renderer, comprising: a processor executing instructions to define a form using the declarative definition language, the declarative definition language defining the form in terms of fields and presentation, the processor generating runtime objects from the declarative definition language; 1. A user interface tool for inputting form data, the processor executing instructions for evaluating a calculation against the form data and returning a result, the instructions for evaluation comprising: instructions for collecting a plurality of reference values ​​for said calculation, said reference values ​​being related to and referencing each other with said form data; instructions for registering said plurality of reference values ​​together with information related to said calculation; and instructions for modifying, in response to a change in one of the plurality of reference values, other reference values ​​of the plurality of reference values ​​that are affected by the change, taking into account dependencies between the form data and the information related to the calculation using the plurality of reference values; a presentation renderer for rendering the form, the presentation renderer using the runtime objects and the form data.

12. The system of claim 11 , wherein the field is a scalar field.

13. The system of claim 11 , wherein the field is a group field.

14. The system of claim 11 , wherein the field is an array field.

15. The system of claim 11 , wherein the processor executes instructions to load the declarative definition language.

16. 12. The system of claim 11, further comprising change broadcaster means for identifying one or more callers affected by changes to the form data and for providing one or more notifications to the one or more callers that the form data has been changed.

17. The system of claim 11 , further comprising a layout modification tool for modifying a layout of form controls.

18. The system of claim 11 , further comprising a style modification tool for modifying the appearance of the form.

19. 12. The system of claim 11, further comprising a computational learning engine that examines the form data for relative position to other fields, relationships to other fields, naming patterns of fields, fields on other forms, or patterns of forms within a given industry and generates pattern-based suggestions based on the patterns in the form data.

20. 12. The system of claim 11, further comprising a workflow generating means for generating a workflow based on a collection of transitions by initializing a collection of transitions including fields, presentations, form updates, assignment changes, or back-end updates using the declarative definition language and setting values ​​of the fields, the presentations, the form updates, the assignment changes, or the back-end updates.

21. 1. A system for dynamically defining and generating forms and workflows, comprising: a first input means for receiving instructions from a user for dynamically defining a form; form definition means, coupled to said first input means for receiving said instructions, for defining said form using a declarative definition language based on said instructions, said declarative definition language defining fields and presentation of said form; a generator coupled to said form definition means for generating runtime objects from said declarative definition language; a storage device for storing said form; a portable device for retrieving the form from the storage device over a network; a second input means coupled to said portable device for enabling a first user to input data into said form; and computing means, in response to the data being entered into the form, for performing a predefined calculation, evaluating the form data, and returning a result, said evaluating comprising: collecting a plurality of reference values ​​for said calculation, said reference values ​​being related to said form data and referencing each other; registering said plurality of reference values ​​together with information related to said calculation; and modifying, in response to a modification of one of the plurality of reference values, other reference values ​​of the plurality of reference values ​​that are affected by the modification, taking into account dependencies between the form data that uses the plurality of reference values ​​and the information related to the calculation; The system further comprises: A system comprising: a presentation renderer for rendering the form, the presentation renderer displaying the form on the portable device and using the runtime objects and the form data.

22. 22. The system of claim 21, further comprising a workflow generating means for initializing a collection of transitions including a field, a presentation, a form update, an assignment change, or a back-end update based on the instruction from the first input means, and generating a workflow based on the collection of transitions by setting values ​​of the field, the presentation, the form update, the assignment change, or the back-end update.

23. The method of claim 1 , wherein the calculation is evaluated according to a user-defined formula.

24. The system of claim 11 , wherein the calculation is evaluated according to a user-defined formula.

25. The system of claim 21 , wherein the predefined calculation is evaluated according to a user-defined formula.

Images