Critical error messages

Navigation:  Testing and releasing the repository > Validating the repository > Validation messages >

Critical error messages

Previous pageReturn to chapter overviewNext page

Table 7-3 details all of the critical error validation messages that may occur during the validation process and provides a brief description of their meaning:

Critical Error Validation Message

Description

Please run Schema Maintenance. Following Aliases refer to nodes that do not exist.

Customized Schemas are used to define the structure of an input document. In some cases these Customized Schemas may be complex and not easily readable. Aliases can be assigned to nodes in a Customized Schema and are used to provide better readability. When a Customized Schema is modified, for example if a node is moved or deleted, items that refer to that node, such as decisions or Aliases, may refer to a node that no longer exists in the Customized Schema. This validation will return an error when an Alias refers to a node that no longer exists on a Customized Schema.

Following abort operations are not allowed in their current location.

 

Abort operations can be used inside Formula Versions and UDOs to abort the current formula, the current decision, or the current decision group. Abort operations are only valid in certain places. For example, an 'AbortFormula' operation could be used in the 'when true' argument of an 'If' operator but it could not be used as a 'Boolean test' argument for an 'If' operator as this makes no logical sense. This validation returns an error if any Abort operations are in locations that are known to be invalid.

Following decisions and decision groups have wrong action type against their context nodes.

 

Decisions are associated with paths to nodes in a Customized Schema. Nodes can be categorised into types- either 'repeating' or 'non-repeating'. Nodes can also be categorised as either 'output' or 'non-output'. Decisions have action-types, such as 'Create if Necessary', 'Update', etc. Some action types are invalid for decisions with paths to repeating nodes and some action types are invalid for decisions with paths to non-repeating nodes. For example, the 'Create' action type can be used on repeating nodes but it cannot be used on non-repeating nodes. Some actions such as 'Create', 'Create if Necessary', and 'AlwaysCreate' are invalid for decisions or decision groups with paths to non-output nodes. This validation returns an error when a decision or decision group uses an action type that is incompatible with the type of the associated node.

Following Formula Versions/UDOs are pointing to decisions that no longer exist

In Formula Versions and UDOs, the 'Execute decision' operation can be used to execute a decision and retrieve the results of that decision. If the decision no longer exists, then it cannot be executed. This validation returns an error if an 'Execute decision' operation is used on a decision that does not exist.

Following decisions have reference to formulas of the wrong data type.

 

Decisions are attached to a set of formulas through 'Formula References'. Both decisions and formulas have data types. If the result obtained by running the formula has a data type that is not compatible with the data type of the decision then the decision cannot execute properly. This validation returns an error if a decision refers to a formula that has a data type that is incompatible with the data type of the decision.

 

Following decisions and decision groups do not have paths assigned.

 

decisions and decision groups are associated with paths on a Customized Schema. These paths are important for determining how a decision or decision group is to be executed. If a decision or decision group has no path it will not be executed. This validation returns an error if a decision or decision group has no associated path.

Following Formula Versions/UDOs access nodes that are not in any Schema in the decision model.

 

All Customized Schemas that will be generated are checked for any formulas or UDOs that cross the decision model-Schema boundary. This may include formulas or UDOs that are never executed. Decision models reference any number of Customized Schemas. These Customized Schemas determine which input documents a decision model may operate on. A decision model can only operate on items that belong to a Customized Schemas that it references. Formulas and UDOs belong to Customized Schemas in a Repository. Each decision that has a context also effectively belongs to a Customized Schema. This validation returns an error if a formula or UDO belonging to a Customized Schema is executed either directly, or indirectly, from a decision model that does not reference that Customized Schema. This validation also returns an error if a formula or UDO referenced by a decision model executes a decision belonging to a Customized Schema that is not referenced by that decision model. This validation also returns an error if a formula or UDO executed by a decision model contains operations that refer to one or more nodes on a Customized Schema that are not referenced by that decision model.

The following decision models do not have any Schemas referenced.

 

Decision models have references to one or more Customized Schemas that describe the input documents that will be processed by the business rules. If a decision model contains no references to Customized Schemas, then no input documents are processed and no rules can be executed. This validation returns an error if a decision model exists but has no references to Customized Schemas.

Following decision models have invalid packages or class names.

 

In previous versions of IDIOM Decision Manager it was possible to create a decision model with an invalid fully-qualified path. While this should not occur in recent versions of IDIOM repositories imported from older versions may still contain paths with invalid characters or paths that start with a numeral. This validation returns an error if a decision model has a path that contains invalid characters or starts with a numeral.

Following decisions are pointing to nodes that have invalid data types, or non-existent nodes.

 

Decisions are associated with paths to nodes on a Customized Schema. Both decisions and nodes have data types. If the result obtained by running the decision has a data type that is not compatible with the data type of the node, then the decision cannot update the node correctly. This validation returns an error if a decision refers to a node that has a data type that is incompatible with the data type of the decision.

 

Following decisions are non-control and have non-output context nodes.

 

Decisions can be grouped into two categories: 'Non-Control' decisions have a result whereas 'Control' decisions do not have a result. Decisions are associated with paths to nodes on a Customized Schema and these nodes can be either 'normal' nodes or 'output' nodes. 'Normal' nodes can be read, but not written to, and 'output' nodes can be read or written to. If a 'Non-Control' decision (which must have a result) is associated with a path to a 'normal' node on a Customized Schema, then that decision cannot update the node because the node cannot be written to. In these cases the decision would achieve nothing. This validation returns an error if a 'Non-Control' decision refers to a node that cannot be written to.

Following decisions and decision groups do not have valid paths.

 

Decisions and decision groups are associated with paths to nodes on a Customized Schema. These paths govern how decisions are executed. If the paths for decisions or decision groups point to nodes that do not exist on the Customized Schema, then there is no way to determine how that decision or decision group is to be executed. This validation returns an error if a decision or decision group has a path to a node that does not exist

These Formula Versions/UDOs delete the root node of the Schema.

 

Delete Operations on nodes can be either set to 'Clear' or 'Remove' mode. When in 'Remove' mode, the Node is removed from the input document entirely. An input document must have a root node, and therefore Delete Operations in 'Remove' mode must not remove the root node on a Customized Schema. This validation will return an error if a Delete Operation in 'Remove' mode targets the root node of a Customized Schema.

These Formula Versions/UDOs delete non-output nodes.

A Customized Schema has nodes that are grouped into 'output' nodes and 'non-output' nodes. Delete Operations on nodes can be either set to 'Clear' or 'Remove' mode. An input document must always have a root node, and therefore Delete Operations in 'Remove' mode must not remove the root node on a Customized Schema. This validation will return an error if a Delete Operation in 'Remove' mode targets the root node of a Customized Schema.

Following items' effective dates are later than their end dates.

 

In a repository, certain items including Table Contents, Formula Versions, and Formula References are stored in groups. These items have an effective date and an end date, which together describe the interval in which the item is valid. Given an item, at any time earlier than the effective date, or later than the end date, the item will be considered invalid. If the end-date for an item is earlier then the effective date, then the item is never valid, and will never be executed. This validation returns an error when an item has an end-date prior to its effective date.

Following Formula Versions/UDOs contain equals operators between strings.

 

Formula Versions and UDOs are composed of operations. Operations can be grouped into categories by the name of the Operator that they use. The 'Equals' operator is used to compare values and determine whether or not they are equal. The 'Equals' operator is designed for easy use with most data types, eg. int or dateTime. However the 'Equals' operator is not designed for use with the string data type. Another operator 'StringCompare' is used to compare values of data type string. This operator allows for increased flexibility in string comparison by introducing 'CaseSensitive' and 'CaseInsensitive' modes. This validation will return an error if an 'Equals' operation is present is used on strings. The 'Equals' operation should be replaced with a 'StringCompare' operation instead.

Following Formula Versions/UDOs use the ExternalContext/PreviousContext operators in an incorrect manner.

 

In IDIOM, Formula Versions are composed of operations. The operator 'PreviousContext' is used within a 'NodeList' operation, and is used to shift the current context to the direct predecessor of the 'NodeList' operation. This shift makes no sense if there is an 'ExternalContext' operation that contains the 'NodeList' and 'Previous Context' operations. This validation returns an error when a Formula Version uses a 'PreviousContext' operation inside an 'ExternalContext' operation.

Following formulas have unsupported data types.

 

Formulas must have a data type that must be set to one of the supported data types. In previous versions of IDIOM, formulas could be set to data type 'date', however current versions do not support 'date' and require the use of 'dateTime' instead. This validation returns an error when a formula is set to an unsupported data type, such as 'date'.

Following Formula Versions/UDOs are pointing to formulas that no longer exist.

 

In IDIOM, Formula Versions and UDOs can execute other formulas to obtain results by using the 'ExecuteFormula' operator. For the result to be returned, the 'ExecuteFormula' operation must target a formula that exists. If the target formula no longer exists, then this will cause an error. This validation returns an error when an 'ExecuteFormula' operation points to a formula that no longer exists.

Following Formula Versions contain node Operations that are pointing to nodes of the wrong data type.

 

FormulaVerions can contain 'Node' operations that refer to nodes on a Customized Schema. Each Node operation refers to a node and has an associated data type. This data type must be compatible with the data type of the node as defined on the Customized Schema. An error may occur if a Node operation is created and then subsequently the data type defined by the Customized Schema changes. In this case the data type of the Operation may no longer be identical to the data type described on the Customized Schema. To resolve this problem, the Node operation should be replaced with a new Node operation that has the correct data type, or the Customized Schema must be adjusted to agree with the data type specified on the Operation. This validation will return an error when a Formula Version contains a Node operation that has a data type that is not compatible with the data type expected from the Customized Schema.

Following Formula Versions refer to one or more non-existent nodes.

 

Formula Versions can contain operations that refer to nodes on a Customized Schema e.g. a 'Node' operation. If a Formula Version has an operation that refers to a node on a Customized Schema, that node must exist on the Schema. If no such node appears in the Schema, the operation cannot be executed. This validation will return an error when a Formula Version has an operation that refers to a node that does not exist in the Customized Schema.

Following Formula Versions refer to nodes that are not reachable.

 

Formula Versions can contain operations that target nodes on a Customized Schema, e.g. a 'Node' operation. Formula Versions also have contexts, which are specified when the formula is created. If a Formula Version has a 'Node' operation or 'IsValidNode' operation, the target node must be reachable from the current context. This validation will return an error when a Formula Version has an operation that refers to a node that is not reachable from the current context.

Following Formula Versions have invalid paths. Please contact Idiom support.

 

Formulas belong to a specific location Node on a Customized Schema. In previous versions of IDIOM, it was possible for a formula to become disconnected from its location Node. A Repository where this happens is considered corrupt and must be fixed by IDIOM Support. This validation will return an error when a Formula has become disconnected from is location Node.

 

Following Formula Versions/decisions/UDOs are pointing to formulas that are unreachable.

 

Formulas are executed either by a decision (through a Formula Reference) or by a UDO or another Formula Version (through an 'ExecuteFormula' operation). Regardless of which method is used, the formula that is to be executed must be reachable from the item that causes the execution. For example, if a formula 'Calculate Price' is located on a node that has a repeating child node, it could not use an 'ExecuteFormula' operation pointing to a formula that lived under that repeating child node. This validation will return an error when a formula is executed from a location, but is not reachable from that location.

Following Formula References refer to items that do not exist within the decision model. Please contact Idiom support.

Formula References describe the formulas that a given decision may execute. In older versions of IDIOM it may be possible to create a Formula Reference that refers to a decision or formula that no longer exists. This validation will report an error if any Formula Reference is present that refers to a decision or formula that no longer exist.

Index Operations have no repeating ancestor.

Formula Versions and UDOs are composed of operations. Operations can be grouped into categories by the name of the Operator that they use. The 'Index' operator is unusual because it is only meaningful on repeating nodes or on nodes that have repeating ancestor nodes. This validation will return an error if an 'Index' operation is used on a node that does not repeat and that has no repeating ancestor nodes.

Following items start cyclic references of execution.

 

In IDIOM, decisions, formulas and UDOs can execute each other in a number of different ways. For example, a decision can execute a formula through a Formula Reference. A Formula Version can execute a UDO through an 'ExecuteUDO' operation, etc. It might be possible to have one item executing a second item which then executes the first item again, which would then execute the second item again, and so on. This type of circular execution can often never terminate, and is prohibited. This validation returns an error if such a pattern occurs, i.e. where two or more items execute each other in a circular manner.

Following Formula Versions/UDOs have node related operations that are pointing to a non-existent node.

 

Formulas and UDOs can contain operations that refer to nodes on a Customized Schema e.g. a 'node' operation. If a formula or UDO has an operation that refers to a node on a Customized Schema, that node must exist on the Schema. If no such node appears in the Schema, the operation cannot be executed. This validation will return an error when a formula or UDO has an operation that refers to a node that does not exist in the Customized Schema.

Following Formula Versions/UDOs contain node operations that are not reachable.

 

Formulas and UDOs can contain operations that target nodes on a Customized Schema, e.g. a 'Node' operation. The context of the formula or UDO is determined by where it is being executed from. If a formula or UDO has a 'Node' operation or 'IsValidNode' operation, the target node must be reachable from the current context. This validation will return an error when a formula or UDO has an operation that refers to a node that is not reachable from the current context.

Following Formula Versions/UDO's contain node operations that are pointing to nodes of wrong data type.

 

Formulas and UDOs can contain 'Node' operations that refer to nodes on a Customized Schema. Each Node operation refers to a node and has an associated data type. This data type must be compatible with the data type of the node as defined on the Customized Schema. This error may occur if a Node operation is created and then subsequently the data type defined by the Customized Schema changes. In this case the data type of the Operation may no longer be identical to the data type described on the Customized Schema. To resolve this problem, the Node operation be replaced with a new Node operation that has the correct data type, or the Customized Schema must be adjusted to agree with the data type specified on the Operation. This validation will return an error when a formula or UDO contains a Node operation that has a data type that is not compatible with the data type expected from the Customized Schema.

Following items have duplicate effective dates with other items in the same group.

 

In a repository, certain items, including Table Contents, Formula Versions, and Formula References, are stored in groups. Each item has an effective date and Formulas Versions have an end date, which together describe the interval during which the item is valid. Given an item, at any time earlier than the effective date, or later than the end date, the item will be considered invalid. Given a current date, the current item in a group is the item with the most recent effective date that is still valid. If two items in the same group have the same effective date, there is no way to determine which of the items should be used. For example: A decision has two Formula References, one pointing to Formula A, and one pointing to Formula B. If both Formula References had the same effective date, there would be no way to tell which formula should be executed for that decision. This validation returns an error if there are two or more items in a group with the same effective date.

Following Formula Versions/UDOs are incomplete but marked as complete.

 

Formula Versions and UDOs are constructed by combining operations. Formula Versions and UDOs that contain empty spaces for Operations are considered 'incomplete'. When a Formula Version or UDO is marked as incomplete, it cannot be executed and will be treated as though it did not exist. Sometimes Formula Versions or UDOs may be internally marked as complete when they are incomplete following schema maintenance when widespread changes are made. These can usually be cleared by opening them, making a change, then saving them. If this fails to remove the error, contact Idiom Support. This validation will return an error when an incomplete Formula Version or UDO is internally marked as complete.

Following Formula Versions/UDOs are complete but marked as incomplete.

Formula Versions and UDOs are constructed by combining operations. Formula Versions and UDOs that contain empty spaces for Operations are considered 'incomplete'. When a Formula Version or UDO is marked as incomplete, it cannot be executed and will be treated as though it did not exist. Sometimes Formula Versions or UDOs may be internally marked as incomplete when they are complete following schema maintenance when widespread changes are made. These can usually be cleared by opening them, making a change, then saving them. If this fails to remove the error, contact Idiom Support. This validation will return an error when a complete Formula Version or UDO is internally marked as incomplete

Following Formula Versions/UDOs contain an operator that is no longer supported. Please contact Idiom support.

 

Formula Versions and UDOs are constructed by combining operations. Operations are grouped into many different types, depending on the name of the Operator used. Operators such as 'If' and 'Add' have been supported by IDIOM since inception. In later versions, new operators are added, and in some cases, older operators are removed and are no longer supported by IDIOM. This validation returns an error if a Formula Version or UDO uses an operator that is no longer supported by IDIOM. In such cases you may require the services of IDIOM Support to assist you in altering your repository to conform to the updated standards.

Following Formula Versions/UDOs have summation variables that are used incorrectly

Formula Versions and UDOs are composed of operations. Operations can be grouped into categories by the name of the Operator that they use. The 'Summation' operator is used to calculate the sum of a sequence of terms. A 'Summation' operation should define a parameter with a name, for example 'var', and the term to be summed. The parameter can be referenced inside the expression. The parameter cannot be referenced inside the start or end descriptions. The parameter cannot overlap another parameter with the same name. The parameter must not be used outside the term of a summation operation. This validation will return an error if any of the conditions above is violated.

Following Formula Versions/UDOs contain a regular expression with an invalid pattern.

 

Formula Versions and UDOs are composed of operations. Operations can be grouped into categories by the name of the Operator that they use. Some operators such as 'RegxMatch' and 'RegxReplace' use a regular expression pattern as an argument. Regular expression patterns describe the text to be matched or replaced, and may contain a variety of special characters. If the special characters are used incorrectly then the pattern is considered invalid. This validation will return an error if a pattern argument to a 'RegxMatch' or 'RegxReplace' operation is not a valid pattern

Following Schemas require maintenance.

Customized Schemas are built from Source Schemas, which may be shared between several repositories. Under some circumstances, a Source Schema might be modified, e.g. adding an extra node. When a Source Schema is modified, the associated Customized Schemas have to be adjusted to reflect those changes. In many cases, this can be done automatically via 'Auto Maintenance'. In other cases, 'Schema Maintenance' must be performed manually. This validation returns an error if any of the Customized Schemas used in the repository require maintenance. Please note that while any of your Customized Schemas require maintenance, you will be unable to generate or release source code that uses that Customized Schema

Following Formula Versions/UDOs have Skip Operations that are not living within a collection.

 

Formula Versions and UDOs are composed of operations. Operations can be grouped into categories by the name of the Operator that they use. Some operators, such as 'CountTrueNodes', iterate over a collection of nodes. The 'Skip' operator is an unusual operator, because it is only meaningful inside operations that iterate over a collection of nodes. This validation will return an error if a 'Skip' operation is present but is not part of an operation that iterates over a collection of nodes.

Following Table Contents contain data that does not fit the column data type.

 

Tables define a number of columns in a Table, along with their associated data types. Table Contents belong to a Table, and can have any number of Table Rows. The data contained in Table Contents must fit the constraints defined by the columns in the Table, for example 'claimValue' would not be a valid 'int'. This validation will return an error if a set of Table Contents contains data which does not fit the constraints specified in the Table.

Following TableContents have duplicate keys

Tables define a number of columns in a Table, along with their associated column types and data types. Table Contents belong to a Table, and can have any number of Table Rows. Each Table Row must have a unique combination of 'key' fields. This validation will return an error if a set of Table Contents contains two or more rows with an identical set of 'key' fields.

 

The following Formula Versions/UDOs are using Tables that have had their definition changed.

 

Tables define a number of columns, along with their associated names and data types. Table Contents belong to a Table, and can have any number of Table Rows. The data contained in Table Contents can be referred to by operations inside either formulas or UDOs; for example, a formula might use a 'TableLookup' operation to find the value of a certain field on a Table Row. Once operations such as 'TableLookup' are used inside formulas or UDOs, the Table must not be changed or these operations cannot be executed correctly. This validation will return an error if an operation (inside a formula or UDO) refers to a Table that has had its definition changed since the operation was written.

Following Formula Versions/UDOs are pointing to UDOs that no longer exist.

 

Formula Versions and UDOs are composed of Operations. Operations such as 'ExecuteUDO' execute a target UDO and return the result. The 'ExecuteUDO' operation cannot function correctly if the UDO that it targets no longer exists. This validation returns an error if an 'ExecuteUDO' operation targets a UDO that no longer exists.

Following UDOs contain node Operations that point to nodes of wrong data type from the UDO's execution context.

 

UDOs can contain 'Node' operations that refer to nodes on a Customized Schema. Each Node operation refers to a node location and has an associated data type. This data type must be compatible with the data type of the node as defined on the Customized Schema. If the UDO is set to 'Use Caller Context' then any Node operations will refer to nodes determined by the context (or contexts) that the UDO is executed from. In such UDOs, 'Node' operations are therefore associated with both their definition locations and their execution contexts. An error may occur if a UDO contains a 'Node' operation associated with both a definition location and an execution context and there is a mismatch between the data types of these nodes. As an example, a UDO may be defined on node 'Application' and refer to child node 'ErrorCode', of type 'int'. Suppose that this UDO is set to 'Use Caller Context' and is executed from node 'Referral', and will therefore refer to execution context 'Referral/ErrorCode' which is of type 'string'. When the UDO is executed, it finds a node it was expecting named './ErrorCode' but an unexpected data type. This validation will return an error when a UDO contains a Node operation with a data type that is not compatible with the data type of the execution context.

Following UDOs refer to one or more nodes that do not exist relative to the UDO's execution context.

 

UDOs can contain 'Node' operations that refer to nodes on a Customized Schema. If the UDO is set to 'Use Caller Context' then any Node operations will refer to nodes determined by the context (or contexts) that the UDO is executed from. In such UDOs, 'Node' operations are therefore associated with both their definition locations and their execution contexts. An error may occur if a UDO contains a 'Node' operation associated with both a definition location and an execution context but the execution context does not exist. As an example, a UDO may be defined on node 'Application' and refer to child node 'ErrorCode', of type 'int'. Suppose that this UDO is set to 'Use Caller Context' and is executed from node 'Policy', and will therefore refer to execution context 'Policy/ErrorCode' which does not exist. This validation will return an error when a UDO contains a Node operation that refers to a node that does not exist. Commonly this occurs because the node exists where the UDO is defined, but does not exist where the UDO is executed from.

Following UDOs refer to nodes that are not reachable from one or more executed UDO contexts.

 

UDOs can contain 'Node' operations that refer to nodes on a Customized Schema. If the UDO is set to 'Use Caller Context' then any Node operations will refer to nodes determined by the context (or contexts) that the UDO is executed from. In such UDOs, 'Node' operations are therefore associated with both their definition locations and their execution contexts. UDOs can contain operations that target nodes on a Customized Schema, e.g. a 'Node' operation. If a UDO has a 'Node' operation or 'IsValidNode' operation, the target node must be reachable from the current execution context of the Node operation. As an example, a UDO may be defined on node 'Policy/Application' and refer to node '../Details/ErrorCode'. Suppose that this UDO is set to 'Use Caller Context' and is executed from node 'Policy/Manager/Inquiry', and will therefore refer to execution context 'Policy/Manager/Details/ErrorCode' and suppose that 'Details' is in this case a repeating node. In this example, the target Node will not be reachable from the current execution context. This validation will return an error when a UDO contains a Node operation that refers to a node that is not reachable from the execution context of the UDO.

Following UDOs contain node Operations that point to nodes of wrong data type from the UDO's location.

 

UDOs can contain 'Node' operations that refer to nodes on a Customized Schema. Each Node operation refers to a node and has an associated data type. This data type must be compatible with the data type of the node as defined on the Customized Schema. An error may also occur if a Node operation is created and then subsequently the data type defined by the Customized Schema changes. In this case the data type of the Operation may no longer be identical to the data type described on the Customized Schema. To resolve this problem, the Node operation should be replaced with a new Node operation that has the correct data type, or the Customized Schema must be adjusted to agree with the data type specified on the Operation. This validation will return an error when a UDO contains a Node operation with a data type that is not compatible with the data type of the Node location.

Following UDOs refer to one or more nodes that do not exist relative to the UDO's location.

 

UDOs can contain 'Node' operations that refer to nodes on a Customized Schema. An error may occur if a UDO contains a 'Node' operation associated with a definition location that does not exist. As an example, a UDO may be defined on node 'Application/ErrorCode' and refer to a node 'Application/ErrorCode/Name', which does not exist. This validation will return an error when a UDO contains a Node operation that refers to a location node that does not exist.

Following UDOs refer to nodes that are not reachable from the UDO's location.

 

Each UDO is defined on a location Node belonging to a Customized Schema. UDOs can contain operations that target nodes on a Customized Schema, e.g. a 'Node' operation. If a UDO has a 'Node' operation or 'IsValidNode' operation, the target node must be reachable from the UDOs location. As an example, a UDO may be defined on node 'Policy/Application' and refer to node '../CoverType/ErrorCode'. Suppose that 'CoverType' is a repeating node - then the node 'Policy/CoverType/ErrorCode' would not be reachable from the UDOs location. This validation will return an error when a UDO contains a Node operation that refers to a node that is not reachable from the location of the UDO.

Following UDOs have invalid paths. Please contact Idiom support.

 

UDOs must be located on nodes in a Customized Schema. In versions of IDIOM Decision Manager prior to version 3.1, UDOs could be inadvertently detached from their locations, causing the Repository to become corrupt. Corrupted Repositories must be manually fixed by Idiom support. This validation returns an error if a UDO is located on a node that does not exist.

Following UDOs refer to parameters that do not exist.

 

UDOs accept a number of parameters and return a result. Within a UDO, parameters are referred to through one or more 'UseParameter' operations. In each UDO, 'UseParameter' operations must only refer to parameters belonging to that specific UDO. Accordingly, parameters from one UDO may not be used in another UDO. Additionally, if a 'UseParameter' operation refers to a parameter that is subsequently removed, then that 'UseParameter' operation becomes invalid. This validation returns an error if a UDO contains 'UseParameter' operations referring to parameters that either do not belong to that UDO or that do not exist.

Following Formula Versions/UDOs are executing UDOs using invalid Parameters.

 

UDOs accept a number of parameters and return a result. UDOs can be executed by 'ExecuteUDO' operations, which must provide the correct parameters for that UDO. If an 'ExecuteUDO' operation specifies parameters that do not exist in the UDO, or fails to specify parameters that do exist in the UDO, there is no way to run the 'ExecuteUDO' operation. This validation returns an error if an 'ExecuteUDO' operation specifies parameters that do not match those defined in the target UDO.

The data type of a UDO Parameter cannot be control.

 

UDOs accept a number of parameters and return a result. These parameters have names and associated data types; for example, a name such as 'Surname' and a data type such as 'string'. 'Control' data type parameters cannot provide any meaningful information to a UDO and have been disallowed. This validation returns an error if a UDO has a parameter with data type set to 'Control'.

Following Formula Versions/UDOs are pointing to UDOs that are unreachable.

 

UDOs are executed through an 'ExecuteFormula' operation either by a Formula Version or by another UDO. Regardless of which method is used, the UDO that is to be executed must be reachable from the item that causes the execution. If UDOs are set to 'Use Caller Context' mode then the UDO assumes the context it was called from and is always reachable. If the UDO is not set to 'Use Caller Context' mode, then it acquires the context where the UDO is defined. In this case, the UDO should not be unreachable from the execution context. For example, if a Formula Version 'Calculate Price' is located on a node that has a repeating child node, it could not use an 'ExecuteUDO' operation pointing to a UDO that lived under that repeating child node. This validation will return an error if a UDO is executed when the context of the UDO is not reachable from the caller location.

Following UDOs are incomplete.

 

UDOs are executed through an 'ExecuteFormula' operation either by a Formula Version or by another UDO. When a UDO is incomplete, it cannot to be executed properly. This validation returns an error when an incomplete UDO is referenced.

Following Formula Versions/UDOs contain node related Operations that are no longer valid.

 

Formulas and UDOs belong to a Customized Schema and can be executed to return a result. The 'caller context' of the formula or UDO is determined by where it is being executed from. The 'execution context' is the location that a formula or UDO is executed with. Note that the caller context may not be identical to the execution context. As a formula or UDO may be executed from a number of different locations, there may be any amount of caller contexts associated with each formula or UDO. These caller contexts describe locations in Customized Schemas. If a caller context in one CustomizedSchema refers to a formula or UDO in a different CustomizedSchema, then that formula or UDO must provide its full and absolute location to the calling operation. If it does not, then there is no way to execute the targeted formula or UDO. This validation returns an error if a formula or UDO belonging to a Customized Schema is being executed from a location on another Customized Schema and it does not provide its absolute location to the calling operation.

Table 7-2: Validation Messages - Critical Error Messages