GENERATING A USER INTERFACE USING A DOMAIN SPECIFIC

LANGUAGE

5

CROSS REFERENCE TO RELATED APPLICATIONS

This application claims the benefit of priority of US. Application Serial No. 11/400,047 filed April 7, 2006, entitled "SYSTEMS AND METHODS FOR 10 GENERATING A USER INTERFACE USING A DOMAIN SPECIFIC LANGUAGE" which application is incorporated herein by reference.

FIELD

15 The embodiments of the present invention relate to generating user interfaces. More specifically, the embodiments relate to a domain specific language for generating a user interface.

LIMITED COPYRIGHT WAIVER

20

A portion of the disclosure of this patent document contains material to which the claim of copyright protection is made. The copyright owner has no objection to the facsimile reproduction by any person of the patent document or the patent disclosure, as it appears in the U.S. Patent and Trademark Office file 25 or records, but reserves all other rights whatsoever. Copyright © 2006 Lawson Software, Inc.

BACKGROUND

30 Business software applications play an important role in running almost every business in operation today. Applications such as general ledger, time and accounting, human resources and other applications enable business to run efficiently and comply with regulatory requirements.

Developing and modifying business software applications typically

35 requires the involvement of many people. For example, business analysts may be required in order to specify the functionality required by the application. Once the functionality has been id tifi d teams of software developers may

then be needed to create the software making up the application. As a result, creating and modifying business software applications, including the user interfaces for such applications, can be a labor intensive and expensive process.

5 SUMMARY

Systems and methods generate user interfaces using a description of a business ontology and a pattern language describing a layout for business objects in the business ontology. The layout description is analyzed and code may be

10 generated to produce the output layout according to the layout description. One aspect of the system and methods includes generating HTML code. A further aspect of the system and methods includes generating Java Swing code. A still further aspect of the systems and methods includes generating user interface code for a desktop application.

15 The layout description may describe a layout in a manner that is display device independent, and that does not rely on absolute positioning of elements. Business object data and fields within a business object may be positioned relative to one another and may further be positioned based on the order in the layout description.

20

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a diagram illustrating user interface components used in some embodiments.

25 FIG. 2 is a diagram illustrating the major components of a system according to embodiments of the invention.

FIG. 3 is a flowchart illustrating an exemplary method for generating a user interface according to embodiments of the invention.

FIG. 4A is a flowchart illustrating a method for processing panels of a 30 layout according to embodiments of the invention.

FIG. 4B is an example pattern language segment illustrating a definition of a panel.

FIG. 4C is an example screen output displayed according to the example pattern language segment of FIG 4B

FIG. 4D is a further example pattern language segment illustrating a definition of a panel.

FIG. 4E is an example screen output displayed according to the example pattern language segment of FIG. 4D.

5 FIG. 5A is a flowchart illustrating a method for processing a list of display fields according to embodiments of the invention.

FIG. 5B is an example pattern language segment illustrating a definition of a list of display fields.

FIG. 5C is an example screen output displayed according to the example 10 pattern language segment of FIG. 5B.

FIG. 6A is a flowchart illustrating a method for processing a form according to embodiments of the invention.

FIG. 6B is an example pattern language segment illustrating a definition of a form.

15 FIG. 6C is an example screen output displayed according to the example pattern language segment of FIG. 6B.

FIG. 7A is a flowchart illustrating a method for processing a composite form according to embodiments of the invention.

FIG. 7B is an example pattern language segment illustrating a definition 20 of a composite form.

FIG. 7C is an example screen output of a first page of a composite form displayed according to the example pattern language segment of FIG. 7B.

FIG. 7D is an example screen output of a second page of a composite form displayed according to the example pattern language segment of FIG. 7B 25 FIG. 8A is a flowchart illustrating a method for processing a paragraph section according to embodiments of the invention.

FIG. 8B is a flowchart illustrating a method for processing a column section according to embodiments of the invention.

FIG. 8C is an example pattern language segment illustrating a definition 30 of a paragraph section and a column section.

FIG. 8D is an example screen output displayed according to the example pattern language segment of FIG. 8C.

DETAILED DESCRIPTION

In the following detailed description, reference is made to the accompanying drawings that form a part hereof, and in which is shown by way 5 of illustration, specific embodiments in which the inventive subject matter may be practiced. These embodiments are described in sufficient detail to enable those skilled in the art to practice them, and it is to be understood that other embodiments may be utilized and that structural, logical, and electrical changes may be made without departing from the scope of the inventive subject matter.

10 Such embodiments of the inventive subject matter may be referred to, individually and/or collectively, herein by the term "invention" merely for convenience and without intending to voluntarily limit the scope of this application to any single invention or inventive concept if more than one is in fact disclosed.

15 The following description is, therefore, not to be taken in a limited sense, and the scope of the inventive subject matter is defined by the appended claims. In the Figures, the same reference number is used throughout to refer to an identical component which appears in multiple Figures. Signals and connections may be referred to by the same reference number or label, and the

20 actual meaning will be clear from its use in the context of the description. The functions or algorithms described herein are implemented in hardware, and/or software in embodiments. The software comprises computer executable instructions stored on computer readable media such as memory or other types of storage devices. The term "computer readable media" is also used

25 to represent software-transmitted carrier waves. Further, such functions correspond to modules, which are software, hardware, firmware, or any combination thereof. Multiple functions are performed in one or more modules as desired, and the embodiments described are merely examples. A digital signal processor, ASIC, microprocessor, or any other type of processor operating

30 on a system, such as a personal computer, server, a router, or any other device capable of processing data including network interconnection devices executes the software.

Some embodiments implement the functions in two or more specific interconnected hardware module d i s with related control and data

signals communicated between and through the modules, or as portions of an application-specific integrated circuit. Thus, the example process flow is applicable to software, firmware, and hardware implementations.

FIG. 1 is a diagram illustrating the major components of a system 100 5 according to embodiments of the invention. In some embodiments, system 100 includes development environment 102, parser 120, repository 122, layout analyzer 124, and code generators 126, 128 and 130. Development environment 102 may provide a graphical user interface useful in specifying a business ontology defining data and business rules to be applied to the data for a to a

10 business application under development. In some embodiments, development environment provides an interface for specifying a business ontology using a pattern language. In particular embodiments, the pattern language is the Lawson Pattern Language (LPL) developed by Lawson Software of St. Paul, Minnesota. In some embodiments, development environment 102 may place pattern

15 language elements into several different files depending on the functionality or data provided by the pattern language elements. In some embodiments, these files include a .webapp file 104, a .page file 106, a .menu file 108, a .busclass file 110, a .field file 112, a .keyfield file 114, and a .bustask file 116. .Webapp file 104 may contain pattern language elements that may be used to define

20 aspects of a business application. .Page file 106 may contain pattern language elements used to define one or more pages of an application. .Menu file 108 may contain pattern language elements used to define menus used by a business application. .Busclass file 110 may be used to contain pattern language elements defining various business classes for a software application. .Field file 112 may

25 be used to contain pattern language elements defining data fields used by business classes. .Keyfield file 114 may contain pattern language elements identifying key fields for one or more business classes. .Bustask file 116 may contain pattern language elements defining business tasks to be executed by a business application. Further details on the pattern language elements contained

30 in the above-described files will be described below.

Parser 120 parses the pattern language defining the data and business rules into business objects for storage in repository 122. In some embodiments, parser 120 reads the files described above and parses pattern language elements found in the files. In addition, pa 120 may parse pattern language elements

defined within the development environment 102 prior to the pattern language element being placed in a file. The business objects produced by parser 120 comprise a translation of the business rules and data into an object for that is more easily processed by a computer system. A BNF (Bachus Naur Form) 5 specification for LPL used in some embodiments is provided in Section A of this specification, entitled "Pattern Language BNF". The parser 120 may follow the syntax rules defined within the BNF in order to parse pattern language elements. In some embodiments, the business objects may be parsed into Java language objects.

10 Repository 122 is a database designed to store the business objects produced by parser 120. Repository 122 may be any type of database. In some embodiments, repository 122 may be a relational database. However, repository 122 may be a hierarchical database, an object-oriented database, or a database comprising one or more files in a file system. In some embodiments, the

15 repository includes a business ontology specifying the attributes and business rules for various business classes. A business class is typically a user defined set of attributes and rules that are related in some way. For example, a business class describing an employee may include attributes that specify the employees name, title, tax identification number, address, salary etc. Repository 122 may

20 also include user interface pattern language elements and security pattern language elements associated with the business class. User interface pattern language elements may be used to define how objects in the business ontology are presented to the user. For example, the user interface pattern language elements may define pages, menus, panes, and columns for displaying data

25 related to business objects. Further details on these pattern language elements will be provided below.

Layout analyzer 124 reads repository 122 to obtain the business objects, and the user interface pattern language elements used to define the layout for the business object data, and in conjunction with the current display properties (e.g.

30 display height, width and resolution) determines how the business object data defined using the business ontology are to appear to a user. It should be noted that the layout defined by the user interface pattern language is independent of the screen size and resolution. Additionally, the user does not need to provide positions for the user interface el t ther the user specifies the elements to

appear on the screen and the layout analyzer determines the positioning of the user interface elements. For example, if an application designer specifies using the UI pattern language that the output is to appear in two columns, the layout analyzer will fit the data into two columns according to the current screen height, 5 width and resolution. A Layout analyzer then uses code generators 126 - 130 to generate code to display the data in the objects defined using the business ontology.

In some embodiments, layout analyzer 124 invokes a Swing JFC (Java Foundation Class) to generate code to display business object data. The Swing 10 JFC is a toolkit providing a UI component library implemented in the Java programming language. The Swing package uses the windowing functionality of AWT and the rendering capabilities of the Java 2D API to provide UI components that comply with the JavaBeans specification. Further details on Swing may be found in the Java™ 2 Platform, Standard Edition, v 1.4.2 API 15 Specification.

In some embodiments, the layout analyzer invokes HTML generator 128 to generate HTML (Hyper Text Markup Language) code that displays the objects defined by the business ontology as a web page.

FIG. 2 is a diagram illustrating user interface pattern language elements 20 200 used in some embodiments. The user interface pattern language elements may include application elements 270, component (also referred to as container) elements 280, and core elements 290. In general, application elements 270 may contain component elements 280, which in turn may contain core elements 290.

Application elements 270 may include webapp 202 elements, page 25 elements 204, and/or menu elements 206. WebApp 202 defines elements for an application within a product line. The elements may include a home page, a navigation bar, a registration key and may determine whether anonymous access (e.g. access without specifying a user name/password combination) is allowed to the application.

30 Page elements 204 define one or more pages of an application. In some embodiments, a page may be composed of panels, and has a scoping level that is the same as a business class. As a result, a page may include data from multiple business objects in different business classes by defining one panel to have data

for objects in a first business class an another panel having data for objects in a second business class.

Menu elements 206 define menus for a user interface. In some embodiments, a menu element 206 specifies a list of one or more menu items 5 244 for the menu. Each of the individual menu items 244 may refer to other menu elements 206, page elements 204 or one of the component elements 280 described below. Further, in some embodiments, menu elements 206 may be nested within other menu elements 206 to create sub menus that are in-lined with the current menu definition. 10 In some embodiments, component elements 280 may include form elements 208, list elements 210, business task elements 230, panel elements 260 and pane elements 270. A form element 208 may be a basic form element 212, a composite form element 214, a matrix form element 216, a wizard form element 218 or a summary form element 220. 15 A basic form element 212 comprises a default style form. The basic form element includes fields that designate a title for the form, indicate whether the form is a primary form, indicate an action (e.g. "create", "read", "update", or "delete" or derivations thereof) associated with the form, and a layout for the form. The layout may include core elements 290 that are to be displayed within 20 the form.

A composite form element 214 is a specialized type of form that may include one or more panel elements, where each of the panel elements is either a type of form element 212-220 or a list element 210.

A matrix form element 216 is a specialized type of form in which the a 25 matrix of cells is displayed. The columns and cells may be defined as business object data. In addition, rows and columns of the matrix may be specified using links to related object (e.g. through key fields or other link mechanisms) so that related data may be displayed in the matrix.

A wizard form element 218 is a specialized type of form in which a first 30 form may be displayed. A "next" action is defined, which may be used to lead a user to a next form, list or page. In addition, actions may be defined to validate the form before the "next" step of the wizard form may be executed.

A summary form element 220 is a specialized type of form that provides for the display of business object d t i form, but typically does not provide

any actions that may be taken with respect to the form. For example, a summary form element may be displayed after a series of wizard form elements have lead a user through the steps in providing or updating business object data to show the end results of the wizard forms..

5 List elements 210 defines how a list of business objects in a particular business class may be displayed in a page, pane or panel. Conditions may be specified to select which business objects are displayed. Further, criteria may be specified to sort the list. In addition, actions such as create, read, update or delete a business object in a list may be specified within a list element. The data 10 for the business objects may be scrolled if more data is displayed than fits on a page, pane or panel.

A business task element 230 specifies a business action, process or transaction and any associated parameters and other attributes of a business related action, process or transaction that may be executed as a result of a menu 15 selection.

A panel element 260 defines a portion of a page. For example, if business objects for multiple different business classes are to be displayed on a page, multiple panels, one for each business class, may be defined for the page. Each panel may be defined to display business object data in a desired format 20 (e.g. list or form).

Pane elements 270 define panes for a panel element 260. hi some embodiments, a panel may be displayed as one, two, three or four panes corresponding to upper, lower, left and right portions of a panel. However, the embodiments are not limited to any particular number of pane elements for a 25 panel.

As noted above, lists and forms may be formed from core elements 290. In some embodiments, these core elements include one or more of form field 232, form button 234, form text 236, check control 238, link 240, header 242, menu item 244, and navigations 246. A form field 232 or a header 242 may 30 additionally specify a label 248 and/or a text style 250.

Form field 232 defines how a field is to be displayed for a form or list. Various parameters may be used to define how a field is to be displayed. For example, a field label may be defined for the field. Additionally, indentation and alignment (left, center, right), and li i e for the field may be defined.

Form button 234 is a user interface element that provides a specification of a button to be placed on the user interface. Form button 234 in some embodiments includes grammar elements that allow a user to specify label text to appear on the button, a condition specifying when the button is valid (i.e. 5 when the button may be enabled), a form to invoke upon activating the button or an action to perform upon activating the button.

Form text 236 provides a user interface element that allows a user to specify text to appear on a form.

Check control 238 includes grammar elements that allow a user to 10 specify a check box that appears on a form or list. In some embodiments, the user may specify a label for the check box, a condition indicating when the check box is valid, a field in a business object that contains the current state (checked vs. unchecked) of the check box, an action to perform when the check box is checked by a application user, and an action to perform when the check 15 box is unchecked.

Link 240 is an element that provides a link to another form, list, or external user interface (for example, a web page).

Header 242 includes grammar elements allowing a user to define a header for a list or form. In some embodiments, the user may specify a header 20 message and a header style to control how the header is presented.

Menu item 244 provides grammar elements for defining an individual menu item within a menu 206. The grammar elements define what happens when the menu item is selected by an application user. In some embodiments, the grammar elements allow an application designer to specify a page, list or 25 form to be displayed upon selection of the menu item. Further, the menu item may define an action (e.g. a business task) to be performed if the menu is selected. Also, the menu item may specify an HTML link to be invoked upon menu item selection. Additionally, the menu item may cause another menu to be displayed upon selection.

30 Navigation 246 allows an application designer to specify a link to a URL, page, form or list that is displayed upon selection of the navigation element.

Label 248 is a grammar element that provides a mechanism for an application designer to associate a label with a field 232 or header 242. The

10

label may provide text for a description or indicator of what the field or header is used for.

Text style 250 is a grammar element that provides a mechanism for an application designer to have different text styles applied to display elements such 5 as form fields 232 or header 242. The text style may specify that the text for a field or header is to be left, right, or center justified. In addition, the text style may specify that the text is to be displayed in a bold or italic style.

Further details on the elements described above are provided in Section A, entitled "Pattern Language BNF", which is a BNF (Backus Naur Form) 10 definition file providing a syntax and grammar definition for a pattern language used in some embodiments of the invention.

FIGs. 3, 4A, 5A, 6A, 7A and 8A illustrate flow diagrams of methods generating a user interface from grammar elements in a pattern language. The methods to be performed by the operating environment constitute computer 15 programs made up of computer-executable instructions. Describing the methods by reference to a flowchart enables one skilled in the art to develop such programs including such instructions to carry out the methods on suitable computers (the processor or processors of the computer executing the instructions from computer-readable media such as ROMs, RAMs, hard drives, 20 CD-ROM, DVD-ROM, flash memory etc. The methods illustrated in FIG. 3, 4A, 5A, 6A, 7A and 8A are inclusive of acts that may be taken by an operating environment executing an example embodiment of the invention.

FIG. 3 is a flowchart illustrating an exemplary method for generating a user interface according to embodiments of the invention. The method begins by 25 receiving a business ontology (block 302). The business ontology may include business objected defined based on business classes specified using a pattern language. In some embodiments, the business objects definitions are parsed and stored in a repository.

Next, the system receives a layout specification for the business objects 30 in the business ontology (block 304). In some embodiments, the layout specification is provided using grammar elements defined in the pattern language used to define the business objects. As discussed above, the layout specification may include definitions for pages, menus, panels, forms, lists and menus. In addition, the layout sp ifi ti may specify how fields are to appear

11

on forms and lists. In some embodiments, the layout specification is defined without reference to absolute positioning of the various elements. Rather, the layout specification identifies the display elements that are to appear on the screen, and in some cases a relative positioning or order. For example, panes 5 may be specified as appearing in an upper or lower position, or in an upper left, upper right, lower left, or lower right position. Further, some display elements may be specified to occupy a particular percentage of the available page, panel, or pane size. Additionally, some display elements may be specified as occupying a particular number of lines on a display.

10 The system then determines the output layout according to the layout specification and the output characteristics (block 306). In some embodiments, the system determines the positioning of the various user interface elements defined in the layout specification based on the available screen output characteristics (e.g. screen height, width and resolution). Further details on 15 various layout processing are provided below with reference to FIGs. 4A - 8D.

The system then generates code to display the user interface elements specified by the layout description and as determined by the output layout (block 308). In some embodiments, HTML code may be generated. In alternative embodiments, Java code conforming to the Java Swing API may be generated. 20 In further alternative embodiments, code conforming to a Microsoft Windows desktop API may be generated.

FIG. 4A is a flowchart illustrating a method for processing a page of a layout according to embodiments of the invention. The method begins by determining one or more panels defined for a page (block 402). For a panel on a 25 page, the system begins initial processing of the panel (block 404).

The system determines if the panel is a multi-pane panel (block 406). If the panel has multiple panes, the system performs steps 412 and 414 for each pane (block 410). The system processes a list associated with the pane (block 412). As noted above, the list may contain any of core elements 290 described 30 above. The system determines the placement of each of the elements defined in the list within the pane. The list is then added to the panel.

If the panel is not a multi-pane panel, the system then determines if the panel is a menu form panel (block 408. If not, the panel is a list panel and the

12

system performs blocks 412 and 414 as described above to place the list in the panel.

If the panel is a menu form panel, the system proceeds to block 420 to process the form. As discussed above, a form definition may include various 5 types of core elements 290 as described above. The system determines the placement within the form of each of the core elements defined for the form. The completed form is then added to the panel (block 422).

FIG. 4B is an example pattern language segment illustrating an example definition 430 of a page having multiple panels 432.1 - 432.6, including a panel 10 defined as having multiple panes 434.1 and 434.2.

FIG. 4C is an example screen output displayed according to the example pattern language segment 430 of FIG. 4B. Tabs 442.1 - 442.6 correspond to panels 432.1 - 432.6 respectively. Additionally, panes 444.1 and 444.2 are displays according to pane definitions 434.1 and 434.2 respectively. 15 FIG. 4D is a further example pattern language segment illustrating an example pattern language definition 450 of a single panel page. FIG. 4E is an example screen output displayed according to the example pattern language segment of FIG. 4D.

FIG. 5A is a flowchart illustrating a method 500 for processing a list of 20 display fields according to embodiments of the invention. The method begins at block 502 by determining the display fields in a list. The system then creates a column for each display field in the list (block 504). In some embodiments, the column width is determined by giving each column the same width in the available panel width. In alternative embodiments, the column width may be a 25 function of the field width. Additionally, the column width may be specified as a percentage of the available panel width. Further details on column processing according to embodiments of the invention are provided below with reference to FIG. 8B.

FIG. 5B is an example pattern language segment 510 illustrating a 30 definition of a list of display fields. In the example provided, five column definitions 512.1 - 512.5 have been specified. FIG. 5C is an example screen output 520 displayed according to the example pattern language segment of FIG. 5B. Columns 522.1 - 522.5 are the resulting output according to definitions 512.1 - 512.5 respectively.

13

FIG. 6A is a flowchart illustrating a method 600 for processing a form according to embodiments of the invention. In some embodiments, the method begins at block 602 by processing each section defined for the form. A section may be one of the container elements 280 or a one of the core elements 290. 5 The method starts at block 602 by determining the sections in the form. For each section, blocks 604-640 may be selectively executed. At block 604, the system checks to determine if the current section is the first section to be processed. If so, the system proceeds to block 606 to place a vertical spacer on the screen. The spacer may run the full width of the screen. The system the 10 proceeds to block 608 to processing the section. At block 610, the system checks to determine if the section is a header section. If so, the system processes the header section at block 612 by placing the text defined for the header on the form, in the style defined for the header.

At block 614 the system checks to determine if a paragraph section is 15 being processed. If so, the system proceeds to block 616 to process the paragraph. Further details on paragraph processing are provided below in FIGs. 8A - 8C.

At block 618 the system checks to determine if the section is a column section. If so, the system proceeds to block 620 to process the column. Further 20 details on column processing are provided below with reference to FIG. 8B.

At block 622 the system checks to determine if a field section is being processed. If so, the system proceeds to block 624 to process the field section. Processing a field section at block 624 includes placing the field data on the form according to the indentation, alignment and text styles associated with the 25 field. In addition, if a label has been defined for the field, the label is placed on the form. Further, the field may be restricted to a specified number of lines in a text area for the field.

At block 626 the system determines if the section is a button section. If so, the system proceeds to block 628 to process the button section. Processing a 30 button section may include placing a button image on the form and a label for the button within the button image. The label may be left, center or right justified as specified by the application designer in the pattern language section.

At block 630 the system determines if the current section is a text section. If so, the system proceed t bl k 632 to process the text section. The

14

text section may be defined as a string of text to appear on the form. The text section may have a text style indicating if the text is to be bold faced or italicized. In addition, a text section may be defined as a blank line to provide spacing on the form.

5 At block 634 the system determines if the section is a menu item section.

If so, the system proceeds to block 636 to process the menu item section. The system places the menu labels for each menu item in the section on the form.

At block 638 the system determines if the section is a form. If so, the section is a form nested within a form. The system proceeds to block 640 and 10 recursively processes the new form according to method 600 as described above.

In each case listed above, after processing the appropriate section the system returns to block 604 and processes the next section until all sections of the form have been processed.

FIG. 6B is an example pattern language segment 650 illustrating a 15 definition of a form. FIG. 6C is an example screen output 660 displayed according to the example pattern language segment of FIG. 6B.

FIG. 7A is a flowchart illustrating a method 700 for processing a composite form according to embodiments of the invention. The method begins at block 702 by determining if a form has been specified as a composite form. If 20 so, the system proceeds to block 704 to process the initial form of the composite form. Details on form processing have been provided above with reference to FIGs. 6A -6C. In some embodiments, the initial form is placed in the upper section of the composite form.

The system then proceeds to block 706 to process each panel in the 25 composite form according to blocks 708-712. At block 708 the system determines if the current panel is a form panel. If so, the system proceeds to block 710 to process the form panel as described above in FIGs. 6A - 6C. After the form has been processed, it is placed in a tab of a tabbed folder widget. If the current panel is not a form panel, the system proceeds to block 712 to 30 process the panel as a list. The processed list is then placed in a tab of a tabbed folder widget for the composite form.

FIG. 7B is an example pattern language segment 720 illustrating a example definition of a composite form. The example definition is a composite form providing two panels 722.1 d 722 2

15

FIG. 7C is an example screen output of a first page 730 of a composite form displayed according to the example pattern language segment of FIG. 7B. Tabs 732.1 and 732.2 are tabs associated with panels 722.1 and 722.2 respectively. FIG. 7C represents the display when tab 732.1 has been selected. 5 FIG. 7D is an example screen output 740 of a second page of a composite form displayed according to the example pattern language segment of FIG. 7A. Screen output 740 is displayed when tab 732.2 has been selected.

FIG. 8A is a flowchart illustrating a method 800 for processing a paragraph section according to embodiments of the invention. A paragraph 10 defines a group of user interface elements that are to appear together. The method begins at block 802 by determining the sections to be processed in the paragraph. Blocks 806 - 820 may be selectively processed for each section. At block 806 the system determines if the current paragraph line is full. If so, at block 808 the system creates a new line for further display of paragraph data. At 15 block 610 the system processes the current section. At blocks 812-818, the system determines if the section is a field section (block 812), a button section (block 814), a text section (block 816), or a menu item section (block 818). Upon determining that the section is one of those listed above, the system proceeds to block 820 to process the section on the next available column in the 20 current paragraph line. The system then returns to block 804 to process the next section until all sections have been processed.

FIG. 8B is a flowchart illustrating a method 830 for processing a column section according to embodiments of the invention. The method begins at block 832 by determining the sections to process in a column section. Block 836 25 determines the sections in the column section, and places the sections evenly into columns. In some embodiments, the sections are placed evenly into columns from top to bottom and from left to right. The columns and rows within a column define cell locations for the column section. At block 838, the system proceeds to process the current section. At block 840, the system determines if 30 the current section is a paragraph section. If so, the system processes the paragraph section as described above with reference to FIG. 8A. At block 852, the processed paragraph section is placed in the next available cell location.

At block 844-850, the system determines if the section is a field section (block 844), a button section (bl k 846) text section (block 848) or a menu

16

section (block 850). If the section is one of the types listed, then the system proceeds to block 852 to process the section and place the section into the next available cell. Processing for the types listed has been previously described.

FIG. 8C is an example pattern language segment 860 illustrating example 5 specifications of a paragraph section and column sections. FIG. 8D is an example screen output 870 displayed according to the example pattern language segment 860 of FIG. 8C.

The Abstract is provided to comply with 37 C.F.R. § 1.72(b) to allow the reader to quickly ascertain the nature and gist of the technical disclosure. The 10 Abstract is submitted with the understanding that it will not be used to limit the scope or meaning of the claims.

In the foregoing Detailed Description, various features are grouped together in a single embodiment for the purpose of streamlining the disclosure. This method of disclosure is not to be interpreted as reflecting an intention that 15 the claimed embodiments have more features than are expressly recited in each claim. Thus the following claims are hereby incorporated into the Detailed Description, with each claim standing on its own as a separate embodiment.

The foregoing descriptions of specific embodiments of the present invention have been presented for purposes of illustration and description. The 20 embodiments presented are not intended to be exhaustive or to limit the invention to the particular forms disclosed. It should be understood that one of ordinary skill in the art can recognize that the teachings of the detailed description allow for a variety of modifications and variations that are not disclosed herein but are nevertheless within the scope of the present invention. 25 Accordingly, it is intended that the scope of the present invention be defined by the appended claims and their equivalents, rather than by the description of the embodiments.

17

Section A

Pattern Language BNF

Lawson Pattern Language Key for Text Styles

Comments

Examples

Pre-defined

********************************************************* ***********************************

General LPL Definitions

LPLConstructName := <uppercase character) [<alphanumeπc characters) ] // up to 255 characters

ActionName : = <LPLConstructName>

BusinessClass = <LPLConstructName>

BusinessTask = <LPLConstructName>

ConditionName = <LPLConstructName>

FieldGroupName = <LPLConstructName>

FieldName : : = <LPLConstructName>

FormlnvokeName = <LPLConstructName>

FormName = <LPLConstructName>

ListName = <LPLConstructName>

MajorSystemProcess : : = <LPLConstructName>

MatrixForm : : = <LPLConstructName>

MenuItemName : <LPLConstructName>

MenuName : <LPLConstructName>

Movexlnterface : <LPLConstructName>

NavigationName : <LPLConstructName>

PageName ; <LPLConstructName>

PanelName : <LPLConstructName>

RelationName : <LPLConstructName>

SetName : <LPLConstructName>

StateName : <LPLConstructName>

TableName : <LPLConstructName>

WebAppName : : = <LPLConstructName>

KeyField : := <keyfield FullFieldName> ViewField ::= <view FullFieldName>

Literal ::= <anγ character except whitespace or angle brackets) ModuleDescription : : = <Literal>

ModuleName ::= <alphanumeric characters>

Prefix : := <stπng of 2 to 5 uppercase alphanumeric characters)

Text : := <alphanumeric characters>

Number ::= [ -] <numeric characters> [. <numeπc characters)]

Percent : : = <Number>%

Constant : : = ( true

I false

I blank )

Value : : = ( "" <Text> ""

I <Number>

I <Percent> I <Constant>

FullFieldName ( <FieldName> [ . <FieldName> ] I <CreateStamp> I <UpdateStamp>

)

CreateStamp ::= create stamp [. actor ] // this references the CreateStamp in the business class

//by itself it is the actual TimeStamp when the instance was created

//the actor keyword references the actor who created this instance

UpdateStamp ::= update stamp [. actor ] // this references the UpdateStamp in the business class

//by itself it is the actual TimeStamp when the instance was last updated

//the actor keyword references the actor who last updated this instance

BusinessObjectReference : := <FieldName> //Field that is of type BusinessObjectReference

LinkOperator first last

FieldOperator : : = ( not // Valid only with a Condition

I I // "

I no // "

I any // Valid only with multi-valued (array, otm) RelatedField oi

RelatedCondition

I al l // "

I f irst // "

I last // "

I old

I each // "

I sum // "

I f loor

I ce iling

I instance count of // "

I s i zeofarray

I ( f irst I last ) iterat ion of // Valid only with a OTM RelatedLink

I next // Valid only on Iteration fields

I previous // " I reference to // Valid only with an OTO RelatedLink — returns the

//BusinessObjectReference of the RelatedLink

TypeOperator decimals // Valid only with a Decimal type field year // Valid only with Date and TimeStamp fields month // " day // " week day // " — 1 -based week day number (1-7) year day // " — 1-basedyear day number (1-366) week // " — 1 -based week day number (1-52) hours // Valid only with Time type fields - Decimal total number of hours since

//beginning of day minutes // " — Decimal total number of minutes since beginning of day seconds // " — Decimal total number of seconds since beginning of day date // Valid only with TimeStamp type fields time // Valid only with TimeStamp type fields levels // Valid only with array fields. Defines number of entries up to and including last entered value entrie s // Valid only with array fields. Defines number of entered fields in the array compact format // Valid only with afield that implements CompactFormat )

RelatedLink ( <LinkOperator> | <FieldOperator> ) ]

<KeyField> [[sub-hierarchy] set]

<RelationName>

<BusinessClass> [ ' ( ' <KeyField> ' ) ' ] [ set ]

<BusinessObjectReference> [ ' ( ' <BusinessClass> ' ) ' ]

[ actor . ] agent [ ' ( ' <BusinessClass> ' ) ' ] this instance <RelatedLink>

// <RelatedLink> option is to indicate that you can string related links, that it is recursive;

// for example, KeyField.RelationName.KeyField.RelationName. Field

// The BusinessClass in a "BusinessClass set" must either have a "part of ontology to

// the preceding item or it must have afield that is one of the symbolic keys of the preceding item

// If there is more than one field that matches the preceding items symbolic keys then

// '('<KeyFie!d> ')' must be present to disambiguate which one is desired

//A BusinessObjectReference must have a BusinessClass designation if it has not been defined

// as a particular kind of BusinessClass

// If this business class is an Agent then another agent that has been linked to this agent can be

// addressed with the ' agent(<BusinessClass>) ' designation. To access any agents that the current

// actor has been linked with simply add the actor' keyword in front of the agent keyword.

/I 'sub-hierarchy ' is only valid when the KeyField implements the Hierarchy pattern

//A <LιnkOperator> can go on each <RelatedLmk> in a Related Link chain; however, a

// <FιeldOperator> can go only at the beginning of a Related Link chain

RelatedReference : : = related each invoked result

RelatedField : = [ <FieldOperator> ]

[ (<RelatedReference> <RelatedLink> ) . ] <FullFieldName> // <FullFieldName> is optional with the FieldOperators

// instance count of and (first | last) iteration of

[ <TypeOperator> ]

RelatedValue : : = ( <RelatedField> [ . <StateName> ] // StateName is one of the States defined on the RelatedField

I <Value>

I <NativeMethod>

I <ParentContext>

I <Actor>

I <CurrentDateTime>

I <CreateStamp>

I <UpdateStamp>

I <ConfigVar>

I <SessionKey>

)

RelatedCondition := [<FieldOperator>] ( [<RelatedLink> . ] <ConditionName>

I <RelatedField> . <StateName> I <NativeMethod>

SymbolicKeyVar ::= symbolickey name //default; the actual name of the KeyField, for example Vendor instancekey // the actual KeyField, for example Apinvoice. Vendor

ParentContext : := parentcontext . ( isbusclass

I name

I stereotype

I istransaction

I module

I <SymbolicKeyVar>

I isbustask

)

//datacontext refers to the parent context of the current context

// symbolickey retrieves the context information of the Symbolic Key that this business object is 'centered' on. // If the business object is not defined directly via a Symbolic Key but is defined as being 'part of some other //business class then it gets the context information of the Symbolic Key of that business class

ConfigVar ::= config. <Literal>

//Allows reference to a configuration variable. Configuration variables are found in configuration // property files. Literal is a property name in one of the configuration property files. If it is not //found it is blank.

SessionKey : := session . key . <FieldName>

//Allows reference to a session key. Session keys are high level KeyField values typically tied to the // invocation of a WebApp by specifying them on the url (e.g "session key.SupplierGroup=818I ")

ActorAttribute : : = <actor FieldName // Field on Actor.busclass in environment product line

Actor : : = actor [ . ( <ActorAttribute> | context . <FieldName> ) ]

// actor by itself is the current actor which is represented by the Actor KeyField in the environment product line // context . <FieldName> is any KeyField within this product line — actors can have any keyfield //within the system defined as a context field with a specific value (e g. Company = I for actor ApClerkl)

CurrentDateTime current time current date current year current period current timestamp current anniversary

ArrayComponent ::= ( <arraγ RelatedField> I <arraγ RelationName I ArrayRangeAddress

I <special index SingleValueArrayAddress>

)

//A Field or a Relation can be an array. A Relation becomes an Array Relation when one of the Values //being mapped to the index value is an array (this is done using the each operator). A Field becomes an // array when it is an ArrayField or when it is a derived field that contains an ArrayField without a single //subscript denoting a specific occurrence. The RelatedField expression (A + each B) where B is an //ArrayField of size 10 returns an array of size 10 where A is added to each occurrence of B. More complex // array expressions are defined below. An ArrayRangeAddress is a subset of an array that can result in a // single occurrence or even no occurrence. A special index SingleValueArrayAddress is an array // with a specific special index variable associated with it By default all ArrayComponεnts are associated with // the special index variable i except when two arrays are used in an expression where it is ambiguous as to //how to associate their respective occurrences. For example, (Array 1 * Array!), is the result a single // dimension array or a two dimension array

I : : = ( i I 3 I k )

// These are internal array indexing variables, which are for special use only within array expressions // Their purpose is to allow the explicit mapping of multiple array occurrences in a single expression // The i variable is implicitly used and is accessible in any array expression, for example, for each // <ArrayComponent> is equivalent to for each <ArrayComponent> [1=1 : arraysize] ; so the // special index variable i can be used to explicitly address an occurrence within the Zot loop. This can be // useful for comparing the current occurrence with the next occurrence' if (A [i] == A [i+1] ) . //Any Array indexed with a special index is still considered an ArrayComponent as it implicitly means //all occurrences in the absence of any array occurrence context.

SizeOfArray ::= sizeofarray [ <ArrayComponent> ]

// sizeofarray returns the size of the first array component in the ArrayComponent (an ArrayComponent //can be made up of several Array Components).

IndexVariable : := ( <RelatedValue>

I <i>

I <SizeOfArray>

)

//Arrays are indexed beginning with 1. The first occurrence of an array is denoted with an index of 1. //An index variable can be a RelatedValue that is not an array or the special index variables ι, J, and k.

SingleValueArrayAddress : := <ArrayComponent> ' [ '<IndexVariable> ' ] '

//A specific value in an array is addressed by using hard brackets [ ] to denote the

// index of the specific occurrence. The special index variables only have meaning when used within

// an array context that is an ArrayExpression or a for each <ArrayComponent> scoped statement

ArrayRangeAddress ::= <ArrayComponent> ' [ ' [<I>=] <from IndexVariable> :<to IndexVariable> ' ]

// This expression defines a subset range of the ArrayComponent denoted by two index variables the //from IndexVariable and the to IndexVariable. The to IndexVariable is inclusive. The size of this array // is (to IndexVariable —from IndexVariable) + 1.

Examples of Array Expressions

A = ArrayField [5]

A = ArrayRelation [1 ] .FieldName

A = sum ArrayField which is equivalent to

A = sum ArrayField [1 : sizeofarray] which is also equivalent to

A = sum (ArrayField [j ]) [ ]=1 : sizeofarray ArrayField]

A = sum ArrayRelation . FieldName

This example searches each relation and returns true if it finds a match

If (FieldName == any ArrayRelation . FieldName)

This example multiplies each occurrence ofArrayl with the respective occurrence of Array2 returning a single dimension array of the same size as Array2 and then sums up all the values.

A = sum (Arrayl [i] * Array2 [i] ) [i=l : sizeofarray Array2 ]

This example shifts the array 1 to the left leaving the last value the same.

Arrayl = Arrayl [i+l] [i=l : sizeofarray-1 ]

This example shifts the array 1 to the left and fills the last value with blank. This is because an out of bounds array access results in the blank value

Arrayl = Arrayl [i+l] [i=l : sizeofarray]

A = (ScalarValue + each ArrayValue) which is equivalent to A = (ScalarValue + ArrayValue [i] [i=l : sizeofarray] ) which is also equivalent to

A = ( ScalarValue + each ArrayValue [ 1 : s izeof array] ) The result of this example is a single dimension array the size of ArrayValue where each occurrence of ArrayValue has ScalarValue added to it

NativeMethod ::= [ <ClassName> .] <MethodName> '(' [<Param>, ...]')'

//Ifthe ClassName is not specified, the method must be an instance method in THIS class

ClassName ::= Java Class MethodName : := Java Method

Param ::= ( <RelatedValue> [as <JavaType>]

I null

JavaType : : = ( Fie ld

I String

I int

I Integer

I DateYMD I // all possible Java Types

Message : : = ' " ' <Literal> [ ' < ' <RelatedValue> "> ' ... [ <Literal> ] .. ] . . ""

//Literal cannot have spaces or angle brackets

// "CompanylsRequired" will display the message "Company is required" // " Company <Company>IsRequιred will display the message "Company 123 is required"

PrimitiveType ::= ( Alpha

AlphaRight

AlphaUpper

Anniversary

BinaryDocument

BinaryObject

Boolean

BusinessObjectReference [to BusinessClass ]

Date

Decimal

DocumentTitle

Integer

Iteration of <BusinessClass>

MimeType

Numeric

Password

Percent

Period

Text

Time

TimeStamp

UniquelD

Year

)

FrameworkMetaType : : = Actor // Typically, these are used only in the underlying framework

ChangeStamp

DataAreaName

LogDocument

LPLName

ProductLmeName

FieldSize ::= <numeric characters> NbrDecimals ::= <numeπc characters>

TypeDataDefinition :: = <PrimitiveType> [[size (fixed | up to)] <FieldSize> [ . <NbrDecimals>] ]

//up to means this is a variable size field (for example, varchar)

// fixed is the default, however a warning is generated on any non up to type that is 30 spaces or more

//unless fixed is designated. Valid only on Alpha and AlphaUpper.

//FieldSize is the overall size of the field. A Decimal field of size 12.2 means 12 total digits

// of which 2 are the number of digits after the decimal

DataDefinition ::= ( is a[n] <FieldName>

I is <TypeDataDefinition>

)

//Needs to have a standard set of "system "fields: product line, module, and so on

States : :=

States

<StateName> value is <Literal> [ = <StatesText>]

StatesText : : =

// This is any text within quotes; currently it is for backward compatibility. It is really the translation text that //needs to be stored in some International Translation mechanism, whatever that it going forward.

SqlName : := sql name is <Literal>

ClassicName ::= classic name is <Literal>

ClassicNameForField : := classic name for <FullFieldName> is <Literal>

********************************************************* ***********************************

Product Line Definition File

_{******************************************************* *************************************}

// The Product Line Definition file exists in the product line directory and is named prodline. IpI

BusinessClass

Standard Patterns

// This section defines patterns that automatically apply to all business classes in the product line [implements CRUD] [implements CreateStamp]

// This pattern puts a CreationStamp field on the business class [implements UpdateStamp]

//Discussion of Context

//In general a context field is similar to a parameter on a function. The key difference is that a parameter on a function must be explicitly passed

//and is therefore 'hard-wired' whereas a context field automatically searches its 'context' to find the appropriate field to hook up to If the

// Employee field has a context field of Company , then when it is put on some business class, it searches the fields on that business class

// seeking to find one that matches up with Company A match is found when the type of the context field matches the type of some target field

// The context field will match if it finds a supertype but will not match if it finds a subtype Therefore APCompany matches to Company but

/I Company does not match to APCompany The search must find an unambiguous reference within a field group level The search starts

// with the local field group level and if a match is not found it goes up a level. It keeps doing this until it either finds a match or runs out of levels.

// The search never goes down a level or into a GroupField at the same level, which is considered to be going down a level.

// There are two key usages of context fields: ontological and regular. Ontological context fields define the affordance structure of a KeyField These //fields are only resolved within the context of a business class Non-optional ontological context fields must be resolved at compile time or an error // will result If a regular context field does not find a match within the context of its business class then it will match dynamically based on its usage. //It will dynamically go outside of the context of its business class to find a match. For example, Worke rsCompClass is a KeyField with a regular // context field called EjfectiveDate. It is placed on the business class JobCode. Because Jobcode does not have an EjfectiveDate on it the context field // is dynamically resolved. The business class TimeRecord has a JobCode KeyField on it, and an EffectiveDate The reference

// JobCode. WorkersCompClass. Rate from the context of the Timerecord business class causes the Worke rsCompClass field to search TimeRecord' s //fields at the same level and above as JobCode and hooks up with TimeRecord EffectiveDate

//A context field can have rules associated with it to determine its value. The special field operator in context is provided to allow for rules based on // whether the context field is found in the context or not.

Example

Per iodCalendar is a Field

Representation Fields

FiscalYear NbrPeπods PeπodEndDates

Context

RunPeπod is an AccountPeriod if (RunPeπod not m context) value is index of first PeriodEndDates . Date >= RunDate

RunDate is a Date if (RunDate not m context) if (RunPeriod not m context) value is current date else value is PeriodEndDates . Date [RunPeriod]

********************************************************* ***********************************

Field LPL Definitions (.field and .keyfield)

Field Structure : : =

<FieldName> is a (Field | KeyField)

[owned by <ModuleName>]

// If not defined then field is global and put in the field' package

[(<SqlName> | sql prefix is <Prefix> ) ]

// sql prefix is for Group Field only; SqlName not valid on a Group Field

//Every duplicate group field type instantiation in a Business Class or GroupField requires a "prefix is ¹ ' //predicate. This lets us add the prefix to all the group field names. Currently, the kludge for the prefix // on a GroupField instantiation in a Business Class is sql prefix is XXX

[ <ClassicName> ]

[text searchable]

[case insensitive compare]

//Means this field will preserve case but all comparisons and record selection will be done //case insensitive If this field is in an index (or a key field), it will be in the index as though it is //always uppercase. That is, uniqueness of this field within its context will be case insensitive.

[store in compact format of <TypeDataDefinition> ] [Format Uses]

[<RelatedField> ...]

// This stores the field in a special internal compact format It is very useful for storing complex group fields

//or arrays that have variable sizes and do not require special SQL indexing or SQL tool visibility.

// Typically this is only used for meta-infiormation about the application, such as List Criteria or Compute

// Statements.

// The format mechanism can overridden and passed specific fields by using the Format Uses phrase.

// This is useful for something like VariableLevels.

[extends <FieldName>]

[name is <Literal>]

// If a field extends another field, it cannot specify a new representation Both KeyFlelds and Fields can be

// extended. An extended KeγField typically specifies an additional business class that contains the particular

// instances of the new KeyField although this is not required. An extended Field typically sets some context

//variable of the base Field

//An example of a KeyField being extended with a new business class is Company. Company might be extended

// as a new field called APCompany with a business class of ApCompany Jf the business class for Company is

// Glsystem, each instance of an ApCompany must also be an instance of a Glsystem, whereas each instance of

//a Glsystem might not be an instance of an ApCompany.

//An example of a KeyField being extended without a new business class being defined is PersonnelCode.

// PersonnelCode has a Context variable called PCodeType and it might be extended as a new field called

// LocationCode with PCodeType set to PCodeType Location (one of its states).

//An example of a Field being extended is Currency Value. CurrencyValue has a context variable called lsRate

//and might be extended as a new field called CurrencyAmount with IsRate set to false

Representation

Ontology

Patterns

Display Fields

Surrogate For

Context Fields

Transient Fields

Local Fields

Derived Fields

Conditions

Relations

Field Rules

Representation

[ <FieldRepresentation> ]

/IA KeyField might not have a representation This is useful when the KeyField is the symbolic key of a business // class that implements the Specialization pattern The field can still be put as a Persistent field in a business class

//to dynamically reference the appropriate related Specialization

FieldRepresentation ::= ( <SimpleField> I <GroupField> I <ArrayField>

)

SimpleField : : = type <DataDefinition>

[ <States> ] // <States> is not indented under type because indentation implies some form of ownership or detail declaration.

//In this case, <States> describes the Field's defintion and not the Representation' s defintion

GroupField : :=

Group Fields

<FieldName> [<DataDefinition>] [<SqlName>] [ ClassicName ]

[text searchable] [<States>]

ArrayField ::= //ArrayFieldis validonlyfora Field

<FieldName> [<DataDefinition> ] occurs (<Literal> | sizeofarray <ArrayField> ) times

Ontology // This section is valid for KeyFields only

[stereotype is <Stereotype> ] business class is <BusinessClass>

// This is the business class that contains the instances of this KeyField. // This business class must specify this KeyField as its symbolic key. [ existence not required ] [when <context FieldName> . ( <ConditionName> | <StateName> ) ]

// This makes the business class designation conditional, which means multiple business classes can be defined // If the last one defined is conditional and the key value is not found, no error will be given. If the last business //class is not conditioned, the key value must be found in one of the business classes. [ Field Mapping use s <SetName> ]

// This is used only to override the access mechanism to the business object. This need comes about when the //business object is not capable of specifying this KeyField as its key. An example of this is the PrSystem // object and the Company KeyField PrSystem contains both Companies and ProcessLevels. <BusinessClass> . <FullFieldName> <Relationpperator> <RelatedField>

Context

// The ontological context defines the affordance structure. Typically there is only a single KeyField in an // affordance structure. If the single Keyfield itself has an affordance context KeyField, that KeyField is also // implicitly part of this KeyField 's affordance structure If there are two KeyFields in an affordance context, it // means that the second one is not afforded by the first one, therefore there is a dual affordance structure. The //first key can be a surrogate for the higher level context of the second key. <KeyField>

[value is <RelatedValue> ]

//A Context key can be set to a specific value. Typically this only happens when the key is extending another // key that has this Context key An example is BargainingUnit, which extends Pcode and sets Pcode 's /I ' PcodeType context to 'BU'

[ ( delete restricted I delete cascades I delete ignored

)]

//delete restricted is the default

[ optional ]

// 'If one of the Context Keys is optional, there must be a higher level Context Key specified even though // the first Context Key implicitly refers to it. This makes it clear that this KeyField can be afforded at both // levels and allows for the delete rule of the higher Context Key to be specified. This higher level Context // Key that is not optional is the group level key; this is the key level at which effective dating is done when //effective date as a group is specified in a Specialization pattern.

[ ( enable | disable ) surrogate context ] // enable is the default

// If a context KeyField has a surrogate, by default this surrogate field is put on the business class // and a secondary index is created so that this field can be validated from either the primary context //or the surrogate context

// If a Key Field extends another keyfield the default name of that key field is the highest level field name in the // extends chain. This can be overridden with a "name is " clause This situation may be nuanced such that when //a keyfield extends another keyfield but has a context value set, then that field should have a default "name is" //oflhe keyfield name itself.

Stereotype : := ( OurCompany

I Agent

I BusinessPolicy

I AbstractGroup

I Document

I DocumentDistribution

I DocumentFulfillment

I AccountingTransaction

)

//Stereotypes are grouped into two classes, transaction and non-transaction. The Transaction stereotypes are //Document, DocumentDistribution, DocumentFulf illment, and AccountingTransaction.

Patterns

[implements MutuallyExclusive ] field determiner is <RelatedField>

<StateName> field is <FieldName>...

// Only valid in a GroupField. This pattern causes the GroupField to behave as though it is only a // single field that has a dynamic type The single field within the Group Field is determined by the //defined "field determiner" <RelatedFιeld> which must be a state field <StateName> must be a defined /I state on <RelatedFιeld> All states on RelatedFleld must be specified [ implements FieldRange ] from i s <FieldName>

[exclus ive ] to is <FieldName> [exclus ive ]

// This pattern is only valid within a GroupField. A from of blank means low-value and a to of blank //high value. To must always be greater than from. Inclusive is the default. This designation allows // the "within " operator and the "overlaps " operator to be used with this field [ implement s CompactFormat ] [ de limiter i s <Literal> ]

// This pattern allows a GroupField or an ArrayField to be entered as a single string each field //being delimeted by the designated delimiter An implication of this is that the delimiter is not //allowed as a character within any of the member or occurring fields The default delimiter is a dash [ implements Hierarchy ]

// This pattern causes an Array KeyField to be treated as a Hierarchy of Keys

// This is only valid on an Array KeyField and currently all Array KeyFields must implement this pattern. //Not yet implemented [ implements Ef f ect iveDated]

[EffectiveDate name is <FieldName>]

// This pattern adds afield of the type defined in the ProductLine file for the Eff ectiveDated pattern to the //primary index of the business class that this KeyField is centered on It also automatically adds a context //variable of the same type to this field The context variable is not an ontological context variable This // context variable is used as the effective date for the look up [ implements Special i zat ion]

[control valid key values]

// When the valid key values are controlled then there must exist a key value at the non-optional // key level before it can be specialized. If the highest key value is deleted then all of the specializations // are also deleted (delete cascades). Delete restricted and delete ignored are not supported. // If this is not specified then the key values of the specializations are uncontrolled. A key value can //be added at some specialization level without a higher level value being present. [ ef fect ive date as a group]

// Only valid when EjfectiveDated pattern is implemented // This option causes the set of specializations to be effective dated as a group.

[set retrieval is inclus ive ]

//Exclusive is the default. Inclusive means that the higher level 'specializations' are included as part of the // lower level specializations. An example of this is JobQualφcations. The company level qualifications are // considered to be part of the job-specφc qualifications.

//If any Context Key is optional, the Specialization pattern can be specified The specialization pattern //allows a single reference to the KeyField to search the business class for the appropriate business object. // The appropriate business object is the one that is the most 'specialized' based on what keys are optional. // The least specialized object is one where all the optional keys are blank. The most specialized object is //one where all the optional keys are filled in. It searches most specialized to least specialized. If the optional //keys are strictly hierarchically related based on their ontology, the search algorithm blanks optional key // values starting from the lowest optional key and moving toward the highest optional key. If the optional //keys are not hierarchically related, the search algorithm will similarly work from lowest to highest key, //however it will put values back into the lower keys. For example, given keys kl, k2, k3 with k2 and k3 optional /I and not hierarchically related, the search pattern is (kl, k2, k3), (kl, k2, blank), (kl, blank, k3), //(kl, blank, blank).

Display Fields // This section valid for KeyFields only

<RelatedField>

// These are the description ' or 'name ' fields for this key They are the 'human ' names we give things, such // as company name, employee name, and so on

Surrogate For // This section valid for KeyFields only

<FieldName> value i s <RelatedField>

Context Fields // These are 'non-ontological' context variables

<FieldName> [ <DataDef inition> ] [ <ContextRule> ] ...

ContextRule : : =

<RelatedField> <AssignmentOp> <RelatedValue> //AssignmentRule default to <RelatedValue>

// Multiple fields can be put on a default. If the first one is blank the second one is used //and so on. Only the last one can be a literal value constraint ' ( ' (<Condition>) ' ) ' <Message> required

[ <Message> ] // defaults to ' Field is required' if (<FieldName> <ContextOperator> )

<ContextRule> else

<ContextRule>

ContextOperator ::= ( in context

I entered )

// This Context Fields section declares a new 'non-ontological ' context field. Non-ontological context fields are not required to be in the context. They are //also evaluated newly each time the field is used. Context rules are not automatically arranged for execution as are Field Rules. The order they are in is //the order in which they are executed.

//Special considerations for field addressing, or what does the ' ' operator do when used with a KeyField, GroupField, or ArrayField KeyField - the ' operator

//on a KeyField automatically addresses all the elements on the business class that the KeyField is centered on. If the KeyField is a subtype of another

KeyField

// the ' ' operator also automatically addresses the elements of the supertype. If an element on the supertype is named the same as an element on the subtype, the

//key word 'super' can be used to 'jump' over the subtype to get to the supertype. GroupField— the ' ' operator or any Field reference in a business class can

// reach through a GroupField or an ArrayField and address a Field on the GroupField if the reference results in an unambiguous target. If Address is a

// GroupField that has a GroupField called PostalArea, which in turn contains City, State, and Tip, the Reference Address. City reaches through the

GroupField

// PostalArea to find its target. It also reaches through an ArrayField. It does not reach through KeyFields to the KeyField' s business class. If Address is on the

// business class Vendor, any rule on Vendor can directly address 'City ' and it does reach through both Address and PostalArea to find 'City '.

Il The syntax definitions for the following are the same as in the Business Class definition

Transient Fields Local Fields Derived Fields Conditions Relations Field Rules

Business Class LPL Definition (.busclass)

Business Class Structure ::=

<BusinessClass> is a BusinessClass

Ontology

Patterns

Persistent Fields

Transient Fields

Text Variables

Field Groups

Local Fields

Message Fields

Derived Fields

Conditions

Relations

Form Invokes

Matrix Forms

Sets

Field Rules

SubType <ConditionName> Field Rule∑

Attach Rules

Dynamic Creation Rules

StateCycles

Actions

BusinessClass is a Bus ine s sClas s owned by <ModuleName>

[pref ix is <Prefix> ] // required for use in Cobol programs

[ <SqlName> ] [ <ClassicName> ] [ store in environment ] // store data in the environment database

Ontology symbolic key is <KeyField>

// Can have multiple symbolic keys, these are synonyms

[name is <FieldName>]

// This overrides the name of the symbolic KeyField on this class

[classic set name is <Literal>]

// This sets the classic name for the primary set that is generated

[<SqlName>]

[ <ClassicName> ]

[ <ClassicNameForField> ]

[<context FieldName> name is <FieldName> ]

// <ContextField>- must be a context field within <KeyField> . The context fields within a KeyField //automatically get put on the business class. The default name is the highest level type name of the // context field. If APCompany is the context field and APCompany extends Company, the name is Company // This phrase allows the field name to be explicitly defined.

[<context FieldName sql name is <Literal>]

[<context FieldName> is a[n] <KeyField> ]

// This overrides the type of the Context Field The new type must be a subtype of the original type, ADCompany //versus Company. This 'symbolically keys' the business class. A business class can be keyed both symbolically // and relatively. A business class that is not symbolically keyed is considered to be 'relatively ' keyed // When a KeyField is defined to be the symbolic key to a business class, the Ontology Context variables //are replicated on the business class When a KeyField is simply used on a business class, the Ontology // Context variables must be resolved within the context of the business class or a compile error occurs. The // exceptions to this are those Ontology Context variables that are designated as optional. part of <BusinessClass>

[connect via UniquelD [only]]

// BusinessClass must NOT implement the Lazy UniquelD pattern to use connect via UniquelD [ de lete ( cascades | restricted | ignored ) ]

// delete cascades is the default

( relative key is <key FieldName> [ <DataDefinition>] I extends <BusinessClass>

[delete ( restricted //default

I cascades I ignored ) ] )

[<States>]

[<SqlName>]

[<ClassicName>]

[<ClassicNameForField>]

[text searchable]

// Only one relative key is allowed This keys the business class relative to another business class // The "relative key" construct will automatically put the <BusιnessClass> SymbolicKey

//field, including its Ontological Context fields, on this business class unless connect via UniquelD only // is specified. It also automatically puts a one-to-one or one-to-many relation on <BusinessClass> pointing back //to this business class. It names that relation '<this business class>SetRel' . If <BusinessClass> is itself // relatively keyed, a one to one required relation will be put on this business class It names that relation // '<BusinessClass>ReV

// The "parts" of <BusinessClass> can be accessed from <BusinessClass> by specifying '<this business class> set' in

//a <RelatedLιnk>

// The <BusmessClass> can be accessed from <this business class> by specifying ' <BusinessClass> ' in a

// <RelatedLink>

// The "extends " construct behaves similar to the "relative key " construct The actual relative key it uses /I is either the symbolic key or the relative key of the extends <BusinessClass>. The key difference is that // <thιs business class> can only be created if the corresponding extends <BusinessClass> instance exists //And if the extends <BusinessClass> is deleted an integrity delete rule will be enforced on <thιs business class>

// This construct is useful whenever there are a set of instances that act as a template for creating instances

// in some other one-to-many related context. An example of this is a set of questions that act as a template //for multiple sets of answers to those question in some one-to-many context from that set of questions

aggregate of BusinessClass

[aggregate ( continuously //default

I when needed ) ] [Aggregate For]

<BusinessClass> . <FullFieldName> ...

// <BusinessClass> must match aggregate of <BusinessClass> Aggregate By

<BusinessClass> . <FullFieldName> ...

// <BusinessClass> must match aggregate of <BusinessClass> [Aggregate I nstance s ] where <Condition>

// <Condition>- is scoped in the context σ/<BusinessClass>

archive of <BusinessClass>

Patterns

[ implement s CRUD ] // Create, Read, Update, Delete. We do not yet support a non-CRUD business object but expect to. A non-

CRUD

// business object would be just a database interface type of thing that was meant to be built on manually.

[implements ForeignTable] [allow updates]

// This pattern by default implements the Readonly pattern and the LazyUniqueld pattern // The Readonly pattern can be inhibited by specifying "allow updates "

[implements Readonly]

[implements LazyUniqueld]

//All business classes automatically get a Uniqueld put on them to support the ability to address any //LPL based business class directly through a Uniqueld. If the business class is not created through // the Landmark runtime but is rather an 8.1 or third party database table then it needs to implement // this pattern This pattern will generate an outboard file and the appropriate logic in the business // class to allow the Landmark runtime to access the outboard table via a Uniqueld.

[implements ManualCode]

[implements Attachments]

//Attachments are generated in the dictionary

[implements DynamicCreation]

// This pattern causes an object to be created automatically if it does not exist when another business object // 'attaches ' to it or if an Update type action is called. The creation can be constrained or special action can be // taken upon dynamic creation by putting rules in the Dynamic Creation Rules section.

[implements Auditing]

[implements EffectiveDated]

[implements Validity] [implements CreateStamp] [name is <Literal>]

[implements UpdateStamp] [name is <Literal>]

[implements Proxy for <RelatedLink> ] //Must be OTO relation or KeyField

[ implements CompoundDocument ] // Must have at least one RelatedLink

Document Component s <RelatedLink>...

[implements Encrypted]

[when ( <Condition> ) ] // Can only reference mutable non related fields

[implements TemplateDriven by <BusinessClass> ]

[ ( create al l instances | // "create all instances" is the default create instance when ( <Condition> ) ) ] // Can only reference mutable non-related fields

//For example, Answer is apart of Response and extends Question. Answer is designated as being TemplateDriven by

// Question. Question is a template for adding, updating and deleting corresponding Answer instances An Answer instance

//cannot be created without a corresponding Question instance.

// This pattern works with a <Template> definition within a <NavigationDefinition> or a <PanelDefinition>.

////create all instances is specified, an Answer instance will be created for every Question in the template list.

//Ifthe create is conditional, an Answer instance will be created only if the condition evaluates to true If the condition

// is false any existing corresponding Answer instance will be deleted.

Persistent Fields

<FieldName> [<DataDefinition> ]

[<States>]

[<SqlName>]

[<ClassicName>]

[ <ClassicNameForField> ]

[ encrypt ] //This will cause the field to be encrypted in the database —valid only for Alpha fields

I automate context ] // If the field is a KeyField this will ensure that all context variables are placed on this bus class

[ text searchable ] //Means this field will be search text indexed by the database

[ al low text variables from <BusinessClass> ] // not yet implemented

[as of <RelatedValue>]

// <FieldName> must be a KeyField, <RelatedValue> must be a TimeStamp or a Date

// this directive will retrieve the business class that this key field points to "as of the specified date and time //an implication of this is that the one-to-many relation from the keyfield's business class back to this //business class will be "delete ignored". If <RelatedValuε> is a Date then the last entry on that date will be retrieved.

[ store as BusinessObj ectRef erence ] // only valid on a KeyField

//this is required when trying to assign this value from an asynchronous operation LawsonClassicTransactwns //are an example of an asynchronous operation. When creating a new record via an asynchronous operation //only the BusinessObjectReference of the record is immediately available and thus only that aspect of the // keyfielά can actually be stored.

// only snapshot is currently supported

<FieldName> is a (replica | snapshot) of <RelatedField>

// replica sets and keeps this field the same as RelatedField under all conditions This specification //generates a rule either preventing RelatedField from changing or causing all references to be updated /I snapshot sets and keeps this field the same as RelatedField only when this business object is being updated // FieldName cannot be of a different type than RelatedField.

// not yet supported

<FieldName> is the <AggregateOp> of <BusinessClass> [ . <FullFieldName>]

[ (recalculate | sum the calculation) ]

// recalculate is the default This phrase is valid only in a business class that is an aggregate of // business class.

// not yet supported

<FieldName> is the <AggregateOp> of <otm RelatedLink> [ . <FullFieldName> ] [where <Condition>]

// This phrase is valid in any business class except an aggregate of business class //Should this really be a replica or a shapshot of a RelatedField^

AggregateOp : := ( aggregate

I instance count )

// The aggregate operator can be used only in a business class that is an aggregate of the

//an aggregated <BusinessClass>. If the operator instance count is used, . <FullFαeldName> cannot be

/ /specif ied.If the operator aggregate is used, . <FullFieldName> must be specified and must be afield in the

//aggregated <BusinessClass> that is capable of being aggregated It must be some form of numeric field. //It can be a group field with non-aggregatable fields in it if there is at least one aggregatable field

Transient Fields // Mutable but not persistent

<FieldName> [ <DataDef inition> ] [value i s <RelatedValue> ]

// not yet implemented

Text Variables

<FieldName> [value is <RelatedValue>]

// Text fields can contain Text Variables. The list of possible text variables is defined in this section. //Ifno value is given then <FieldName> must be a valid Persistent Field or Derived Field within // this business class.

Field Groups Il Arbitrary grouping of fields within this business class

<FieldGroupName>

<FullFieldName> ...

Local Fields

<FieldName> [ <DataDef inition> ] [value i s <RelatedField> ]

Message Fields // These fields are 'written' out to the report database

<FieldName> [ <DataDef inition> ]

Derived Fields

<FieldName> <DerivedFieldType> [type <DataDefinition>]

//type is not required for all derived fields. On some derived fields, such as Compute, the type defaults from the

//fields in the compute statement.Type is required for NativeField. [ <SqlName> ] [ <ClassicName> ] ( <DerivedFieldExpression> | <optionally blank if NativeField> )

DerivedFieldType : : = is a ConditionalField is a ComputeField is a StringField is a MessageField is a ListOperationField is a NativeField

DerivedFieldExpression ::=

ConditionalField if <Condition>

<RelatedValue> else if <Condition>

<RelatedValue> else

<RelatedValue>

ComputeField

<Parens> <RelatedValue> <MathOperator> <Parens> <RelatedValue> <Parens> ...

StringField

<RelatedValue> <RelatedValue> <RelatedValue> ...

MessageField

Message // This is similar in capability to a StringField except that it is implicitly Language Translatable.

// not yet implemented

ListOperationField

<ListOperator> <RelatedValue> [(, | and) <RelatedValue> } ] .. NativeField

[<NativeMethod> ]

// Can optionally call a JavaClass level method or an instance level method, which is a method on this instance.

Condition : := ' (' ( ConditionExpression

I <RelatedCondition>

') '

Parens : : = ( ' ( '

I ') '

MathOperator : : =

ListOperabor : := minimum of maximum of average of

Conditions

<ConditionName> [when ' ( ' <ConditionExpression> ' ) ' ] //can be on same line [<SqlName>] [<ClassicName>] when ' ( ' <ConditionExpression> ' ) '

ConditionExpression : : =

<ConditionNode> <Conjunction> <Parens> <ConditionNode> <Parens> <Conjunction>

Conjunction : := (and | or)

ConditionNode : := ( <ComparisonCondition> I <RelatedCondition> I <FieldCondition> I <RelationCondition> I IsABusClassCondition

ComparisonCondition : : = <RelatedF_.eld> <Cond_.tionOperator> <RelatedValue>

FieldCondition : : = [ <FieldOperator> ] ( <RelatedField> | <FieldGroupName> )

( entered

I is numer ic

I is high value

I changed

I in context

I is leap year

) // You cannot use a <RelatedField> with changed and in context. These can take a

<Ful IFi e 1 dName>.

RelationCondition ( f irst I not | no ) ] RelatedLink exist s

// not yet implemented

IsABusClassCondition : := <RelatedField> is a[n] <BusinessClass>

ConditionOperator : :=

I <= I > I <

I within

I overlaps

)

//the within operator is valid with array key fields that implement the Hierarchy pattern //It evaluates to true when the left operand's occurring fields match up to the non-blank right //operand's occurring fields. If the left operand has (5,3,9,10,20} as its occurring values it will match // the following right operands: {5,,,,}, {5,3,,,}, {5,3,9,,}, {5,3,9,10,}, {5,3,9,10,20} The concept is that //the left operand is "within" the right operand's hierarchical structure.

/I the within operator is also valid with group fields that implement the FieldRange pattern // the overlaps operator is only valid with group fields that implement the FieldRange pattern

Relations II By default a relation is valid only if key fields are entered

(<RelationName> [is a[n] (<BusinessClass> | <KeyField> ) set] | <KeyField> set)

// When KeyField set is used, the RelationName is a <KeyFleld>Set. Alternatively a one-to-many relation // based on a KeyField can be given a specific name by using <RelationName> is a <KeyField> set. //A KeyField set is the preferred way to define a one-to-many relation. It is similar to a Relative //Relation except that it automatically generates the relation tophrase below

[<SqlName>]

[ -ClassicName ]

[ ( one-to-one | one-to-many ) relat ion (to BusinessClass | us ing <RelatedLink> ) // If RelatedLink is a Relative Relation, it is a further definition based on the Relation given. // This would typically be used only to further restrict a one-to-many relation This phrase is required when the // Relation is not a KeyField set, otherwise a KeyField set has the same rules as a Relative Relation

[valid when <Condition>] [required]

[delete (restricted | cascades)] Field Mapping uses ( <SetName>

I [<BusinessClass>] part of key I [<KeyField>] symbolic key )

// SetName is required for now on a BusinessClass until OPF supports it. It is not required on a Relative /I Relation. It may however be used on a Relative Relation to change the sort order if there are no 'holes ' in the // upper key

/I BusinessClass must be one of the part of business classes and KeyField must be one of the symbolic key fields re lated . <FullFieldName> <RelationOperator> <RelatedValue> .. [ Instance Se lection ] where ' ( ' <Condition> ' ) '

// Valid with one-to-many only This expression can use the OTM object 's fields and the current object 's fields.

RelationOperator : : = ( =

I >= I > I <= I <

I as of )

//non = operators are valid on last key only // as of operator is valid on a date only RelationName

//A conditional relation must return the same underlying business object with the same cardinality (oto or otm). [ <SqlName> ] [ <ClassicName> ] if <Condition>

RelationName else if <Condition>

<RelationName> else

<RelationName>

Form Invokes

<FoπtiInvokeName>

( <FormInvokeRule> | <ControlRule> )

FormlnvokeRule : : = invoke <InvocationTarget>

[ f i ll in [ blank ] f ields from <RelatedLink> ]

[except invoked . ( <FullFieldName> | <FieldGroupName> ) ]

// <RelatedLink> cannot be the same as the invoke 's <RelatedLink> [ invoked . <FullFieldName> <AssignmentOp> <RelatedValue> ] [ <Rule> ]

//the way to address fields in the <RelatedLιnk> that is being addressed here is to use the // invoked keyword

Matrix Forms

<MatrixForm> rows are RelatedLmk column is <BusinessClass> cell is <BusxnessClass>

Sets

<SetName> // No Key Change is no longer supported All indexes can have keys changed

[ <SqlName> ] [ :ClaεεicName ]

[pr imary ] // One index only must be primary and cannot have duplicates, if no Ontology section

[ ( no duplicates //default I dupl icate s ) ]

[ indexed ] //A physical index is created If not specified, a virtual index is created (the sql database will create a sorted

// set on the fly) Sort Order

<FullFieldName> [descending]

[Instance Selection] where ' ( ' <RelatedCondition> ' ) '

// Inline conditions not supported Must define a condition // Condition must have only primary fields

General Form for Rules

Contexts in which Rules can exist

Field Rules SubType <ConditionName> Field Rules

<FieldName> <FieldName>

<Rule> <Rule>

Attach Rules Dynamic Creation Rules

<Rulθ> <Rulθ>

State Rules Attach Rules

<Rule> <Rule>

<FieldName> <FieldName>

<Rule> <Rule>

AssignmentOp ^{■ •} =

// exponentiation //is modulus operator

Rule . = ( <ControlRule>

I <GeneralRule> // Valid in all contexts

I <FieldRule> // Valid in Field context only

I <F_.eldCreateRule> // Valid in Field context with Create action

I <GroupRule> // Valid only within a GroupField

I <ArrayRule> // Valid only within an ArrayField

I <Act_.onRule> // Valid in Action context only

I <FormInvokeRule> // Valid in the Form Invokes section only

)

ControlRule : = //A ControlRule is a Rule that defines the control of other rules As with a standard Rule each has a

// recursive nature that is the <Rule> under the Ij (<Condltlon>) can be another ControlRule or standard Rule i f ( <Condition> )

<Rule> [ el se ]

<Rule> for each {<otm RelatedLink> | <array RelatedField>) <Rule> [each <RelatedField> ]

//Within the scope of the for each the fields of the <0TM RelatlonName> and the occurring field within // <Array RelatedFιeld> are addressed through the each key word If the <OTM RelattonName> is Employees // and a field on the Employee business class is Name then that field is addressed as each Name within the scope // of the for each If this is for an array field this structure drives a loop that goes through each occurrence in the array //All other array fields are presumed to have the same index as the primary occurring field The RelatedFleld must be a //field that has a Representation with afield that occurs The actual occurring field must be addressed directly (for //example each OccuringField) within the actual loop

while ( <Cond_.tion> ) <Rule>...

GeneralRule : : = // Valid in all contexts

/I HOf yet implemented confirmation required [<Message>] constraint ' (' (<Condition>) ') '

<Message> //Message required on constraint rule

<RelatedField> <AssignmentOp> <RelatedValue> // Assignment rule

// <RelatedField> valid only in scope of Business Object (not field rules) // useful in a Field Context Rule

// not yet implemented update <RelatedField> // not valid in Action context initialize [ <FullFieldName> ] add <RelatedValue> to <FullFieldName> subtract <RelatedValue> from <FullFieldName>

FieldRule : : = // Valid in Field context only

[(force I dynamic)] default to <RelatedValue>

// a force default rule defaults the field whether it is entered or not

//a dynamic default rule leaves the field blank and dynamically defaults it when it is referenced // a standard default fills in the field if it is blank

I ( default as a group | default individual fie lds ) ] //default is default as a group // issue here is how to do defaulting on a group field required

[ <Message> ] // defaults to ' Field is required' cannot be entered

[ <Message> ] //defaults to 'Field cannot be entered' cannot be changed

[ <Message> ] //defaults to 'Field cannot be changed' must be numeric

[ <Message> ] // defaults to ' Field must be numeric'

// not yet implemented f ield s i ze i s <RelatedField>

FieldCreaheRule : : = // Valid in Field context with Create action autosequence [using <RelatedField> ]

// if no field specified find last instance in context and increment by 1

GroupRule : : = // Valid only within a GroupField always default (individual fields | as a group)

//Prevents group default rule from being overridden mutual ly exclusive [<Message> ]

ArrayRule : : = // Valid only within an ArrayField array size is <RelatedField> edit increasing sequence make increasing sequence edit decreasing sequence make decreasing sequence edit contiguous make contiguous no dupl icate s [ on <FullFieldName> [ , <FullFieldName> ] . . ] // where Field is a MemberField within an occurring GroupField

ActionRule : : = // Valid in Action context only bui ld text search f ield <FullFieldName> // strings the given fields into <FullFιeldName> Fie lds

( <RelatedValue> | <FieldGroupName> ) ..

rollback changes to <RelatedField>

// <RelatedFielά> must be of type TimeStamp // Auditing pattern must be implemented // Only valid within Action Rules initiate <ProcessName> process [title is <Message>] [Criteria]

<RelatedField>...

[category filter is <RelatedField>] [Variables]

<RelatedField>... [Navigations ]

[<RelatedLink> . ] <NavigationName>

//List of navigations to show for a participant of the process // This maps to the "Folders " concept in ProcessFlow

invoke [ destructive ] <InvocationTarget> [ thi s instance ]

// < CreateAction> must be a non-parameter Create Action

// "destructive " is only valid on a Delete type action and will physically remove the record

// whether or not the business class implements Auditing [ as sign result to ( <KeyField> | <ViewField> | <BusinessObjectReference> ) ]

// This defaults when the InvocationTarget is a Key Field

// Not valid with "create instance "

// This must be a BusinessObjectReference if the InvocationTarget is an update type of

// Lawson Classic Transaction.

// This can only be used on a Lawson Classic Transaction if it has a business class designation. [ f i ll in [ blank ] f ields from <RelatedLink> ]

[except invoked . ( <FullFieldName> | <FieldGroupName> ) ] ..

// <RelatedLink>- cannot be the same as the invoke' s <RelatedLink>- [ invoked . <FullFieldName> <AssignmentOp> <RelatedValue> ] . . [ <Rule> ] ...

//the way to address fields in the <RelatedLιnk> that is being addressed here is to use the

// invoked keyword [ <FullFieldName> <AssignmentOp> result . <FullFieldName> ] . .

//A LawsonClassicTransaction is capable of returning result fields. The result fields are

//are accessed using the "result" keyword

send email

[to <RelatedValue>. . ] //Must enter one of to, cc, bcc

[cc <RelatedValue> ]

[bcc <RelatedValue>...] from <RelatedValue>...

[subject <Message>]

[attachment <RelatedField>]

[name is <RelatedValue> ]

[mime type is <RelatedValue> ] Contents

<Message> register new actor login name is <RelatedValue> password is <RelatedValue> registration key is <Message> role is <RelatedValue>... person name is <RelatedValue> contact info is <RelatedValue> make transition to <StateName>

InvocationTarget : := <ActionName> [ (

[<StateName>] <RelatedLink>

I <BusinessClass> // Must be a SetAction

I <BusinessTask> // Any action on a

BusinessTask

I <LawsonClassicTransaction> I <MovexInterface> )]

FieldRules : :=

<FullFieldName> <Rule> ..

// Field name can have template operator in it '<A> ' if it does then rules can have matching template operator

Field Rules

<FieldRules> ...

SubType <ConditionName> Field Rules

<FieldRules> ...

Attach Rules // Rules that get 'fired' when another business object is seeking to 'attach' itself to this object

<Rule> ...

// Only rules that are valid in all contexts. //Any constraint rule means that attachment of calling object is not allowed

//No <FieldRules>

Dynamic Creation Rules //Rules that get fired' when a Dynamic Creation is about to occur

<Rule> ... //Any constraint rule means that Dynamic Creation does not occur and an exception does occur.

// Both Attach Rules and Dynamic Creation Rules can address contextual information about the business class //that is causing these rules to fire through the special variable datacontext.

Example

Attach Rules if (datacontext . istransaction) UsedByAIransaction = true;

Dynamic Creation Rules if ( datacontext . symbolickey = "Vendor") AgentSource = AgentSource . Vendor if (datacontext .module = "HR")

ξystemξource = "PR" else

SystemSource = datacontext .module

States and Actions

//State definitions are optional. If States are defined, all actions must exist within a state. If States are not defined a 'Maintain' state // is generated internally in the repository and all Actions are put on that state If no Actions are defined, the actions Create, Update, //and Delete are automatically generated If any actions are defined, one of them must be a Create type of action (it is ok to never be able //to update or delete a business object but if it can never be created, there isn't much point in defining it in the first place)

StateCycles

<StateCycleDefinition>

StateCycleDefinition : : =

<StateCycleName> is a StateCycle

[ state f ield i s <persistent FieldName> ]

//default is <StateCycleName> + State [ initial state is <StateName> ]

//default is first state definition <StateDefinition> . .

StateDefinition ::=

<StateName> is a State Entrance Rules

<Rule>... Exit Rules

<Rule>... Field Rules

<FieldRules> .. SubType <ConditionName> Field Rules

<FieldRules> .. [<EventHandler> ...] <ActionDefinition> ... [<StateCycleDefinition> ...]

//A StateName must be unique within another State StateCycles do NOT participate in the name scoping of States. Thus if there is a state "Open " that has two

//StateCycles ("ApprovalCycle " and "NotφcationCycle ") the StateNames within those two StateCycles must be unique. This allows a State to be fully identified

//via its upper StateName. In this example if ApprovalCycle has a State "NeedsApproval" then it can be addressed using " Open.NeedsApproval" . A

StateName

//address need not be fully qualified as long as it can be unambiguously resolved.

Actions

(<ActionDefinition> | <EventHandler> ) ...

ActionDefinition ::=

<ActionName> is a[n] [<ActionType>] Action [valid when <SimpleCondition> ]

//A blank ActioήType means Instance Action unless ActionName is the same as ActionType

// If ActionName = = ActionType, ActionType = ActionName

[restricted] // Can only be invoked; cannot be executed via UI

[allow anonymous access] //Allows the "anonymous" user to execute this action

Set Is //Valid for Set actions only

<RelatedField> ..

Implements Modeling Pattern //Valid for Set actions only reset action is <StateName> . <ActionName> unmodeled state is <StateName> modeled state is <StateName>

Parameters // Valid fσ r Create, Instance, and Set actions

<FieldName> [ <DataDef inition> ] ...

<Rule>... Local Fields

<FieldName> [ ( <DataDef inition>

I is a <BusinessClass> view ) ] [value is <RelatedField> ] Results

(<FieldName> | BusinessClass view) Field Rules //Valid for Create and Update actions only

<FieldRules> .. SubType <ConditionName> Field Rules //Valid for Create and Update actions only

<FieldRules> .. Accumulators

<FieldName> [<DataDef inition> ] where (<Condition> )

(count instances | sum <RelatedField> ) Instance Selection //Valid for Set actions only where (<Condition> )

Sort Order // Valid for Set actions only

<RelatedField> [de scending ]

[alternate key is <RelatedField> ] when (<Condition>)

Action Rules // Rules for entire set if a Set Action — otherwise just the rules for this instance

<Rule> //only valid for a non Set Action constraint type rules as well as action rules

// can be placed here — constraint rules constrain whether the action takes place or not Set Rule s // only valid for a Set Action — constraint rules here determine

Entrance Rules

<Rule>

Exit Rules

<Rule>

<Sort FullFieldName> Set Rule s // Valid for Set actions only

Entrance Rules

<Rule> Exit Rules <Rule> Instance Rules // Valid for Set actions only

<Rule>

Exit Rules // Rules to be executed upon exit of the Action

<Rule>

ActionType : : = ( Create // Takes Business Object DataView creates a new record and returns a Business Object I Update // Takes Business Object DataView with Key updates an existing record and return a Business Object I Delete //Takes DataVlewKey deletes an existing record and returns nothing I Preview // Takes Business Object DataView and returns a Business Object, no updates are done I Instance // Takes DataVlewKey or Parameter DataView with a Key executes its rules persists the record returns nothing I Set //Takes Parameter DataView without a Key operates on a set of records persisting each one returns nothing )

EventHandler : := on ( <StateName> . <ActionName> entrance to <StateName> exit of <StateName> )

Action Rules <Rule>

Example of an Action

CreateChecks is a Set Action Set is

PayGroup ProcGrp

Implements Modeling Pattern reset action is PaymentModelmg. Modeled Unmodel unmodeled state is PaymentModelmg . Unmodeled modeled state is PaymentModelmg .Modeled

Example of State syntax

LifeCyde is a ξtateCycle state field is LifeCycleState //default is <StateCydeName> + State

Unreleased is a State

Create is an Action Update is an Action Delete is an Action Release is an Action Action Rules make transition to Released invoke Release Unreleased Polmes

Released is a State

Cancel is an Action Action Rules constraint (NoActivity)

"Cannot cancel if Activity exists" make transition to Cancelled Update is an Action

Approval is a ξtateCycle initial state is NeedsApproval

Approved is a State

Update is an Action Action Rules if (any audited field changed) make transition to NeedsApproval

NeedsApproval is a State Update is an Action Action Rules

Approve is an Action Action Rules make transition to Approved

Communication is a ξtateCycle

Notlssuable is a State

On NeedsApproval .Approve Action Rules make transition to Issuable

Issuable is a State

Issue is an Action Action Rules make transition to Issued

Issued is a State

Update is an Action Action Rules if (any audited field changed) make transition to Revised

Revised is a State

On NeedsApproval .Approve Action Rules make transition to Issuable

Cancelled is a State

Close is an Instance Action

Closed is a State

Delete is an Action

Unrelease is an Instance Action Action Rules make transition to Unreleased

Module LPL Definition (.module)

<ModuleName> is a Module

[ <ClassicName> ] // Use system codeforconvertingfiles type is (]ava | classic) description is <ModuleDescription>

<MajorSystemProcess> is a Maj orSystemProcess Data Set

<KeyField> ... Data Set Rules

<DataSetRules> .. Business Task Sequence

BusinessTask .. Business Task Rules <BusinessTask> ..

<BusinessTaskRules>

DataSetRules : : = al low data set changes // This allows changes to the set that is being processed between tasks re start process at BusinessTask // This forces the process to be restarted at the designated business task

RelatedField : : = ( <RelatedField>

I data set

// On conditions within Data Set Rules, this allows for the condition 'if (data set changed) '

BυsinessTaskRules required

Example of MajorSystemProcess definition pr is a Module

PayrollCyde is a MajorSystemProcess

Data Set

Company is a HRCompany ProcessLevel is a HRProcessLevel

Data Set Rules allow data set changes //between cycle programs if (data set changed) restart process at EarnmgsAndDeductionsCalculation

Business Task Sequence

RetroPayCalculation

OvertimeCalculation

TipsCalculation

UkAbsenceProces s ing

EarnmgsAndDeductionsCalculation

TimeAccrualCalculation

PaymentCreation

PayrollClose

GlPostmg

PeriodClose

Business Task Rules

OvertimeCalculation if ( Proces sLevel . OvertimeCalculationRequired ) required

TipsCalculation if ( Proces sLevel . TipsCalculationRequired) required

UkAbsenceProces sing if ( Proces sLevel . UkαbsenceProces singRequired ) required

EarningsAndDeductionCalculation if (Proces sLevel . DoLawsonPayroll ) required

PaymentCreation if (Proces sLevel . DoLawsonPayroll) required

PayrollClose if (Proces sLevel . DoLawsonPayroll ) required

Business Task Pattern LPL Definition (.bustask)

Business Task Structure : :=

<BusinessTask> is a BusinessTask

Parameters

Parameter Rules

Results

Patterns

Actions

BusinessTask is a BusinessTask owned by <ModuleName>

[ store in environment ] // Presume storage of all related invokes to be in the environment

//and therefore, start a transaction for the environment database

Parameters

<FieldName> [<DataDefinition> ]

[<States>]

<FieldName> is a[n] <BusinessClass> view

Parameter Rules Il Just like Field Rules structure

<Parameter FullFieldName>.. <Rule>...

Results

<FieldName> [<DataDefinition> ]

[<States>]

<FieldName> is a[n] <BusinessClass> view Patterns

[implements ManualCode] [implements ManualTransaction] [implements FrameworkTask]

Actions

<ActionName> is an Instance Action Action Rules <Rule>...

Example of Business Task definition

TransactionPostmg is a Busiπesslask

Parameters

CompanyGroup

Parameter Rules

CompanyGroup required

Result

CompletionMessage is Alpha30

Actions

PostTransactions is a Function Action

Action Rules for each CompanyGroup . Companies ) invoke Admaster . PostTransactions

Admaster . Company CompanyGroup . Companies . Company

Admaster . AccountRange CompanyGroup .Companies .AccountRange

Admaster .FisealYear CompanyGroup . Companies . FiscalYear

Admaster . AcctPeriod CompanyGroup . Companies . AcctPeriod

Admaster . RunDate CompanyGroup . Companies . RunDate

CompletionMe s sage = "SuccessfulCompletion"

CreateCandidate is a BusmessTask

Parameters

Company is an ERCompany Resume is a BmaryDocument

Parameter Rules

Company required Resume required

Result

Candidate view

Patterns

Ul Definition File

// UI definitions are logically part of either a business class, business task, or field definition This is accomplished by having the same file name as the // respective business class, business task, or field in a different directory structure The standard directory structure is com/lawson/apps/<ModuleName> ; // the UI definition files are stored in com/lawson/forms/<ModuleName>. Thus the file com/lawson/forms./field/Address.field contains the UI definitions for // the field com/lawson/apps/field/Address.field. Every business class, business task, or field can have a default UI definition as well as alternate UI definitions

( BusinessClass is a BusinessClass I <BusinessTask> is a BusinessTask I <FieldName> is a Field )

[<NavigationDefinition>] ..

[ <ListDefinition> ]

[<MatrixListDefinition>] ..

[<FormDefinition>] ...

[ <SummaryFoπnDefinition> ] ..

[ <ActionFormDefinition> ]

[ ComposibeFormDefinition>] ...

HttpURL ::= <Message>

Link ::= ( <NavigationName> I <HttpURL>

)

Label : : = label is (<Message> | default) [<TextStyle>.. ]

FormText text of <Message> [<TextStyle>.. ] blank line

TextStyle ::= ( header [1-6]

I right justify

I center

I left justify

I bold

I italics

NavigationDefinition ::=

<NavigationName> is a Navigation

[valid when <SimpleCondition> ]

( <Page>

I <Form>

I <List>

I <Template>

ListDefinition ::=

<ListName> is a List [is primary]

[propagate as a Navigation]

[title is <Message>] // defaults to ListName

[is default select] [show in descending order] [Display Fields]

<RelatedField>

[ (<Label> | no label) ] // default is Field Label

[use text area [of <Literal> lines] ] // Use a text area control to display this field

[filter by]

[link is <Link>]

[sort order is (<SetName> | primary)]

[is default [descending] ] [allow update]

[detail list is <RelatedLink> . (<ListName> | primary)] [Filter By]

<RelatedField> ..

[ (<Label> | no label) ] // default is Field Label

[select is <ListName>] [filter form is <FormName>] [Instance Selection] where ' ( ' <Condition> ' ) '

[form is <FormName>] // Form to use on an "Open". Primary form will be used by default.

[create action is [ <StateName> . ] <ActionName> ] ... [open action is [<StateName> . ] <ActionName>] ... [restrict action [ <StateName> . ] <ActionName>] ..

FormDefinition : :=

<FormName> is a Form [is primary]

[propagate as a Navigation]

[use for action [<StateName> . ] <ActionName>]

[title is <Message>] // defaults to FormName

Layout [for <ISOLocale> [, <ISOLocale>] ..] ..//first Layout cannot have "for <ISOLocale>" <FormLayout>..

SummaryFormDefinition ::=

<FormName> is a SummaryForm

[title is <Message>] // defaults to FormName

Layout [for <ISOLocale> [, <ISOLocale>] ] //first Layout cannot have "for <ISOLocale>" <Summary Layout >..

SuininaryLayout : : = ( <FormField> I <FormButton> I <CheckControl> I <FormText>

I form is [<RelatedLink> . ] <FormName> // can take only an OTM RelatedLink

I <LayoutDirective> [<SummaryLayout> ..]

ActionFormDefinition ::=

<FormName> is an ActionForm action is [<StateName> . ] <ActionName>

//An ActionForm is used to format parameters on an action Can also be used for non parameter-based actions. // When this is specified and there are parameters on the action, the field scoping is limited to the parameters // If no parameters are defined on the action and the action is a Create or an Update action, the field scoping is the

// whole business class This kind of form only has an OK and a Cancel button OK runs the specified Action and // Cancel returns to the previous page

[ t it le i s <Message> ] // defaults to FormName

Layout [ for <ISOLocale> [ , <ISOLocale> ] . . ] ..//first Layout cannot have "for <lSOLocale> " <FormLayout>. .

FormLayout : : =

<LayoutDirective> [ ( <FormField> I <FormButton> I <CheckControl> I <FormText> I <FormLayout> .. )]

ISOLocale ::= <ISOLanguageCode>_<ISOCountryCode> [_<alphanumeric charaters>]

// The optional alphanumeric characters are a variant

ISOLanguageCode : := ( <two alpha characters>

I find ISO La.ngua.ge codes and place here I

)

ISOCountryCode ::= ( <two alpha characters>

I find ISO Country codes and place here I

)

LayoutDirective ::= ( paragraph

I single column

I two column [grid]

I three column [grid]

I seven column [grid]

I column (1 I 2 I 3) [of <Percent>]

I header (1 I 2 I 3 I 4 |5) of <Message>

)

FormButton : : = button of <Message>

[valid when <SimpleCondition> ]

( link is <Link>

I form invoke is <FormInvokeName>

I action is [<RelatedLink> . ] [ <StateName> . ] <ActionName>

)

[ <Label> ] // default is no label

[ ( left align | center | right align ) ] //left align is default unless used in a MatrυcList (center is default)

I indent ]

CheckControl : : = check control

[valid when <SimpleCondition> ] [checked state is <FieldName> ] check action is [<StateName> . ] <ActionNaitιe> uncheck action is [ <StateName> . ] <ActionName> [<Label>] //default is no label

[ ( left align | center | right align ) ] //left align is default unless used in a MatrixList (center is default) I indent ]

FormField : : =

<RelatedField>

[ ( labe l is ( <RelatedField> | <Message> | number ) | no label ) ] // default is Field Label [ <TextStyle>...]

[ ( left align | center | right align ) ] // left align is default

[form is <FormName>]

[indent]

[ di splay only ] // implicit on SummaryForm

[ compact format ]

[ se lect is <ListName> ]

[ use text area [ of <Literal> line s ] ] // Use a text area control to display this field

SimpleCondition : : = ( <boolean RelatedField> | <RelatedField> . <StateName> )

Navigation : : = navigation i s <NavigationName>

Page : : = page is <PageName>

Form : : = form is ( <FormName> | pr imary )

List : : = list is <RelatedLink> . ( <ListName> | primary)

[helper list is <RelatedLink> . (<ListName> | primary)] [action is [ <StateName> . ] <ActionName>] ...

//A "helper list ¹ ' is a list that will show below the main list that should be helpful to managing the main list. // One example of a list being helpful is a list of instances that can be copied into the main list Another example // may be a list of instances that are just useful to see when managing the main list. // If no action is specified on a helper list then all the Instance actions will display. //Multiple actions can be specified.

Template : := template is <RelatedLink> business class is <BusinessClass>

(<Form> I list is (<ListName> | primary) )

//A Template specification is a means for building a list of <RelatedLink> instances that are used as a template for

//creating <BusιnessClass> instances <BusιnessClass> must implement the TemplateDnven pattern The // <RelatedLιnk> target must be the business class specified in the TemplateDnven pattern

Compos iteFormDef inition : :=

<FormName> is a CompositeForm [is primary] [wizard]

[finish form is <FormName> ] // Must be a SummaryForm

[cancel action is [ <StateName> . ] ActionName ] [propagate as a Navigation]

[use for action [<StateName> . ] <ActionName>] [title is <Message>] // defaults to FormName

[context form is <FormName> ] //This allows common "context" fields to be put outside the panels <PanelName> is a Panel ..

[mouse over text is <Message>]

[next action is [<SfcateName> . ] <ActionName>] //only valid for Wizard

[valid when <SimpleCondition> ]

(<Form> I <List> | <Template> | <Navigation> )

[Special Actions] //Allows actions from the primary business class to be called from this context

[<StateName> . ] <ActionName>..

Example of CompositeForm definition

SourcmgEventDocument is a CompositeForm title is "<mode>EveπtDocument" Event is a Panel form is SourcmgEventHeader Questions is a Panel form is ξourcmgEventQuestion set //defaults to primary list

Terms is a Panel list is SourcmgEventTerm set Meetings is a Panel list is ξourcmgEventMeetmg set Attachments is a Panel list is ξourcmgEventAttachment set Contacts is a Panel list is SourcmgEventContact set Lines is a Panel list is SourcmgEventLme set .EventLmes Notifications is a Panel list is ξourcmgEventNotification set

MatrixDefinition : : =

<MatrixForm> is a MatπxForm [title is <Message>] // defaults to MatrixName context form is <FormName> Column

Display Fields (

<RelatedField> ...

[<Label> | no label) // default is Field Label [link is <Link>] I <FormButton> .. I <CheckControl> ...

Cell

Display Fields

<RelatedField>

[<Label> | no label) ] // default is Field Label [link is <Link>]

<FormButton> ..

<CheckControl> ...

Detail Fields

<RelatedField> ...

[<Label> | no label) // default is Field Label [link is <Link>]

<FormButton>

<CheckControl> ...

Example of Matrix definition

CompareResponses is a MatπxForm title is "CompareResponses" context form is CompareResponsesContextForm

Column

Display Fields

Supplier . ξupplierName no label check control check action is AwardAllLmes uncheck action is UnAwardAllLmes SupplierTotalBidAmount link is QuestionResponses label is "ViewResponses" Cell

Display Fields check control label is "Line<ξourcingEventLme> : <ξourcingEventLme . Description>" header2 checked state i s I sAwarded check action i s AwardLme uncheck action i s UnAwardLme BidAmount l abe l is "<ξourcingEventLme . Lme lnf o> '' Detail Fields

ExtendedPπce

Reque stedDel iveryDate link i s LmeQuestionRe sponse s l abe l is "ViewRe spon se s "

Page Definition File

// Page definition files must have an extension of . page and are found in com/lawson/forms/<ModuleName > Page names exist in the same name space as

// BusinessClass names and BusinessTask names

//Pages and CompositeForms have a lot of similarity but also some significant differences.

// The similarity is that they are both made up of panels.

// The difference is in their ontology and their (current) capability.

//A ComposiieForm is defined within the scope of a BusinessClass, BusinessTask, or Field, like a regular Form. Because of this it presupposes that all references

//are references within the context of that Business Class. A Page is defined as an individual entity at the same scoping level as a BusinessClass, Task, or

Field.

// It is also made up of panels but each panel must designate its own particular context. Pages can also have multi pane panels whereas CompositeForms cannot.

// This restriction is not ontologically required; it is just a simplification for now.

<PageName> is a Page

[ t itle i s <Message> ] // defaults to PageName

[allow anonymous access]

[Context Form]

Layout [ for <ISOLocale> [ , <ISOLocale> ] . . ] ..//first Layout cannot have "for <lSOLocale> "

<FormLayout>. . //valid fields are the set of all Context fields defined on all Panels and panes

<PanelName> is a MultiPanePanel [mouse over text is <Message>] pane <PaneNuinber>..

<PanelDefinition>

<PanelName> is a Panel ...

[mouse over text is <Message>] <PanelDefinition>

PaneNumber : : = ( 1 | 2 | 3 | 4 ) // 1 is upper ¹ IeJt, 2 is lower left, 3 is upper right, 4 is lower right

// The current metaphor for panes is that there are four possible panes: pane 1 is the upper left, pane 2 is the lower left, pane 3 is the upper right

/I andpane 4 is the lower right.

//Pane interaction is accomplished through inferencing how the actions relate to each other through the IpI business class action specification

// Pane sizing is yet to be done I would expect something like a default pane size and a minimum pane size, but am not sure what the units would be

/I I think vertical sizing could be lines and horizontal sizing could be percent of total width

PanelDefinition ::= ( <MenuPanel> I <ListPanel>

)

MenuPanel : : =

Layout [ for <ISOLocale> [ , <ISOLocale> ] ...] .. //first Layout cannot have "for <lSOLocale> "

<MenuLayout>. .

MenuLayout : : =

( <FormText> I <MenuItem> [<Label>]

[allow anonymous access] I <LayoutDirective> [<MenuLayout>...]

ListPanel : : = business class is < BusinessClass | pane<PaneNuπ_ber> . <RelatedLink> )

[ l i st is <ListName> ] // defaults to primary list on resultant business class

[Context ]

<FieldName> .. [Actions]

( [action is] [<StateName> . ] <ActionName>...

[<Label>] I form is RelabedLink . <FormName>..

// <RelatedLink> can only be one of the context fields [ <Label> ] )

//A context field will implicitly be used as a "fixed" context to any Create action that is executed - if Context of "Actor" is specified // and a Create action is executed then the Actor field in the business class will be populated with the Actor context

Example of Page definition

3uyerPage is a Page

Worksheet is a MultiPanePanel panel business class is ξourcmgEventWorksheet Context

Actor required

Actions

CreateEvent ξendToPO Delete pane2 business class is Polnterface Context

Pocompany

Actions

CreateEventWorksheet

Draft is a Panel business class is ξourcmgEvent list is DraftEvents // only show create events within Draft state Context

Company required

Open is a Panel business class is SourcmgEvent list is OpenEvents // should not show create events Context

Company required

Awarded is a Panel business class is SourcmgEvent list is AwardedEvents Context

Company requ

**********************************************

Menu Definition File

_{******************************************************* *************************************}

//Menu definitions are in the same name space as BusinessClasses, BusinessTasks, and Pages. A Menu definition file has an extension o/.menu <MenuName> is a Menu

<MenuItems>

// If a menu is used in a Navigation Bar within a wepapp file then the first menu item is "Home " which takes the // user to the 'home page " within the webapp definition file.

[<MenuName> is a Menu].. //This allows menus to be "in-lined" within a single menu definition file

<MenuItems>

Menultems : : =

Menu Items

<MenuItemName> .. <MenuItem>

[allow anonymous access]

Menultem : : =

( page is <PageName>

I list is <BusinessClass> . (<ListName> | primary)

I form is <BusinessClass> . (<FormName> | primary)

[create action is [ <StateName> . ] <ActionName> ]

[open action is [<StateName> . ] <ActionName>] ... 0

[restrict action [ <StateName> . ] <ActionName>] .. I form is actor . agent ( BusinessClass ) . [ <RelatedL_.nk> . ] (<FoπtιName> | primary)

[create action is [ <StateName> . ] <ActionName> ]

[open action is [<StateName> . ] <ActionName>] ...

[restrict action [ <StateName> . ] <ActionName>] .. I action is <BusinessTask> . <ActionName> I link is <HttpURL> I menu is <MenuName> )

********************************************************* ***********************************

WebApp Definition File

_{******************************************************* *************************************}

// WebApp definitions are in their own name space within a product line. A WebApp definition file ends in .webapp and is located in the /I <ProductLme>/webappε directory

<WebAppName> is a WebApp owned by <ModuleName> home page is <PageName> [navigation bar is <MenuName>] [registration action is <BusinessClass> . [<StateName> . ] <ActionName> ]

// <ActιonNαme> must be α Create type action.

[open action is [<StateName> . ] <ActionName> ] [restrict action [ <StateName> . ] <ActionName>] .. [automatic login] [registration key is <Message>] [allow anonymous access]

Lawson Classic Transaction Definition File

//A Lαwson Classic Transaction definition is defined within a module and has an extension of . lcb // This definition is required to execute a Lawson classic transaction from an IpI definition.

<LawsonClassicTransaction> is a LawsonClassicTransaction token is <LawsonClassicToken>

[business class is <BusinessClass>] Field Mapping busclass . <FieldName> = (result . <FieldName> | <Literal> )

// The fields in the business class that must be mapped are the primary key fields - either the symbolic key and its context or the part-ofkey and its context.

// We will be enhancing the Lawson Classic Transaction implementation to use an Asynchronous Message-Based mechanism to execute the transaction for

// Create, Update and Delete actions (not Find Actions)

// One issue with an asynchronous mechanism is that we cannot get feedback from the API immediately, which means that when adding a record that is

// autosequenced we cannot get the autosequenced key value back right away. This is a problem when we need to store a reference to the added record or if we

// want to add more records that refer to the record just added

// To solve this problem we need to store a surrogate key (a unique id) that will be generated when the API message is sent. When the API is successfully fully

// executed, we will link the primary key of the created record to the surrogate key that was generated. To do this we need to know what fields on the returned

// message of the API map to the primary key fields.

// That is why we need to define which (primary) business class this transaction creates or updates as well as which primary key fields within that business class

// map to which fields on the API.

Transaction Fields

<FieldName> [<DataDefinition> ] .. classic name is <classicname> [(key [required] | required)] [variable decimal]

<ActionName> is a[n] <LCTActionType> Action .. function code is ' " '<alphanumeric> '" '

LawsonClassicToken : := <two uppercase alpha characters>

<two uppercase alphanumeric characters>.

<single digit numeric character > J/ for example, APlO 1

LawsonClassicTransaction ::= <LPLConstructName>

LCTActlonType : : = ( Create // Create, Update, and Delete process the interface asynchronous^. They post a message

I Update //to a queue that is picked up later for processing.

I De lete

I Find // Find actions are processed sychronously.

Example of LawsonClassicTransaction

APlO is a LawsonClassicTransaction token is APlO.1 business class is Apvenmast Field Mapping busclass . VendorGroup = result .VendorGroup busclass . Vendor = result .Vendor

Transaction Fields VendorGroup classic name is "VEN-VENDOR-GROUP" key required Vendor classic name is "VEN-VENDOR" key required VendorName is Alpha size 30 classic name is "VEN-NAME" required

Add is a Create Action function code is "A" returns message

Change is an Update Action function code is "c" returns transaction

Delete is a Delete Action function code is "D" returns message

Inquire is an Inquire Action function code is "I"

Example of LawsonClassicTransaction Invocation

PurchaseOrder is a BusmessClass invoke APlO Inquire invoked . VendorGroup = Company .VendorGroup invoked . Vendor = Vendor VendorName = result .VendorName

Mo vex Interface Definition File

//A Movex Interface definition is defined within a module and has an extension of . mi. // This definition is required to execute a Movex transaction from an IpI definition.

<MovexInterface> is a Movexlnterface program is <Literal> //for example PDSOOlMI

<ActionName> is a[n] <MIActionType> Action ... [returns (transaction | message)]

[ MIBusClassMap ] //only valid on Create actions

Input Record

<FieldName> [<DataDefinition> ] .. classic name is <Literal> [required] [Output Record]

<FieldName> [<DataDefinition> ] .. [classic name is <Literal>]

MIActionType ::= ( Create Update Delete Find

)

// Create, Update, and Delete types will process the interface asynchronously. They will post a message // to a queue that will be picked up later to be processed. Find type actions are processed sychronously.

MIBusClassMap : : =

[business class is <BusinessClass>] Field Mapping busclass . <FieldName> = ( [result .] <FieldName> | <Literal> )

// The from field can either come from the Output Record ("result " Field) or from the Input Record // In Movex Interfaces typically only the autogenerated field is returned when doing a Create — thus // the input fields need to be used to have a complete key

// The fields in the business class that must be mapped are the primary key fields - either the symbolic key and its context or the part-ofkey and its context.

// We will be enhancing the Movex Interface implementation to use an Asynchronous Message-Based mechanism to execute the transaction when doing

// Create, Update, and Delete actions (not Find Actions).

// One issue with an asynchronous mechanism is that we cannot get feedback from the API immediately, which means that when adding a record that is

// autosequenced we cannot get the autosequenced key value back right away. This is a problem when we need to store a reference to the added record or if we

// want to add more records that refer to the record just added.

// To solve this problem we need to store a surrogate key (a unique id) that will be generated when the API message is sent. When the API is successfully fully

// executed, we will link the primary key of the created record to the surrogate key that was generated. To do this we need to know what fields on the returned

// message of the API map to the primary key fields.

// That is why we need to define which (primary) business class this transaction creates or updates as well as which primary key fields within that business class

// map to which fields on the API.

Example of Movex Interface

Customer is a Movexlnterface program is CRS610MI Add is a Create Action business class is Customer Field Mapping busclas s . Company = Company busclas s . CustomerNumber = result . CustomerNumber

Input Record

CuξtomerTemplate is AlphaUpper size 10 classic name is CUTM required Company is Numeric size 3 classic name is CONO required Division is AlphaUpper size 3 classic name is DIVI Language is AlphaUpper size 2 classic name is LNCD CustomerNumber is AlphaUpper size 10 classic name is CUNO CustomerName is Alpha size 36 classic name is CUNM required CustomerAddres s 1 is Alpha size 36 classic name is CUAl required

Output Record

CustomerNumber is AlphaUpper size 10 classic name is CUNO ErrorMessagelfStatusl2 is Alpha size 50 classic name is ERRM

Example of Movex Interface Invocation

BusmessPartner is a BusmessClass invoke Add Customer invoked. CustomerTemplate = CustomerTemplate invoked . Company = Company invoked . CustomerName = Name

BusPartnerCustomerNumber = result . CustomerNumber

Logical to Physical, Business Class to Table Mapping

// This is stored in αfile named <BusιnessClass>.physi.cal. //Field names and Sets can be referenced in more than one table

// not yet implemented

<BusinessClass> physical storage <TableName> Fields

<FullFieldName> ...

Sets

<SetName> ..

Business Class LPL for Apdisthdr

Apdisthdr is a Busines sClas s owned by ap pref ix i s HDR

Ontology Key

DistCode is a DistributionCode

// This is the default because APCompany extends Company APCompany name i s Company

//Default will name Key Context fields as highest level type name

Patterns implements CRUD

Fields

// generated because of DistributionCode KeyField + Context

Company is an APCompany DistCode is a DistributionCode

Description

AcctEditFlag is Alpha size 1

AcctUnitFlag is element AllFlag

AccountFlag

TotalPercent

TotalTranAmt is element AdjAmt

TotalUnit is element DetailTotal

// generated because of enable surrogate content phrase in KeyField Vendor Group

Sets //generated based on Key definition

Hdrsetl primary indexed Sort Order

Company

DistCode

Hdrset2 // generated to support validation within the Surrogate Context indexed Sort Order

VendorGroup

DistCode

Company

Hdrset3 indexed

Sort Order

DistCode

Company