FI-GLX Validations and Substitutions
`
`The following Help Topics are available:
`
`~stJtutJ~ls
`P~a~e_s
`
`For Help on Help, Press F1
`
`Version
`
`SAP-00005219
`
`

`
`Version
`Prepared for R/3 Release 2.2.
`August 1994
`
`SAP-00005220
`
`

`
`Copyrights
`
`@1994 SAP AG. All rights reserved.
`Neither this documentation nor any part of it may be copied or reproduced in any form or by any
`means or translated into another language, without the prior consent of SAP AG.
`SAP AG makes no warranties or representations with respect to the content hereof and specifically
`disclaims any implied warranties of merchantability or fitness for any particular purpose. SAP AG
`assumes no responsibility for any errors that may appear in this document. The information
`contained in this document is subject to change without notice. SAP AG reserves the right to
`make any such changes without obligation to notify any person of such revision or changes. SAP
`AG makes no commitment to keep the information contained herein up to date.
`
`SAP-00005221
`
`

`
`Introduction
`
`Overview
`
`With FI-GLX’s validations and substitutions software, you can validate and/or substitute data at the
`time of entry--to the FI-GLX System and other SAP Systems.
`You do not need to change the standard SAP System to customize your validations and
`substitutions. For each installation, you can define exactly which validations and substitutions are
`necessary to ensure the integrity of your data.
`This section contains the following topics:
`
`SAP-00005222
`
`

`
`What are Validations?
`
`In the SAP System, almost all input values are validated by a program or against tables or master
`files. Since some types of validations cannot be standardized, you can use FI-GLX’s validations
`program to create validations for your system.
`With validations, you can check values and combinations of values as they are being entered in the
`R/3 environment. Validation rules are stored in the Rule Manager; as data is being entered, the
`Rule Manager validates the data against the validation rules. Because validation occurs before
`data is posted, only valid information is posted to the FI-GLX System.
`Many values that you enter into the SAP System are automatically checked against standard
`validation rules.
`Example:
`The system validates account numbers against a master file or checks that a ledger is assigned to
`an FI-GLX company code.
`You use FI-GLX validations when you want to create a user-defined Boolean statement to validate
`an entry in a way that is not defined for the standard system. FI-GLX validations allows you to
`create your own Boolean statements without making any changes to the standard system.
`A validation can consist of up to 999 steps. Therefore, you can validate data against any number
`of Boolean statements before the data is posted.
`A validation step contains the following two statements:
`¯ Prerequisite statement: The prerequisite statement determines if the entered value(s) should
`be validated. If the prerequisite statement is false, then the value is valid and the transaction
`continues.
`¯ Check statement: The check statement determines if the entered value(s) are valid. If the
`check statement is true, then the value is valid and the transaction continues. If the check
`statement is false, then the system displays a message.
`You define prerequisite and check statements using Boolean Logic. You can define simple
`statements, or you can create complex statements by using rules and sets as part of the Boolean
`Logic statement.
`Some examples of user-defined validations are shown in the following table:
`Examples of User-Defined Validations
`Prerequisite Statement
`
`Check Statement
`
`then only sales centers can be posted.
`If the account is a revenue account
`then the business area must be 2 and plant must
`If the currency is U.S. dollar, and the
`be 10.
`the cost center is 9
`If the user is contained in set RGUSER-02,
`and the currency is in set RGCUR-02
`If the user and the currency are contained
`in the multi-dimension set USERCUR-02.
`
`then the account must be in set RGACCT-02.
`
`then the account must be in set RGACCT-05.
`
`The following figure shows the interaction of FI-GLX validations with values entering the SAP
`System.
`
`SAP-00005223
`
`

`
`© ENTER
`
`DISPLAY
`TRANSACTION VALIDATION
`DATA
`MESSAGES
`
`T
`
`MANAGER
`
`/
`
`E
`
`® RULE
`ISUBSTITUTION
`IVALIDATION
`ISELECTION
`ISUMMATION
`
`RULES
`
`RULES
`
`I
`
`ACTION
`
`DISPLAY
`MESSAGE
`
`\
`\
`
`For each validation step:
`1. Data are entered into the SAP System.
`2. Data are sent to the FI-GLX Rule Manager and to validations.
`Validations is part of the Rule Manager along with substitutions, ledger selection rules and
`summation rules.
`3. Data are then checked against a prerequisite statement.
`If the prerequisite statement is true, the data are checked against the check statement. If the
`prerequisite statement is false, the data are valid.
`4. If the prerequisite statement is true, and the check statement is:
`-
`
`true, then the data are valid.
`false, then the data cannot be posted, and the system displays a message.
`-
`5. If there are additional steps in the validation, the system accesses the next step for validating
`the data until all validation steps have been processed.
`For information about creating Boolean Logic statements, see Boolean Lo~
`You can also define the result of breaking the validation rule. You can instruct the system to send
`the user an information message, or you can force the user to correct the error before continuing
`with data entry.
`
`SAP-00005224
`
`

`
`For information about creating validations, see Validations
`..........................
`
`Validation Messages
`
`When you define validations, you can also define the message and the message’s long text that
`should appear on the user’s terminal if a check statement is not met.
`Example:
`A user cannot post to cost center 200. When the user attempts to post to cost center 200, a
`message will appear and the user will not be allowed to continue with processing.
`For information about creating messages for validations, see Validations
`
`SAP-00005225
`
`

`
`What are Substitutions?
`
`Substitution rules are stored in the Rule Manager; as data is being entered, the data is substituted
`by the Rule Manager. Substitution occurs before the data is summarized in a summary data base.
`FI-GLX substitution is the process of checking entered values (when they are entered into the SAP
`System) against a user-defined Boolean statement. If the statement is true, the system substitutes
`specified values into the FI-GLX system.
`Note
`The system performs substitutions before validations so that substituted values can also be
`validated.
`A substitution can consist of up to 999 steps. Therefore, you can substitute data using any
`number of Boolean statements before the data is posted.
`A substitution step contains the following main components:
`Prerequisite statement: The prerequisite statement defines the conditions that must be met
`before the substitution takes place. If the prerequisite statement is false, the transaction
`continues with no substitution. If the prerequisite statement is true, the transaction continues
`with the substituted value(s).
`Substitution value(s): The substitution value is a numerical or character value with which an
`incoming value should be substituted. You can substitute more than one value per substitution.
`Substitution exit: You can also specify that the substitution be performed in a substitution
`exit. A substitution exit number refers the system to a user-defined ABAP/4 program. When
`you substitute values using a substitution exit, you can define more complex substitutions and
`substitute more than one value in a substitution.
`When you define an FI-GLX substitution, you use the same kind of syntax as in FI-GLX validations.
`The substitution prerequisite statement can be a simple statement or a complex combination of
`statements, rules, and sets.
`Examples of user-defined substitutions are shown in the following table:
`Examples of User-Defined Substitutions
`Prerequisite Statement
`
`Substitution
`
`If the cost center is 10,
`
`then substitute the value 1 for the plant and value 3 for
`the business area.
`then substitute the value 001 for the cost center
`If the account is 10000 and the
`and 012 for the period.
`business area is 20,
`then substitute the value "blank" for the product code.
`If the account is in set ACCT-23,
`and the cost center is in set CENTER-56
`
`You can also use substitutions to summarize data by adding more detail to the document
`information as it is posted to the FI-GLX System.
`Example:
`You can define a substitution to substitute (create) the value 10 in the dimension Plant if the entry
`values are accounts 10000 through 20000 and cost center 2. When the values are posted to the
`FI-GLX, the system creates the value 10 for the dimension plant for accounts 10000 through 20000
`and cost center 2.
`The following figure shows the interaction of FI-GLX substitutions with values entering the SAP
`
`SAP-00005226
`
`

`
`FALS E
`
`TRUE
`
`SUBSTITUTION I
`
`IPERFORM
`
`SUBSTITUTION
`
`System.
`
`ENTER
`TRANSACTION
`DATA
`
`RULE
`MANAGER
`
`IS UBSTITUTION
`IVALIDATION
`I\
`I\
`ISELECTION
`I\
`ISUMMATION
`
`RULES
`
`RULES
`
`® ®
`
`For each substitution step:
`1. Data are entered into the SAP System.
`2. Data are sent to the FI-GLX Rule Manager and to substitutions.
`Substitutions is part of the Rule Manager along with validations, ledger selection rules and
`summation rules.
`3. Data are then checked against a prerequisite statement.
`If the prerequisite statement is true, the system performs the substitution. If the prerequisite
`statement is false, then there is no substitution.
`4. If there are additional steps in the substitution, the system accesses the next step for
`substituting the data until all substitution steps have been processed.
`Note
`When you are substituting values from outside the FI-GLX system, the dimension being substituted
`must be defined for the Boolean class for which you are substituting data.
`For information about creating substitution statements, see Boolean Loq~ntax
`
`SAP-00005227
`
`

`
`Boolean Logic Statements and Rules
`
`The SAP System uses Boolean Logic to create validation/substitution statements. A Boolean
`Logic statement is a linguistic, logical structure that can be either true or false. Statements can be
`linked together using operators (such as OR, AND, NOR) to create complex statements.
`Boolean Logic uses truth tables to determine the truth value (TRUE or FALSE) of statements. A
`truth table assigns the value of T (TRUE) or F (FALSE) to each part of a statement of a complex
`statement, and then determines if the combined statement is true or false.
`The following example uses a truth table for the AND (conjunction) operator to determine if a value
`should be substituted.
`
`Transaction Data
`
`,L
`
`FALSE
`
`TRUE
`
`TRUE
`
`ISUBSTITUTE VALUE I
`
`In this example, if the transaction contains Account 500000 and Cost Center 150, then the
`combined statement is true, and the value is substituted. If the transaction does not contain
`Account 500000 and Cost Center 150, then the combined statement is false, and the value is not
`substituted.
`
`SAP-00005228
`
`

`
`In the FI-GLX System, you can use a Boolean statement in one process, and then use the same
`statement in another process by linking the statement to another statement. To use a Boolean
`statement in an FI-GLX process or in another statement, you create a rule.
`
`Rules
`
`Rules
`
`A rule is a Boolean expression that you can use as a condition or check or in another rule.
`allow you to refer to frequently used Boolean expressions by using the rule name.
`Rules are used in:
`validations
`substitutions
`ledger selection
`For information about the use of rules in ledger selection, see FI-GLXBasic Functions.
`¯ Report Writer
`For information about the use of rules in Report Writer, see FI-GLXReport Writer.
`rollups
`For information about the use of rules in rollups, see FI-GLXBasic Functions.
`You create rules using the Customizing function. For information about Boolean Logic statements
`and rules, see Boolean Lo~
`Note
`This manual explains how to create rules for use in the Validations/Substitutions software. For
`information about the use of rules in other FI-GLX modules, see the respective documentation.
`
`¯
`
`Rule Manager
`
`The Validations/Substitutions software also contains a Rule Manager, which stores all rules created
`on the FI-GLX System. The Rule Manager also processes rules when they are called from a
`validation/substitution callup point.
`Example:
`If a rule does not exist but is defined for a validation and/or substitution, the Rule Manager will
`output an error message.
`
`SAP-00005229
`
`

`
`Boolean Classes
`
`The Boolean class determines the fields that can be used in a validation/substitution/rule definition,
`as well as the message class for validation messages.
`Example:
`Application area CO and callup point 0001 use Boolean class 001, which is a list of all COBL fields.
`If you define a validation that uses Boolean class 001, you can only use those COBL fields defined
`for Boolean class 001.
`When you define validations, substitutions, and rules, you must assign an application area and
`callup point code to the validation/substitution/rule. The application area code specifies the
`general application area where the validation/substitution occurs (for example, GL for FI-GLX
`postings), and the callup point code specifies the exact location of the validation/substitution (for
`example, 0001 for posting header check). The combination of application area and callup point
`code determine the Boolean class for a validation/substitution/rule.
`The following table lists current Boolean classes and descriptions, as well as the application area
`and callup point codes that comprise the Boolean classes.
`Boolean Classes
`Boolean Class
`
`Application area
`
`Callup pnt Module
`
`Description
`
`Coding block field
`CO
`G/L Ledger selection ......
`G/L < 2.1
`GR
`
`GS
`
`selection
`
`0001
`
`Valid/Subst.
`
`0001
`
`Report Writer
`0001
`Ledger
`
`001
`002
`003
`
`004
`
`005
`006
`007
`020
`
`021
`
`022
`
`023
`
`024
`
`GLU1 (complete)
`
`GU
`GL
`GU
`G/L Ledger selection ......
`GLU1 Header segment GL
`G/L Report Writer
`GR
`Ledger selection GLX
`GS
`sele.
`Ledger selection CO1
`select.
`Ledger selection CO2
`select.
`Ledger selection FI
`select.
`Ledger selection JV
`select.
`
`GS
`
`GS
`
`GS
`
`GS
`
`0001
`0002
`0002
`
`0001
`0002
`0003
`
`0004
`
`0005
`
`0006
`
`0007
`
`Rollups
`Valid/Subst.
`Rollups
`
`Valid/Subst.
`Report Writer
`GLX Ledger
`
`CO Ledger
`
`CO Ledger
`
`FI Ledger
`
`JV Ledger
`
`Caution
`A Boolean class can be used by other callup points and application areas, so you should use
`caution when changing a Boolean class.
`
`SAP-00005230
`
`

`
`Tables GB01 and GB01C determine which fields can be used for a specific Boolean class. Table
`GB01 is an SAP-delivered, client-independent, control table and cannot be changed; table GB01C
`is client-dependent and is provided specifically for customer configuration.
`You can not select a different Boolean class for a callup point, but you can modify the contents of
`fields for a Boolean class, see ~e!e.t.ing...~.J._.d._s t.o..#~..~o[ean.~_.C.Jass"
`the Boolean class by adding fields to the Boolean class. For information about adding/deleting
`
`Application Areas
`
`The application area specifies the general application area where the validation/substitution occurs
`(for example, GL for FI-GLX postings). The Validation/Substitution software provides the following
`application area codes:
`CO (Controlling): You can define validations, substitutions, and rules for
`validations/substitutions using this application area.
`GL (Extended General Ledger): You can define validations, substitutions, and rules for
`validations/substitutions using this application area.
`GR (Report Writer): You can only define rules for Report Writer using this application area.
`GS (Ledger Selection): You can only define rules for ledger selection using this application
`area.
`¯ GU (Rollups): You can only define rules for rollups using this application area.
`
`Validation/Substitution Callup Points
`
`Validation/substitution callup points are specific places in the FI, MM, CO, and FI-GLX applications
`which specify the exact location where a validation/substitution occurs. If you want to
`validate/substitute a value, you must activate the validation/substitution for the callup point for
`which you want the validation/substitution to occur.
`Example:
`If you want to validate account numbers that are directly entered into the FI-GLX system, you must
`define a validation for callup point 0001 (document header) with application area GL. Once you
`have defined the validation, you then need to activate the validation.
`At each callup point, the system can use information you have already entered (such as user name,
`header information, and information entered in previous callup points) to validate/substitute the
`values you enter at a callup point.
`Example:
`Your check statement may require that for SAP company code 01 and currency code US$, the
`account number must be between 200000 and 220000. In FI, you enter the account number at
`callup point 0001 ; however, you enter the SAP company code and currency code prior to callup
`point 0001. The system uses the SAP company code and currency information you enter prior to
`callup point 0001 to validate the account number you enter in callup point 0001.
`Note
`Different application area codes may use the same callup point code, but the callup point code
`does not refer to the same callup point.
`
`Example:
`
`Callup point code 0001 has a different meaning for Cost Accounting (CO) validations and Extended
`General Ledger (GL) validations.
`
`SAP-00005231
`
`

`
`Overview of Validations/S u bstitutions
`To define FI-GLX validations/substitutions, you must complete the following tasks:
`1. Decide where the validation/substitution will be performed.
`Where a validation/substitution is performed depends on two codes:
`the application area code: a 2-digit character code, which specifies the general application
`area where the validation/substitution occurs (for example, GL for FI-GLX postings), and
`
`the callup point code: a 4-digit number, which specifies the exact location of the
`validation/substitution (for example, 0001 for posting header check).
`The combination application area/callup point code determines the validation/substitution’s
`Boolean class. For information about Boolean classes, see Boolean Classes
`2. Create a validation/substitution or select an existing validation/substitution.
`When you create a validation, you:
`enter the application area, callup point, and Boolean class for the validation,
`
`define the prerequisite statement that should be used for selecting data for validation and the
`check statements against which selected data should be validated
`determine the messages that will appear if a check statement is not met during validation.
`For information about creating a validation, see .Va!!dat.!o.ns
`When you create a substitution, you:
`enterthe application area, callup point, and Boolean class forthe substitution
`
`define the statement that should be used for selecting data for substitution and value with
`which the data should be substituted.
`For information about creating a substitution, see Substitutions
`3. Activate the validation/substitution.
`You activate a validation/substitution by:
`entering the callup point and company code (for SAP local companies)/company ID (for
`FI-GLX global companies) for the validation/substitution. For CO validations/substitutions,
`you enter the callup point and controlling area for validation/substitution.
`assigning the validation/substitution name to the callup point/company or controlling area
`combination and setting the activation flag.
`Once the validation/substitution is activated, it will be called when a posting is made.
`For information about activating a validation, see Activatinq..a..~.a.t.ion For information about
`activating a substitution, see Activating,.a..~tu.t.ipn. For information about the use of
`validations/substitution in CO, see the CO Implementation Guide (IMG).
`
`SAP-00005232
`
`

`
`Conversion to Release 2.1A
`
`If you used rules in releases prior to Release 2.1A, you may want to convert the old format rules to
`the new format in order to improve system performance. You convert the rules using report
`RGUGBR10.
`To determine if your system uses the new rule format, use report RGUGBR15.
`For information about using these reports and other rule manager reports, see .U~iD.q.:tD.e..F~.u.!e..
`~,.e.,r.,,_,R,.,e,.~ .o..&s..
`Caution
`Once the old rules have been converted, they cannot be converted back again.
`
`SAP-00005233
`
`

`
`Validations
`
`With validations, you can check values and combinations of values as they are being entered in the
`R/3 environment. Validation rules are stored in the Rule Manager; as data is being entered, the
`Rule Manager validates the data against the validation rules. Because validation occurs before
`data is posted, only valid information enters the FI-GLX System.
`This section contains the following topics:
`
`..¢.han ig~g~.a..V.alidati.o.n
`,D.el.e.tJ Qg..a..V..aJidat ~o.n
`Ac.t J.ya.t J.ng.a..Y.al.id ati.o~t
`D.ea.c..t i.v.a.t in~.a..V.alidati.o.n
`
`SAP-00005234
`
`

`
`Introduction to Validations
`You can use a validation simultaneously at different callup points, and you can create different
`dependencies for validating data. Also, you can define a validation on the system, even if it is not
`called anywhere (for example, for future usage).
`To use a validation, you perform the following steps:
`1. Decide where the validation will be performed.
`Where a validation is performed depends on two codes:
`
`the application area code: a 2-digit character code, which specifies the general application
`area where the validation occurs (for example, GL for FI-GLX postings), and
`the callup point code: a 4-digit number, which specifies the exact location of the validation
`(for example, 0001 for posting header check).
`
`Note
`Different application area codes may use the same callup point code, but the callup point code
`does not refer to the same callup point.
`
`Example:
`
`Callup point code 0001 has a different meaning for Cost Accounting (CO) validations and Extended
`General Ledger (GLX) validations.
`The combination application area/callup point code determines the validation’s Boolean class.
`The Boolean class determines the fields that can be used in the validation, as well as the
`message ID for validation messages.
`Example:
`Application area CO and callup point 0001 use Boolean class 001, which is a list of all COBL
`fields. You can not select another class for this callup point, but you can modify the contents of
`the Boolean class by adding fields to the Boolean class.
`For information about adding fields to a Boolean class, see &,.d.,d.j,0g~.e..l#.t,i..n.g Fields to a Boolean
`Clas_==s_
`Caution
`The Boolean class can be used by other callup points and application areas, so you should use
`caution when changing a Boolean class.
`For information about Boolean classes, see Boolean Classes
`2. Create a validation or select an existing validation.
`When you create a validation, you enter the application area, callup point, and Boolean class for
`the validation. You also define the prerequisite statement that should be used for selecting
`data for validation and the check statements against which selected data should be validated.
`You can also determine the messages that will appear if a check statement is not met during
`validation.
`For information about creating a validation, see Creatinq a Validation
`3. Activate the validation.
`You activate a validation by entering the callup point, company code (for SAP local
`companies)/company ID (for FI-GLX global companies), and activation flag for the validation.
`Next, you assign the validation name to the callup point/company combination. Once the
`
`SAP-00005235
`
`

`
`validation is activated, it will be called when a posting is made.
`For information about activating a validation, see Activatinq a Validation
`In R/3, release 2.1A, validations are called in two places:
`¯ Postings that use cost accounting groups
`First, you define a validation for a cost accounting group and then activate the validation.
`When you post with transaction FB01 (in FI), the validation specified for the cost accounting
`group is performed. CO validations are made using transaction FB01 (in FI) and MR01 (in MM)
`within the appropriate controlling area.
`¯ Direct postings to Extended General Ledger (FI-GLX)
`First, you define a validation for a local SAP company code or global FI-GLX company code and
`then activate the validation. When you post with transactions GB01 (in FI-GLX) or GB11 (in
`FI-GLX), the validation specified for the company is performed.
`Two different validations callup points are possible: one for validating the posting header of the
`document, and one for the document lines. You can specify a separate validation for each of
`these callup points.
`
`SAP-00005236
`
`

`
`Creating a Validation
`
`To create a validation:
`1. Select Tools --> Customizing --> Configuration --> Accounting -~ Financial accounting -->
`Extended G/L --> Tools --> Val/subst/rules --> Validation.
`The Change Validation: Initial screen appears.
`Note
`You can also access the Change Validation: Initial screen from the Extended General Ledger
`FI-GLX menu by selecting Environment--> Configuration menu--> Tools--> Val/subst/rules -->
`Validation.
`
`.
`
`.
`
`Select Validation --> Create.
`The Create Validation: Initial screen appears.
`Complete the following fields:
`Validation Type a name for the validation.
`Applictn area Type the two-character code for the application area.
`determines from which application program the validation is called.
`CO
`Controlling
`Extended General Ledger
`GL
`Callup point Type the four-character code for the callup point.
`when the validation will be called during processing.
`Example:
`The callup point that you can enter in this field depends upon the application area that you
`entered in the Applictn area field for the validation. Example entries for the application
`area/callup point combinations are shown in the following table.
`Example Entries for Application Area/Callup Point Combinations
`Application Area Callup Point Description
`
`The application area
`Example entries include:
`
`The callup point determines
`
`CO
`GL
`
`0001
`0001
`0002
`
`Primary data
`Document header
`Document position
`
`The Boolean class is determined based upon your entries in the Applictn area and Callup point
`fields. For information about Boolean classes, see Boolean Classes
`
`Copying a Validation
`
`Reference - Validation Type the name of a validation that you want to copy.
`have the same Boolean class as the validation you are creating.
`4.
`Press ENTER.
`The Create: Validation - <Validation Name> screen (1) appears.
`Complete the following fields:
`Validation name Type a description of the validation. The validation description is
`language-dependent and will display in validation lists when the validation is processed.
`
`.
`
`The validation must
`
`SAP-00005237
`
`

`
`Authorization group If you want to require that a user have authorization for creating,
`displaying, changing, and deleting this validation, type the name of an authorization group in the
`Authorization group field. If you do not want to require user authorization, leave this field blank.
`6. You can use the following additional processing functions on this screen.
`Additional Processing Functions -Create: Validation <Validation Name> Screen (1)
`Select
`To
`
`Validation --~ Save
`Edit -~ Choose
`Edit --~ Insert entry
`Edit--~ Delete entry
`Details --> Rule fields
`
`Details --> Rule list
`
`Details --> Usage
`Environment -~ Rules
`
`Save the validation.
`Change an existing validation step.
`Add a validation step.
`Delete a validation step.
`Display a list of valid fields and tables that you can use.
`These fields and tables are determined by the Boolean class of the
`validation.
`Display a list of defined rules that use the same Boolean class as
`the validation.
`Display where the validation is currently used.
`Create/change/display rules.
`
`.
`
`.
`
`.
`
`Select Edit --> Insert entry.
`A new step appears for the validation. A step number is automatically assigned.
`You can define up to 999 steps for each FI-GLX validation. The validation steps are processed
`in the order displayed on the screen. To rearrange the order, type over the step number with
`the number of the step it should follow.
`Example:
`You want step 004 to follow step 001. Type 002 over the value 004.
`To move a step to the beginning of the list, type over a value with 000.
`
`Move the cursor to the new step and select Edit --~ Choose.
`The Create: Validation - <Validation Name> screen (2) appears.
`Complete the following fields:
`Prerequisite Type a Boolean Logic statement as the prerequisite statement for selecting data
`for validation. If the prerequisite statement is false, then the entered value is not selected for
`validation, and the transaction continues. If the prerequisite statement is true, the entered
`value is checked against the check statement entered in the Check field.
`The prerequisite statement can consist of up to six lines and uses the same syntax as in the R/2
`System. For information about syntax rules for entering Boolean statements, see !3.Q.Q].e~r)...
`
`Check Type a Boolean Logic statement as the check for validating data selected by the
`statement in the Prerequisite field. If the check statement is true, then the entered value is
`valid, and the transaction continues. If the check statement is false, then the system sends a
`message to the user.
`For information about syntax rules for entering Boolean statements, see Boolean Loq~.S.,yn.tax
`Typ Type a message type. If the check statement is false, the system sends a message to
`the user. The message type determines the action required by the user.
`
`SAP-00005238
`
`

`
`The following table contains valid validation message types.
`Validation Message Types and Descriptions
`Type Text Description
`
`Information
`
`W
`
`E
`
`Warning
`
`Error
`
`A
`
`Aborts
`
`An information message appears for the user.
`The posting transaction continues.
`A warning message prompts the user for action, but the
`message can be ignored and posting continued.
`An error message informs the user that the entry has been
`rejected by the system and that a new entry must be made.
`Posting cannot proceed until the error is corrected.
`A termination message is displayed after the system terminates
`a transaction. Transaction aborts.
`
`No. (Message Number) Type a message number.
`
`The message number refers to a message that is created using the Environment -~ Messages
`function. When the check statement is false, the system displays the message that
`corresponds to the message number you enter in the No. field.
`For information about entering messages, see Validation Messa~
`Output fields (1-4) Type a table and field combination for up to four message variables.
`Variables in the message are represented by a $ sign.
`There are four (1-4) table/field entry fields for up to four message variables ($). When the
`system encounters a variable ($) in a message, it replaces the variable with the corresponding
`table/field value. The order of the table/field names corresponds to the order that the variables
`appear in the message.
`Example:
`There are two variables in the following message:
`Cost center $ cannot be used with account $.
`The first variable ($) refers to table GLU1 and the dimension Cost Center. Therefore, the
`entries in the first Output fields fields are as follows:
`Output fields 1 GLU1 RCNTR
`The second variable ($) refers to table GLU1 and the dimension Account. Therefore, the
`entries in the second Output fields fields are as follows:
`Output fields 2 GLU1 RACCT
`If the value entered for cost center is 100, the value entered for account is 0000050000, and the
`check statement is false, the system displays the message:
`Cost center 100 cannot be used with account 0000050000.
`The table/field combinations that can be used for this validation depend on the Boolean class
`assigned to the validation. You can view valid table/field combinations using the Details --~
`Rules fields function.
`Example:
`For Boolean class 1, table SY and field UNAME can be used.
`The table name and field should be entered directly without the using <, >, and $ signs, as is
`
`SAP-00005239
`
`

`
`required when entering the prerequisite statement (Prerequisite field) and check statement
`(Check field).
`10. You can use the following additional processing functions on this screen.
`Additional Processing Functions - Create: Validation <Validation Name> Screen (2)
`Select
`To
`
`Details --> Rule fields
`
`Details --> Rule list
`
`Environment --> Rules
`Environment -~ Messages
`
`Display a list of valid fields and tables that you can use for the
`validation. These fields and tables are determined by the
`Boolean class of the validation.
`Display a list of defined rules that use the same Boolean class
`as the validation.
`Create/