Skip Headers
JD Edwards EnterpriseOne Tools Interoperability Guide
Release 8.98 Update 4

Part Number E14711-02
Go to Documentation Home
Home
Go to Book List
Book List
Go to Table of Contents
Contents
Go to Index
Index
Go to Master Index
Master Index
Go to Feedback page
Contact Us

Go to previous page
Previous
Go to next page
Next
PDF · Mobi · ePub

7 Understanding XML Transformation Service

This chapter contains the following topics:

7.1 XML Transformation Service

The JD Edwards EnterpriseOne XML transformation system (XTS) uses extensible stylesheet language (XSL) to transform XML documents to the format that is required by JD Edwards EnterpriseOne. XTS also transforms JD Edwards EnterpriseOne response XML documents back to the XML format of the original request.

XTS is a multi-threaded Java process that runs as a JD Edwards EnterpriseOne kernel process. Upon system startup, the XTS kernel library loads a Java virtual machine (JVM). Once the JVM is loaded, the server proxy is started. Java Runtime Environment (JRE) v. 1.4 is included with the JD Edwards EnterpriseOne software.

XTS is available on all platforms that JD Edwards EnterpriseOne supports.

7.2 XTS Process

When the JD Edwards EnterpriseOne XML Dispatch kernel receives an XML document that it does not recognize, it sends the document to XTS for transformation. XTS reads the XSL, transforms the document to a format that is compatible with JD Edwards EnterpriseOne, and sends the document back to the XML Dispatch kernel for processing. When the JD Edwards EnterpriseOne response comes into XML Dispatch, XML Dispatch remembers that the document needs to be transformed from the JD Edwards EnterpriseOne XML format and sends the document to XTS for transformation. XTS transforms the JD Edwards EnterpriseOne XML document back to your original XML format and sends the document to XML Dispatch for distribution to you.

Native XML format is the XML format that is defined by JD Edwards EnterpriseOne and is documented in this guide. All XML documents coming into JD Edwards EnterpriseOne must be in native XML format. The JD Edwards EnterpriseOne kernel processes (such as, XML CallObject, XML trans, XML list, and so on) can only process XML documents that are in native format. As part of the XTS solution, JD Edwards EnterpriseOne provides a selector that determines whether a non-JD Edwards EnterpriseOne XML document can be transformed. A selector is code that looks at an XML document to see if it recognizes the document. If the selector recognizes the XML document, the selector is able to associate the XML document with a stylesheet that is provided for transformation. The selector is able to transform Version 1 XML format into JD Edwards EnterpriseOne native XML format. Version 1 XML format is XML format that is defined by JD Edwards EnterpriseOne but has been modified to be tool friendly. Native XML format uses a field name that is preceded by parameter name. Version 1 XML format uses just the field name.

7.2.1 Example: JD Edwards EnterpriseOne Native XML Format

This sample code shows JD Edwards EnterpriseOne native XML format:

<xml version='1.0'?>
<jdeRequest pwd='mike' type='callmethod' user='mike' environment='DV810'>
<callMethod app='test' name='GetPhone'>
<params>
<param name='mnAddressnumber'>4242a</param>
<param name= 'mnLinenumberid'></param>
<param name= 'cIncludeexcludecode2'></param>
<param name= 'szPhonenumber'>/param>
<param name= 'szPhoneareacode1'></param>
<param name= 'mnOKtoDelete'></param>
<param name= 'szPhonenumberType'></param>
</params>
</callMethod>
</jdeRequest>

7.2.2 Example: JD Edwards EnterpriseOne Version 1 XML Format

This sample code shows Version 1 XML format:

<?xml version=1.0 ?>
<intBPAPI>
<dsControl>
 <dsLogin>
  <User>JDESVR</User>
  <Password>JDESVR</Password>
  <Environment>ADEVNIS2</Environment>
  <Session />
 </dsLogin>
 <dsAPI>
  <Noun>jdeSalesOrder</Noun>
  <Verb>Create</Verb>
  <Version>1.1</Version>
 </dsAPI>
 <dsTranslation>
  <InMap />
  <OutMap />
 </dsTranslation>
</dsControl>
<dsData>
 <callMethod_GetLocalComputerId app="NetComm" runOnError="no">
  <szMachineKey id="" />
  <onError_GetLocalComputerId abort="yes" />
 </callMethod_GetLocalComputerId>
<callMethod_F4211FSBeginDoc app="NetComm" runOnError="no">
 <mnCMJobNumber id="" />
 <cCMDocAction>A</cCMDocAction>
 <cCMProcessEdits>1</cCMProcessEdits>
 <szCMComputerID idref="2" />
 <cCMUpdateWriteToWF>2</cCMUpdateWriteToWF>
 <szCMProgramID>NetComm</szCMProgramID>
 <szCMVersion>NetComm</szCMVersion>
 <szOrderType>SQ</szOrderType>
 <szBusinessUnit>M30</szBusinessUnit>
 <mnAddressNumber>4242</mnAddressNumber>
 <szReference>2</szReference>
 <cApplyFreightYN>Y</cApplyFreightYN>
 <szCurrencyCode>CAD</szCurrencyCode>
 <cWKSourceOfData />
 <cWKProcMode>1</cWKProcMode>
 <mnWKSuppressProcess>0</mnWKSuppressProcess>
 <onError_F4211FSBeginDoc abort="yes">
  <callMethod_F4211ClearWorkFile app="NetComm" runOnError="yes">
   <mnJobNo idref="1" />
   <szComputerID idref="2" />
   <mnFromLineNo>0</mnFromLineNo>
   <mnThruLineNo>0</mnThruLineNo>
   <cClearHeaderWF>2</cClearHeaderWF>
   <cClearDetailWF>2</cClearDetailWF>
   <szProgramID>NetComm</szProgramID>
   <szCMVersion>ZJDE0001</szCMVersion>
  </callMethod_F4211ClearWorkFile>
 </onError_F4211FSBeginDoc>
</callMethod_F4211FSBeginDoc>
 <callMethod_F4211FSEditLine app="NetComm" runOnError="yes">
  <mnCMJobNo idref="1" />
  <cCMLineAction>A</cCMLineAction>
  <cCMProcessEdits>1</cCMProcessEdits>
  <cCMWriteToWFFlag>2</cCMWriteToWFFlag>
  <szCMComputerID idref="2" />
  <mnLineNo>1</mnLineNo>
  <szItemNo>1001</szItemNo>
  <mnQtyOrdered>5</mnQtyOrdered>
  <cSalesTaxableYN>N</cSalesTaxableYN>
  <szTransactionUOM>EA</szTransactionUOM>
  <szCMProgramID>1</szCMProgramID>
  <szCMVersion>ZJDE0001</szCMVersion>
  <cWKSourceOfData />
  <onError_F4211FSEditLine abort="no" />
 </callMethod_F4211FSEditLine>
 <callMethod_F4211FSEndDoc app="NetComm" runOnError="no">
  <mnCMJobNo idref="1" />
  <szCMComputerID idref="2" />
  <szCMProgramID>NetComm</szCMProgramID>
  <szCMVersion>ZJDE0001</szCMVersion>
  <cCMUseWorkFiles>2</cCMUseWorkFiles>
  <mnSalesOrderNo id="" />
  <szKeyCompany id="" />
  <mnOrderTotal id="" />
  <onError_F4211FSEndDoc abort="no">
   <callMethod_F4211ClearWorkFile app="NetComm" runOnError="yes">
    <mnJobNo idref="1" />
    <szComputerID idref="2" />
    <mnFromLineNo>0</mnFromLineNo>
    <mnThruLineNo>0</mnThruLineNo>
    <cClearHeaderWF>2</cClearHeaderWF>
    <cClearDetailWF>2</cClearDetailWF>
    <szProgramID>NetComm</szProgramID>
    <szCMVersion>ZJDE0001</szCMVersion>
   </callMethod_F4211ClearWorkFile>
  </onError_F4211FSEndDoc>
 </callMethod_F4211FSEndDoc>
 <returnParams failureDestination="error" successDestination="success" 
runOnError="yes">
  <mnOrderNo idref="3" />
  <szOrderCo idref="4" />
  <mnWKOrderTotal idref="5" />
 </returnParams>
 <onError abort="yes">
  <callMethod_F4211ClearWorkFile app="NetComm" runOnError="yes">
   <mnJobNo idref="1" />
   <szComputerID idref="2" />
   <mnFromLineNo>0</mnFromLineNo>
   <mnThruLineNo>0</mnThruLineNo>
   <cClearHeaderWF>2</cClearHeaderWF>
   <cClearDetailWF>2</cClearDetailWF>
   <szProgramID>NetComm</szProgramID>
   <szCMVersion>ZJDE0001</szCMVersion>
  </callMethod_F4211ClearWorkFile>
 </onError>
</dsData>
</intBPAPI>

7.3 Custom Selectors

You can build a selector to transform your XML format into JD Edwards EnterpriseOne native XML format. If you write a custom selector, include both request and response extensible stylesheet language transformation (XSLT) documents.

Inside the Java file, the system uses two APIs to select templates. Use the boolean fetchTemplates API to fetch the appropriate XSLT document for the request document. Public boolean fetchTemplates throws IXTSMTemplateSelector.TemplateFetchException, XTSXMLParseException. This sample shows how to use this API:

fetchTemplates(XTSDocument  inXML,  IXTSMSelectionInfo  info)

Use the Public void fetchTemplates to fetch the appropriate XSLT document for the response document. Public void fetchTemplates throws IXTSMTemplateSelector.TemplateFetchException.

fetchTemplates(IXTSMSelectionInfo  info)

Note:

Ensure that your custom selector is accessible in the ClassPath.

7.3.1 XTS APIs

When you write a custom selector, you can use these APIs to interface with JD Edwards EnterpriseOne:

  • IXTSMTemplateSelector

  • IXTSMTemplateSelector.TemplateFetchException

7.3.2 Example: Creating a Selector

This code was written by JD Edwards EnterpriseOne to build the Version 1 XML selector. This sample code uses the XTS.jar file. You can use this code as a sample for creating your selector:

File: XTSMJDETemplateSelector.java
//
////////////////////////////////////////////////////////////////////////////////
package com.jdedwards.xts.xtsm;
import com.jdedwards.xts.xtsr.IXTSRepository;
import com.jdedwards.xts.xtsr.IXTSRKey;
import com.jdedwards.xts.xtsr.XTSRException;
import com.jdedwards.xts.xtsr.XTSRInvalidKeyStringException;
import com.jdedwards.xts.xtsr.XTSRInvalidKeyFieldException;
import com.jdedwards.xts.xtsr.XTSRKeyNotFoundException;
import com.jdedwards.xts.XTSDocument;
import com.jdedwards.xts.XTSFactory;
import com.jdedwards.xts.XTSLog;
import com.jdedwards.xts.XTSConfigurationException;
import com.jdedwards.xts.XTSXMLParseException;
import com.jdedwards.xts.xtsm.IXTSMTemplateSelector;
import com.jdedwards.xts.xtse.IXTSEngine;
import com.jdedwards.xts.xtse.IXTSECompiledProcessor;
import java.util.List;
import org.w3c.dom.*;

/**
* This class is the  Template Selector. It recognizes
* JD Edwards EnterpriseOne standard XML documents and returns the
* appropriate XSL stylesheets necessary for transformation.
*/
public class XTSMJDETemplateSelector implements IXTSMTemplateSelector
{
 /** Class constructor. */
 public XTSMJDETemplateSelector()
 {
  XTSLog.trace(XTSMJDETemplateSelector()'', 3);
  // get repository reference
  XTSFactory factory = XTSFactory.getInstance();
  m_repository = factory.createXTSRepository();
 }

 /**
 * Fetch the appropriate XSLT documents and IXTSECompiledProcessors as
 * indicated by the TPT stored in the <code>info</code> parameter.
 * @param info - Selection Info that contains TPI and should be modified
 * by the selector to specify transformation information.
 * @exception IXTSMTemplateSelector.TemplateFetchException - thrown
 * if an error occurs when extracting information from the
 * inclement.
 */
 public void fetchTemplates(IXTSMSelectionInfo info)
    throws IXTSMTemplateSelector.TemplateFetchException
 {
  XTSLog.trace("XTSMJDETemplateSelector.fetchTemplates(XTSMSelectionResult)", 
3);
  NodeList nodes = info.getTPIElement().getElementsByTagName(JDE_TS_XTSR_KEY);
  int numNodes = nodes.getLength();
  for(int i = 0; i < numNodes; i++)
  {
    // extract key info & create a key
    IXTSRKey key = createKeyFromNode((Element)nodes.item(i));

    // fetch the doc and add it to the list
    try
    {
     info.getXSLList().add(m_repository.fetch(key));
    }
    catch (XTSRKeyNotFoundException e)
    {
     throw new IXTSMTemplateSelector.TemplateFetchException(
        "Selected XTSRKey not found in repository: "
        + JDE_TS_XTSR_KEY);
    }
    catch (XTSRException e)
    {
     throw new IXTSMTemplateSelector.TemplateFetchException(
        "Unable to fetch the XSL document specified within '"
        + JDE_TS_XTSR_KEY +
        "' from the XTSRepository");
    }
  }
 }

 /**
 * Fetch the appropriate XSLT documents and compiled processors for
 * the given document.
 * @param inXML - the XTSDocument to try to recognize.
 * @param info - Selection Info object to be modified by selector to
 * indicate transformation information.
 * @return - <code>true</code> if the selector has recognized the
 * document and specified the appropriate selection info using
 * <code>info</code>, <code>false</code> otherwise.
 * @exception TemplateFetchException - thrown when an error occurs
 * when trying to recognize the DOM.
 * @exception XTSXMLParseException - thrown if <inXML> could not be
 * parsed.
 */
 public boolean fetchTemplates(XTSDocument inXML,
                IXTSMSelectionInfo info)
  throws IXTSMTemplateSelector.TemplateFetchException,
      XTSXMLParseException
 {
  XTSLog.trace("XTSMJDETemplateSelector.fetchTemplates(Document, Element)", 3);
  boolean recognized = false;
  Document inDOM = inXML.getDOM();
  // see if an XTSR key is specified within the document:
  NodeList nodeList = inDOM.getElementsByTagName(JDE_XTSR_KEY);
  if (nodeList.getLength() > 0)
  {
    try
    {

     // extract key info & create a key
     IXTSRKey key = createKeyFromNode((Element)nodeList.item(0));

     // add transformation path information to outElement
     createNodeChildFromKey(info.getTPIElement(), key);

     // fetch the doc and add it to the list
     info.getXSLList().add(m_repository.fetch(key));

     info.setResultXML(true);
     info.setPathInfoStored(false);
     recognized = true;
    }
    catch (XTSRException e)
    {
     throw new IXTSMTemplateSelector.TemplateFetchException(
          "Unable to fetch the XSL document specified within '"
          + JDE_XTSR_KEY +
          "' from the XTSRepository");
    }
    catch (XTSRKeyNotFoundException e)
    {
     throw new IXTSMTemplateSelector.TemplateFetchException(
          "Key specified in TPI not found in repository"
          + JDE_XTSR_KEY);
    }
  }
  else // no XTSR key, so look for JDE information:
  {
    nodeList = inDOM.getElementsByTagName(JDE_INT_BPAPI);
    if (nodeList.getLength() != 0)
    {
     // add transformation path information to outElement
     createNodeChildFromKey(info.getTPIElement(), getVersion1toNativeKey());

     // fetch the doc and add it to the list
     info.getXSLList().add(getVersion1toNativeXSL());

     info.setResultXML(true);
     info.setPathInfoStored(true);
     recognized = true;
    }
  }
  return recognized;
 }
 /**
 * Extracts XTSRKey information from the given node, and creates an
 * instance of IXTSRKey based on that information.
 * @return - the new IXTSRKey.
 * @param element - Element that contains the key information.
 * @exception XTSMUnrecognizedElementException - thrown if the
 * Element format is unrecognized.
 */
 protected IXTSRKey createKeyFromNode(Element element)
      throws XTSMUnrecognizedElementException
 {
  XTSLog.trace("XTSMJDETemplateSelector.createKeyFromNode(Element)", 4);
  IXTSRKey key = null;
  boolean request = false;
  boolean response = false;
  if (element.getNodeName().equals(JDE_XTSR_KEY))
  {
    request = true;
  }
  else if (element.getNodeName().equals(JDE_TS_XTSR_KEY))
  {
    response = true;
  }
  if (request || response)
  {
    key = m_repository.createKey();
    try
    {
     String keyString = element.getAttribute(JDE_XTSR_KEY_ATTRIBUTE);
     key.setFieldsFromString(keyString);
     if (key.getFieldValue(SUBTYPE_FIELD).length() == 0)
     {
       if (request)
       {
        key.setFieldValue(SUBTYPE_FIELD, SUBTYPE_REQUEST);
       }
       else
       {
        key.setFieldValue(SUBTYPE_FIELD, SUBTYPE_RESPONSE);
       }
     }
    }
    catch (XTSRInvalidKeyStringException e)
    {
     throw new XTSMUnrecognizedElementException(
          "Specified '" + JDE_XTSR_KEY +
          "' element format is invalid for this XTSRepository");
    }
    catch (XTSRInvalidKeyFieldException e)
    {
     throw new XTSConfigurationException(
          "Specified '" + SUBTYPE_FIELD +
          "' field name not supported by repository key");
    }
  }
  return key;
 }
 /**
 * Creates a node that contains the key fields values and appends it
 * to the given parentNode.
 * @param parentNode - Node to which the key information should be
 * appended.
 * @param key - Key information to store in the node.*/

 protected void createNodeChildFromKey(Node parentNode, IXTSRKey key)
 {
  XTSLog.trace("XTSMJDETemplateSelector.createKeyFromNode(Node,IXTSRKey)", 4);
  try
  {
    IXTSRKey keyClone = key.getRepository().createKey();
    keyClone.setFieldsFromString(key.getFieldsString());

    // Do not store the sub type, clear it here:
    keyClone.setFieldValue(SUBTYPE_FIELD, "");

    // create new node and append it to the provided element:
    Element element = (Element)parentNode.getOwnerDocument().createElement
(JDE_TS_XTSR_KEY);
    element.setAttribute(JDE_XTSR_KEY_ATTRIBUTE, keyClone.getFieldsString());
    parentNode.appendChild(element);
  }
  catch (XTSRInvalidKeyStringException e)
  {
    XTSLog.log("Unexpected ");
    XTSLog.log(e);
    throw new RuntimeException("Unexpected Exception: " + e.toString());
  }
 }

 /**
 * Returns the key of the stylesheet to use in converting
 * JD Edwards EnterpriseOne version 1 documents into EnterpriseOne native
 * documents.
 * @return - The key for the XSL stylesheet.
 */
 protected IXTSRKey getVersion1toNativeKey()
 {
  XTSLog.trace("XTSMJDETemplateSelector.getVersion1toNativeKey()", 5);
  if (null == m_version1ToNativeKey)
  {
    try
    {
     // create standard xsl XTSRKey:
     m_version1ToNativeKey = m_repository.createKey();
     m_version1ToNativeKey.setFieldsFromString(V1_TO_NATIVE_KEY);
    }
    catch (XTSRInvalidKeyStringException e)
    {
     String error = "XTSRKey necessary for JDE template selection is invalid: "
           + V1_TO_NATIVE_KEY;
     XTSLog.log(error);
     XTSLog.log(e);
     throw new XTSConfigurationException(error);
    }
  }
  return m_version1ToNativeKey;
 }

 /**
 * Returns the XTSDocument which contains the XSL stylesheet for
 * converting JD Edwards EnterpriseOne version 1 documents into JD Edwards
 * EnterpriseOne native documents.
 * @return - XTSDocument containing the XSL stylesheet.
 */
 protected IXTSECompiledProcessor getVersion1toNativeXSL()
 {
  XTSLog.trace("XTSMJDETemplateSelector.getVersion1toNativeXSL()", 5);
  if (null == m_version1ToNativeXSL)
  {
    XTSDocument xsl = null;
    Try
    {
     xsl = m_repository.fetch(getVersion1toNativeKey());
     IXTSEngine engine = XTSFactory.getInstance().createXTSEngine();
     m_version1ToNativeXSL = engine.createCompiledProcessor(xsl);
    }
    catch (XTSRException e)
    {
     String error = "Unable to fetch selected template from the repository:";
     XTSLog.log(error);
     XTSLog.log(e);
     throw new XTSConfigurationException(error + e.toString());
    }
    catch (XTSRKeyNotFoundException knfe)
    {
     String error = "Selected template XTSRKey not found in repository:";
     XTSLog.log(error);
     XTSLog.log(knfe);
     throw new XTSConfigurationException(error + knfe.toString());
    }
    catch (XTSXMLParseException pe)
    {
     String error = "Invalid XSL document in repository";
     XTSLog.log(error);
     XTSLog.log(pe);
     throw new XTSConfigurationException(error + pe.toString());
    }
  }
  return m_version1ToNativeXSL;
 }

 /** Reference to the XTSRepository */
 private IXTSRepository m_repository = null;

 /** Key for converting version 1 documents to native documents. */
 private IXTSRKey m_version1ToNativeKey = null;

 /** Compiled XSL Stylesheet for converting version 1 docs to
  *  native docs. */
 private IXTSECompiledProcessor m_version1ToNativeXSL = null;

 /** Field Value for the XTSRKey that indicates the document is an XSL doc */
 private static final String DOC_TYPE_XSL = "XSL";

 /** Element name that indicates the DOM is a Version 1 document */
 private static final String JDE_INT_BPAPI = "intBPAPI";

 /** Element name that indicates the DOM is a request and not a
  *  response or error. */
 private static final String JDE_REQUEST = "jdeRequest";

 /** Element name that indicates the DOM is a response */
 private static final String RESPONSE = "jdeResponse";

 /** Element name that specifies an XTSRKey to use in transforming
  *  the document. */
 private static final String JDE_XTSR_KEY = "jdeXTSRKey";

 /** The attribute of the <code>JDE_XTSR_KEY</code> element that
  *  stores the XTSRKey string value */
 private static final String JDE_XTSR_KEY_ATTRIBUTE = "key";

 /** XTSRKey field name that specifies the sub-type of the XML
  * document. Normal values for the sub-type are defined by
  * <code>SUBTYPE_REQUEST</code> and <code>SUBTYPE_RESPONSE</code> */
 private static final String SUBTYPE_FIELD = "SUB_TYPE";

 /** XTSRKey field name which specifies the type of the XML document.
  *  The normal value is defined by <code>DOC_TYPE_XSL</code> */
 private static final String FIELD_TYPE = "TYPE";

 /** XTSRKey field name which specifies the format (or owner) of the
  *  XML document. The normal value recognized by this selector is
 * 'JDE' */
 private static final String FIELD_FORMAT = "FORMAT";

 /** XTSRKey field name that specifies the particular transformation
  *  that the XSL document will perform. This selector uses
  *  'V1_NATIVE' for transformations between JD Edwards EnterpriseOne Version 1
  *  XML documents and JD Edwards EnterpriseOne native version documents. */
 private static final String FIELD_ID = "ID";

 /** The string representation of the XTSRKey for the XSL document to
  *  format JD Edwards EnterpriseOne version 1 request documents into
  *  JD Edwards EnterpriseOne native request documents. */
 private static final String V1_TO_NATIVE_KEY = "XSL-JDE-V1_NATIVE-REQUEST";

 /** XTSRKey field <code>SUBTYPE_FIELD</code> value that indicates
  *  the XSL document will transform jdeRequest documents. */
 private static final String SUBTYPE_REQUEST = "REQUEST";

 /** XTSRKey field <code>SUBTYPE_FIELD</code> value that indicates
  *  the XSL document will transform jdeResponse documents. */
 private static final String SUBTYPE_RESPONSE = "RESPONSE";

 /** Element name stored within the Transformation Path Information
  * (TPI)that specifies the XTSRKey used to transform the document. */
 private static final String JDE_TS_XTSR_KEY = "XTSJDETemplateKey";

 private static class XTSMUnrecognizedElementException
     extends IXTSMTemplateSelector.TemplateFetchException
 {
  public XTSMUnrecognizedElementException(String text)
  {
    super(text);
  }
 }
}

7.4 XTS jde.ini File Configuration

The XTS Kernel must be defined in the server jde.ini file. The name of the configuration file is retrieved from the config_file system variable in the JVM. These property settings are part of a configuration file other than jde.ini. The jde.ini file does not require any special configurations other than to define the XTS Kernel.

7.4.1 [JDENET_KERNEL_DEF23]

These setting are for a Microsoft Windows platform:

krnlName=JDEXTS KERNEL
dispatchDLLName=xtskrnl.dll
dispatchDLLFunction=_JDEK_DispatchXTSMessage@28
maxNumberOfProcesses=1
numberOfAutoStartProcesses=0

This table provides the different .dll extensions for other platforms:

Table Column Heading Dispatch DLL Name Dispatch DLL Function
IBM i XTSKRNL JDEK_DispatchXTS
HP9000B libxtskrnl.sl JDEK_DispatchXTS
SUN or RS6000 libxtskrnl.so JDEK_DispatchXTS

Other jde.ini File settings include:

  • [JDENET]

  • [XTSRepository]

  • [XTS]

7.4.2 [JDENET]

Configure this setting:

maxKernelRanges=24

Note:

For the XTS kernel to run, set the maxKernelRanges setting to 23 or higher.

7.4.3 [XTSRepository]

Configure these settings:

XSL-JDE-V1_NATIVE-REQUEST=ml.xsl
XSL-JDE-V1_NATIVE-RESPONSE=lm.xsl

Note:

The first setting is the JD Edwards EnterpriseOne default value that enables XSL to transform the request document from Version 1 to native. The second setting is the JD Edwards EnterpriseOne default value that enables XSL to transform the response document from native to version 1.

You can provide your XSL files either at this location or any other location as long as your selector can find and access your XSL. To add your XSL files to this location, use these naming conventions, where Filename is the name of your XSL documents:

XSL-JDE-Filename-REQUEST=

XSL-JDE-Filename-RESPONSE=

7.4.4 [XTS]

This is an example setting:

XTSTemplateSelector1=com.jdedwards.xts.xtsm.XTSMJDETemplateSelector
XTSTraceLevel=2

Note:

The XTSTemplateSelector1 setting is the JD Edwards EnterpriseOne default template selector for providing XSL to transform between Version 1 and native format.

You can add your custom template selector to this section. For example, your template selector setting could be defined as follows:

XTSTemplateSelector2=com.customer.CustomTemplateSelector

The XTSTraceLevel=2 setting defines the level of XTS logging.