In the XMLport designer – you set up a defined format. Just think of it, as a kind of schema (xsd). You can add Elements and Attributes and in the Properties you can setup the Encoding and the DefaultNamespace.

Now that the XMLport has been designed, it is time to use it.

An XMLport, can as already mentioned, not be executed by itself. You have to call it from another routine. Such as a codeunit, forms etc.

To export XMLs do the following:

First create an Out File - this are what you xml will be called:

      outFile.CREATE('c:\outxml.xml');

Next prepare for streaming the data to XML. In Designer example we used 
Sales Header. So the out stream is called SH_outStream:

      outFile.CREATEOUTSTREAM(SH_outStream);

Now that we have the out File and the out stream ready it is time to execute
the XMLport. This is done by calling the export:

      XMLPORT.EXPORT(50000, SH_outStream);

And then finally end by closing the file.

      outFile.CLOSE;

The exported XML file will look like this:

<?xml version="1.0" encoding="UTF-16" standalone="no"?>
<invoice>
    <sales_header>
        <document_no>2001</document_no>
        <sell-to_customer>10000</sell-to_customer>
        <sales_lines>
            <sales_line>
                <itemno quantity="4" price="0">ITEM-No-10</itemno>
                <description>This is a item description</description>
            </sales_line>
        </sales_lines>
    </sales_header>
</invoice>

Importing XML files is similar to the Export:

First open the file:

      inFile.OPEN('c:\inxml.xml');

Next create an in stream:

      inFile.CREATEINSTREAM(SH_inStream);

And then execute the XMLport to importing the xml:

      XMLPORT.IMPORT(50000, SH_inStream);

And then finally end by closing the file:

      inFile.CLOSE;

That’s all – now you can export and import xml files using an XMLport.

The error occurs when using setAttribute directly on the XML Dom Element. To prevent a crash, use a function to set the Attribute.

The function could look like this:

IF ISCLEAR(XMLDoc) THEN
…..CREATE(XMLDoc);

XMLAttribute := XMLDoc.createAttribute(AttributeName);
XMLAttribute.value(Value);
XMLElement.setAttributeNode(XMLAttribute);
CLEAR(XMLAttribute);

where the local variables are:

• XMLDoc is Microsoft XML, v4.0′.DOMDocument
• XMLAttribute is Microsoft XML, v4.0′.IXMLDOMAttribute

and the function parameters are:

• Value is Text 1024
• AttributeName is Text 1024
• XMLElement is var and a Automation “‘Microsoft XML, v4.0′.IXMLDOMElement”

Ex. a XML containing the following will not be able to be loaded because the DTD does not use a URI path.

<!DOCTYPE TXP SYSTEM “example.dtd”>

Uniform Ressource Identifier (URI) Ex. “http://mysite.com/ex.dtd”

A load can be done any way by ignoring parsing errors

XMLDoc.validateOnParse := FALSE;
XMLDoc.resolveExternals := FALSE;

Loading a XML document with a DTD / Schema is possible if the DTD / XSD file is placed in the same directory as the XML file.

Luckily load errors can be captured!

validateOnParse and resolveExternals must be enabled when loading the document (they are by default true)

XMLDoc.validateOnParse := TRUE;
XMLDoc.resolveExternals := TRUE;
XMLDoc.load(FileName);

Parse Errors can be saved in a variable (Microsoft XML IXMLDOMParseError)

XMLErr := XMLDoc.parseError;

XMLErr can return a error code and a reason description

Message('Error: %1 %2',XMLErr.errorCode,XMLErr.reason);

Error: -1072898028
Element content is invalid according to the DTD/Schema

XML ports are thought not my preferred object, because they are limited. They work in the same way as a dataport. Therefore in the following we will concentrate us on the use of the automation Microsoft XML.

Before we are able to load/read an XML document, we must define a variable, which will provide us with a container for the document.

Define the variable XMLDom as Microsoft XML – DomDocument

Because we are using automations, we have to create the instant at first:

CREATE(XMLDom);

Now we are ready to load a XML document into the container. There are 2 ways:

1. Loading from a text variable

XMLText := '<"1.0" encoding="ISO-8859-1"?>';
XMLText += 'SystemStatus';
XMLDom.loadXML(XMLText);

2. Loading from a file

XMLFile := 'c:\text.xml';
XMLDom.load(XMLFile);

As soon the XML Document has been loaded, we are ready to add tags and read tags.

There are 2 ways to read XMLs. You can parse the XML Document as Nodes or as Elements. Nodes are though often Elements with sub elements. Elements do not contain sub elements.

Tags a common referee to Nodes and Elements

1. Reading as Nodes:

XMLNodeList := XMLDoc.getElementsByTagName(Tag);
Node := XMLNodeList.item(0);
IF NOT ISCLEAR(Node) THEN
    ReturnValue := Node.text;

2. Reading as Elements:

Element := XMLDoc.selectSingleNode(TagName);
IF NOT ISCLEAR(Element) THEN BEGIN
    ReturnValue := Element.text;

If you instead of reading wants to build a XML Document you can also do this in 2 ways.

1. Create a XML from a text variable:

Building the XML

    XMLText := '<"1.0" encoding="ISO-8859-1"?>';
    XMLText += 'SystemStatus';
    XMLDom.loadXML(XMLText);

Saving the XML:

    XMLDom.save(xmlfile);

XML:
    <"1.0" encoding="ISO-8859-1"?>
    
        SystemStatus
    

2. Creating an Init XML and then adding elements /nodes:

Build initial XML:

    InitXML := '<"1.0" encoding="ISO-8859-1"?>'+
               '';

    XMLDom.load(InitXML);

Add Element:

    Root := XMLdoc.documentElement;
    NewTag := XMLDom.createElement('Type');
    NewTag.text := 'SystemStatus';
    Root.appendChild(NewTag);

XML:
    <"1.0" encoding="ISO-8859-1"?>
    
          SystemStatus
    

Document Type Definition (DTD) defines the legal elements of an XML Document.

<!DOCTYPE note SYSTEM “external.dtd”>
<root>

XML Schema is an XML-based alternativ to DTD.

<root
xmlns=http://mysite
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://mysite/schema.xsd”>

Schemas will in the near future replace DTDs.

DTD Example – External DTD file

<?xml version=”1.0″?>
<!ELEMENT root (child)>
<!ELEMENT child (#PCDATA)>

DTD Example – Using DTD in a XML

<?xml version=”1.0″ encoding=”utf-8″ ?>
<!DOCTYPE note SYSTEM “external.dtd”>
<root>
…..<child>123456</child>
</root>

Schema Example

<?xml version=”1.0″ encoding=”UTF-8″?>
<xs:schema xmlns:xs=”http://www.w3.org/2001/XMLSchema”
xmlns=”www.mysite.dk”
xmlns:wmh=”"
elementFormDefault=”qualified”
targetNamespace=”www.mysite.dk”>
<xs:element name=”root”>
…..<xs:complexType>
……….<xs:sequence>
……………<xs:element ref=”child”/>
……….</xs:sequence>
…..</xs:complexType>
</xs:element>
<xs:element name=”child” type=”xs:string”/>
</xs:schema>

Schema Example – Using Schema in a XML

<?xml version=”1.0″ encoding=”utf-8″?>
<root xmlns=”www.mysite.dk”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”www.mysite.dk ex.xsd”>
…..<child/>
</root>

• Single, unique root element
• Matching open/close tags
• Consistent capitalisation
• Correctly nested elements (no overlapping elements)
• Attribute values enclosed in quotes
• No repeating attributes in an element

If a document conforms to the rules then it is well formed.