Top
Top
LibraryEASYProcess Reference ManualProcessesServicesEvaluatorWorkshopEvaluateXml

EvaluateXML Overview

The service "EvaluateXML" is used to translate XML into data nodes as children of the WorkData node to be used in the process later.

Example: "<Container><Test1>123</Test1><Test2>abc</Test2></Container>" will create the nodes "WorkData/Container/test1" and "WorkData/Container/Test1" so they can be referenced by XSLT later in the process.

This is useful if you want to create an XML structure that cannot be created in a similar service, such as Evaluate. For example, WorkData/Variable could not be created with Evaluate. Instead, it would have to be WorkData/Evaluate/Variable. With the EvaluateXML the desired structure is possible.

We can also control the existence of node based on certain conditions. If you want to create an eval in an Evaluate service, once an eval is defined, it exists and it cannot be un-created depending on a blank value. With an EvaluateXml, the xml node could be wrapped in an XSLT “If”, “Choose”, or “For-Each”. With these XSLT functions, if the correct conditions are met, the XML node will exist.

EvaluateXml gives developers lots of control over the nodes created and works very well with XSLT functions. Many complex functions could be used at once to create a desired XML structure without the constraints of EASYProcess build XML.


EvaluateXml Use Examples
Odd XML Structures
Use with XSLT
Workshop:EvaluatorWorkshop
Service:EvaluateXml
Inputs
ConvertNodeValueToXml

XmlThe XML input which will be placed under the WorkData node.

EvaluateXml Use Examples

Basic Use Example

EvaluateXMl can be used to add XML nodes as children under the WorkData node in the process logs.

In this example below, some simple XML is typed into the XML input of the service. When the service is ran, the xml entered appears in the logs under the WorkData level.

Input

Output

Notice that we have two nodes Test1 and Test2 under Container in the output. Once the service is ran, the following variables exist in the logs and could be referenced by later services:

Variable Reference

Variable Value

WorkData/Container/Test1

123

WorkData/Container/Test2

abc

EvaluateXml Service “Info” Node

If you notice, our service, which was named “EvaluateXml” did not have a “EvaluateXml” named node like a RunQuery or Evaluate would. Instead the actual nodes (not info nodes) created were named according to the xml provided in the input. The “Info” node is still named after the service though. In order to keep these in sync, it is a good idea to name the service the same as the outermost xml node in the input to the service.

In our example, if we change the name of the service to “Container” to match the outermost node in the input XML, the “Info” node will be named “ContainerInfo” and match the syntax that is consistent with other services in EASYProcess.

Service Renamed on Canvas

Service “Info” node in Logs


Odd XML Structures

One of the benefits of an EvaluateXml service is the amount of control over the XML structure it gives the developer. Below are some examples of the EvaluateXml services used to for this reason.

API Output

In the API contract definition, it was required that the CartId of the current user be output in the format: WorkData/CartId. For this an Evaluate service could not be used since it would have to  output WorkData/Evaluate/CartId.

Here was the existing output for the process when an Evaluate services was used:

Here is the output after it was converted to an EvaluateXml service. Notice since it has the developer defined XML, it is not organized nicely in the service and is less readable. However, two nodes were defined beneath the WorkData node in this EvaluateXml: ResponseInfo and CartId.

 In the screenshot the Xml nodes which mark the beginning of and the end of the developer-entered xml are highlighted.


Use with XSLT

EvaluateXml is a great service to use with complex XSLT functions. Below are examples of the services used for this reason.

Using For-Each to Create Nodes

Sometimes an existing node set will need to be referenced and will be used to determine the output. For example, for each item passed in, to this pricing process, an item node must be returned in the output with the item’s price and other info. If an item cannot be found or priced, each item must return in the output with its own node and information about why it failed.

With this requirement, it is easy to see why a developer would want to say “for each item passed in, output an xml node”. This can be done to dynamically build the Xml of the output depending on the input using Evaluate Xml and the XSLT For-Each function.

Here is that EvaluateXml. The nodes dynamically created based on the input are circled. This is the output node when items fail. Each node (named either NotInUserCatalog or NotFound) returned corresponds to an item node passed (WorkData/Item) in which was given an attribute (NotInUserCatalog and NotFound) to be used to identify the failed items.

Using XSLT Copy-Of to Create Nodes

Using the XSLT Copy-Of function, it copies all the existing XML at the target node. The asterisk is then used to copy all children nodes.

In this example, we have a pricing process. The input to the process is given in WorkData/Item. Then each item is taken and given a “Valid” attribute with either “True” or “False”. This is used later in this output EvaluateXml. There is a for-each which will iterate through all the item nodes that are given as input. However, it will only iterate through the ones with their “Valid” attribute set to “True”. This way, it will only iterate through the items that have information to return (invalid items are not returned here).

After targeting the correct nodes to iterate through, two variables are defined (ItemNumber and Quantity). These are the two pieces of information needed to differentiate between items in the input.

There is an existing RunQuery named “GetItem” which finds all the item info of the items requested by the input of the process.

With the two variables, a copy-of xslt variable is used to target the correct result from the “GetItem” service (the one from the iteration of the input we are on) and copy all the XML returned by the “GetItem” service to the EvaluateXml. The EvalauteXml service is wrapping all this information in an “Item” node, so each item will output an Item node just the same way it was passed in.

Notice that because we are in a For-Each loop, the reference to the GetItem service must exit the for each loop path to reference the correct node. It does this by placing a “/” before the WorkData.

The asterisk selects all child nodes. So this will select all the child nodes of the GetItem service. This will be attributes of the item like ItemNumber, Quantity, and Price.

The EvaluateXml created an output node named “Item”. See below as the Item node now has all the attributes from the GetItem service.


Powered by EASYProcess (© 2019 K-Rise Systems, Inc).