<!DOCTYPE html>
<html>

<head>
  <meta charset="utf-8">
  <title>Check of FundsXML4-Documents with Holdings</title>
  <meta name="author" content="Peter Raffelsberger">
  <script src="https://unpkg.com/ag-grid-community/dist/ag-grid-community.min.noStyle.js"></script>
  <link rel="stylesheet" href="https://unpkg.com/ag-grid-community/dist/styles/ag-grid.css">
  <link rel="stylesheet" href="https://unpkg.com/ag-grid-community/dist/styles/ag-theme-balham.css">
  <!--link rel="stylesheet" href="https://unpkg.com/ag-grid-community/dist/styles/ag-theme-pr.css"-->
</head>

<style>

.ag-theme-balham .ag-cell {
  line-height: 19px; /*26px;*/
  padding-left: 12px;
  padding-right: 12px;
  border: 1px solid transparent;
  padding-left: 11px;
  padding-right: 11px;
}

.ag-theme-balham .ag-header {
  background-color: #606060; /*#f5f7f7;*/
  color: #e0e0e0; /*rgba(0, 0, 0, 0.54);*/
}

body {
  margin: 10px auto;
  /*max-width: 58em;*/
  /*width: 72em; /* 64em; 58em;*/
  font-family: sans-serif;
  font-size: 0.9em; /*1em;*/
  color: #333333;
}

h1, main, svg {
  /*border-radius: 0px 0.5em 0.5em;*/
  border: 1px solid;
  padding: 10px 20px 8px 20px;  /* oben, rechts, unten, links */
  margin: 10px;
}
 
h1 {
  background: #F1F3F4 10px 5px no-repeat;
  border-color: #d5d5d5;
  color: #2020D0;
  font-size: 1.5em; /*1.5em;*/
  /*padding-left:200px;*/
  text-align: center;
}

h1 span {
  margin-left: 4.5em;
}  

main {
  display: block;     /* for IE */	
  background: #c4ced3;
  border-color: #8a9da8;
  min-height: 400px;
}

form {
  /*width: 40em;*/
}

input {
  text-align: right;
  float: right; /*left;*/
  display: block;
  margin: 0 0 .2em .2em;
  padding: .2em .5em;
  background-color: #f1f3f4; /*#fffbf0;*/
  border: 1px solid #8a9da8; /*#708090; #e7c157;*/
}

input#file-input {
  width: 40em;
}

label { 
  float: right;
  font-size: 1em;
  text-align: right;
  line-height: 1.2;
}

label::after {
  content: ": ";
}

button {
  /*background-color: #FFFF80;*/
  border-style: solid;
  border-width: 1px;
  border-color: #808080;
  color: #2020D0;
  /*float1: right;*/
  font-size: 1.2em; /*1em;*/
  font-weight: bold;
  margin: .6em .6em .6em 0em;  /* oben, rechts, unten, links */
  padding: 5px 30px 4px 30px;  /* oben, rechts, unten, links */
  /*padding: 3px 12px 2px 12px;  /* oben, rechts, unten, links */
  background: linear-gradient(to top, #C0C0C0, #F6F6F6);
  /*background: linear-gradient(to top, #C0C0C0, #EDEDED);*/
}

button:hover {
  /*background-color: #E0E0A0; /* #EDEDED; */
  background: linear-gradient(to top, #EDEDED, #C0C0C0);
  border-style: solid;
  border-width: 1px;
  border-color: #000000;
}

button.sample {
  /*background-color: #FFFF80;*/
  font-size: 1em; /*1.3em;*/
  font-weight: normal;
  color: #202020;
  margin: 0em .3em 0em .3em;  /* oben, rechts, unten, links */
  padding: 3px 12px 2px 12px;  /* oben, rechts, unten, links */
}

button.clear {
  /*background-color: #FFFF80;*/
  font-size: 1em; /*1.3em;*/
  font-weight: normal;
	float: right;
  color: #202020;
  margin: 0em 0em 0em 1em;  /* oben, rechts, unten, links */
  padding: 3px 15px 2px 15px;  /* oben, rechts, unten, links */
}

td {
  /*padding: .2em .4em 0.2em 0.4em;  /* oben, rechts, unten, links */
  padding: 0px 5px 0px 5px;  /* oben, rechts, unten, links */
  vertical-align: top;
  white-space: nowrap;
}

td.table-titel {
  background: #9aa8b8; /* #f1f3f4; #c4ced3; */
  padding: 5px 5px 3px 5px;  /* oben, rechts, unten, links */
  text-align: center;
}

td.myheader {
  font-weight: bold;
  line-height: 2.2em;
  padding: 0.2em .3em .0em 0.3em;  /* oben, rechts, unten, links */
  /*
  font-size: 1em;
  padding: 0.2em .3em 0.2em 0.3em;  /* oben, rechts, unten, links */
  */
}

td.source {
  margin: 0em .75em 0em .3em;
  padding: 0em .75em 0em .3em;  /* oben, rechts, unten, links */
}

td.data {
  font-size: 0.9em;
  /*padding: .2em .5em 0em 0.5em;  /* oben, rechts, unten, links */
  vertical-align: middle;
}

td.data-right {
  font-size: 0.9em;
  /*padding: .2em .5em 0em 0.5em;  /* oben, rechts, unten, links */
  text-align: right;
  vertical-align: middle;
}

td.input {
  color: #888888;
  font-size: 0.75em;
  line-height: 2.0em;
  /*padding: 0em .3em 0em 0.3em;  /* oben, rechts, unten, links */
}

td.about {
  background: #F1F3F4;
  border: 1px solid #909090; /*#708090; #e7c157;*/
  /*border-color: #d5d5d5;*/
  font-size: 0.85em;
  /*font-weight: bold;*/
  max-width: 844px;
  padding: .6em .6em .6em .6em;  /* oben, rechts, unten, links */
}

tr.about {
  margin: 0em 0em 0em 2em;  /* oben, rechts, unten, links */
}

td.author {
  font-size: 0.75em;
  font-weight: bold;
  vertical-align: bottom;
}

textarea {
  background: #F1F3F4;
  font-size: 12px; /*0.9em;*/
  margin: 0em .3em 0em 0em;
  /*padding: 0.2em .0em .0em 0.3em;  /* oben, rechts, unten, links */
	width: 100%;
  /*max-width: 844px;*/
}

textarea.result {
  /*color: #888888;*/
}

</style>

<body>

<script type="text/javascript">

const cOK = 0;
const cWarning = 1;
const cError = 2;
const cErrorMandatory = 3;
const cAllOptional = 4;
const cAllMandatory = 5;

var sourceText;
var resultArea;
var xmlDoc;
var buttonAnalyseFundsXmlDoc;


// array for check results
var aCheckResults = [
  //{module: "ModuleName", status: "OK", xpath: "/FundsXML4", uniqueID: "...", text: "abc"}
];

/*
var colDef = {
    name: 'Dynamic Styles',
    field' 'field2',
    cellStyle: function(params) {
        if (params.value=='Police') {
            //mark police cells as red
            return {color: 'red', backgroundColor: 'green'};
        } else {
            return null;
        }
    }
}*/

// specify the columns for check results grid
var columnDefsCheckResults = [
  {headerName: "Section", field: "module", width: 125},
  {headerName: "Status", field: "status", width: 80, /*, filter: 'agStatusFilter'*/
    cellStyle: function(params) {
        if (params.value == 'OK') return {backgroundColor: '#B0F0B0'};
        if (params.value == 'WARNING') return {backgroundColor: '#FFE0A0'};
        if (params.value == 'ERROR') return {backgroundColor: '#F0B0B0'};
        return null;
    }
	},
  {headerName: "XPath", field: "xpath", width: 300, editable: true},
  {headerName: "UniqueID", field: "uniqueID", width: 100, editable: true},
  {headerName: "Description", field: "text", width: 1000, editable: true}
];

// specify the data for check results grid
var gridDataCheckResults = [
  //{module: "ModuleName", status: "OK", xpath: "/FundsXML4", uniqueID: "...", text: "abc"}
];

// let the grid know which columns and what data to use
var gridOptionsCheckResults = {
  columnDefs: columnDefsCheckResults,
  rowData: gridDataCheckResults,
  rowHeight: 22,
  enableColResize: true,
  enableSorting: true,
  enableFilter: true
};


function filterResults (moduleFilter, statusFilter)
{
	gridDataCheckResults = [];

  if (moduleFilter == 'RegulatoryReporting') {
	  for (var i = 0; i < aCheckResults.length; i++)
		  if ((aCheckResults[i].module == moduleFilter || aCheckResults[i].module.substr(0,7) == 'RegRep-') && (aCheckResults[i].status == statusFilter || statusFilter == ''))
			  gridDataCheckResults.push(aCheckResults[i]);
  }
  else {
	  for (var i = 0; i < aCheckResults.length; i++)
		  if ((aCheckResults[i].module == moduleFilter || moduleFilter == '') && (aCheckResults[i].status == statusFilter || statusFilter == ''))
			  gridDataCheckResults.push(aCheckResults[i]);
  }

  gridOptionsCheckResults.api.setRowData(gridDataCheckResults);
}


// specify the columns for check results grid
/*
var columnDefsSummary = [
  {headerName: "SECTION", field: "section", width: 250},
  {headerName: "STATUS", field: "status", width: 110},
  {headerName: "PASSED", field: "ok", width: 110},
  {headerName: "WARNINGS", field: "warning", width: 110},
  {headerName: "ERRORS", field: "error", width: 110}
];
*/
var columnDefsSummary = [
  {headerName: "Section", field: "section", width: 250},
  {headerName: "Status", field: "status", width: 110,
    cellStyle: function(params) {
        if (params.value == 'OK') return {backgroundColor: '#B0F0B0'};
        if (params.value == 'Warning') return {backgroundColor: '#FFE0A0'};
        if (params.value == 'Error') return {backgroundColor: '#F0B0B0'};
        return null;
    }
	},
  {headerName: "OKs", field: "ok", width: 100},
  {headerName: "Warnings", field: "warning", width: 100},
  {headerName: "Errors", field: "error", width: 100}
];

// specify the data for check results grid
var gridDataSummary = [
  {section: "Root", status: "-", ok: 0, warning: 0, error: 0},
  {section: "ControlData", status: "-", ok: 0, warning: 0, error: 0},
  {section: "Funds", status: "-", ok: 0, warning: 0, error: 0},
  {section: "FundDynamicData", status: "-", ok: 0, warning: 0, error: 0},
  {section: "FundStaticData", status: "-", ok: 0, warning: 0, error: 0},
  {section: "ShareClasses", status: "-", ok: 0, warning: 0, error: 0},
  {section: "Holdings", status: "-", ok: 0, warning: 0, error: 0},
  {section: "Transactions", status: "-", ok: 0, warning: 0, error: 0},
  {section: "AssetMasterData", status: "-", ok: 0, warning: 0, error: 0},
  {section: "RegulatoryReporting", status: "-", ok: 0, warning: 0, error: 0},
  {section: "TOTAL", status: "-", ok: 0, warning: 0, error: 0}
];

function onCellClickedSummary (params)
{
	// params.node.data["is_row_update"] = 1;
	// params.rowIndex (e.g. 5 for Holdings)
	// params.data.section (e.g. 'Root' or 'ControlData' or 'Holdings')
	// params.column.colId (e.g. 'section' or 'ok' or 'warning' or 'error')
	// statusText.innerHTML = 'onCellClicked(' + params.data.section + ', ' + params.column.colId + ')';
	var section = params.data.section;
	if (section == 'TOTAL')
	  section = '';

	var status = '';
	if (params.column.colId == 'ok') status = 'OK';
	if (params.column.colId == 'warning') status = 'WARNING';
	if (params.column.colId == 'error') status = 'ERROR';

	filterResults(section, status);
}

// let the grid know which columns and what data to use
var gridOptionsSummary = {
  columnDefs: columnDefsSummary,
  rowData: gridDataSummary,
  rowHeight: 22,
  enableColResize: true,
  enableSorting: false,
  enableFilter: false,
	onCellClicked: onCellClickedSummary
};


function updateSummaryStatus()
{
  var sections = gridDataSummary.length - 1;

  gridDataSummary[sections].ok = gridDataSummary[0].ok;
  gridDataSummary[sections].warning = gridDataSummary[0].warning;
  gridDataSummary[sections].error = gridDataSummary[0].error;

	for (var i = 0; i < sections; i++) {
    gridDataSummary[sections].ok += gridDataSummary[i].ok;
    gridDataSummary[sections].warning += gridDataSummary[i].warning;
    gridDataSummary[sections].error += gridDataSummary[i].error;
  }

	for (var i = 0; i < gridDataSummary.length; i++) {
		if (gridDataSummary[i].error > 0)
		  gridDataSummary[i].status = "Error";
		else
			if (gridDataSummary[i].warning > 0)
				gridDataSummary[i].status = "Warning";
			else
				gridDataSummary[i].status = "OK";
	}
}


function escapeHtml(text)
{
  return text
         .replace(/&/g, "&amp;")
         .replace(/</g, "&lt;")
         .replace(/>/g, "&gt;")
         .replace(/"/g, "&quot;")
         .replace(/'/g, "&#039;");
}


function LoadSampleDoc(filename)
{
  var fileURL = "samples/" + filename;

  //sourceText.innerHTML = escapeHtml("<FundsXML4/>");
  xhttp = new XMLHttpRequest();
  xhttp.overrideMimeType('text');  // 'text/xml'
  xhttp.open("GET", fileURL, false);
  xhttp.send(null);
  //xmlDoc = xhttp.responseXML;
  sourceText.innerHTML = escapeHtml(xhttp.responseText);
}


function Test() {
  var XML = document.createElement("div");
  var Node = document.createElement("testing");
  Node.appendChild( document.createElement("testingOne") );
  Node.appendChild( document.createElement("TestingTwo") );
  Node.appendChild( document.createElement("TestingThree") );
  XML.appendChild(Node);
  //alert(XML.innerHTML);
  var ResultText = document.getElementById('XmlResult');
  ResultText.innerHTML = XML.innerHTML;
}


function FillWithTestData() {
  document.getElementById('DataSupplierName').value = 'Asset Management Company';
  document.getElementById('DataSupplierCode').value = 'AMC';
  document.getElementById('DocumentID').value = '1234567890';
  document.getElementById('FundName').value = 'Test Fund European Equities';
  document.getElementById('FundCurrency').value = 'EUR';
  document.getElementById('FundIsin').value = 'XY0123456789';
  document.getElementById('NavDate').value = '2015-09-16';
  document.getElementById('NavPerShare').value = '123.45';
  document.getElementById('XmlResult').value = '';
}


function ClearFields() {
  document.getElementById('DataSupplierName').value = '';
  document.getElementById('DataSupplierCode').value = '';
  document.getElementById('DocumentID').value = '';
  document.getElementById('FundName').value = '';
  document.getElementById('FundCurrency').value = '';
  document.getElementById('FundIsin').value = '';
  document.getElementById('NavDate').value = '';
  document.getElementById('NavPerShare').value = '';
  document.getElementById('XmlResult').value = '';
}


function setDigits(value, digits)
{
  var factor = 1;

  for (var i = 0; i < digits; i++)
    factor *= 10;

  return Math.round(value * factor) / factor;
}


function StrLen(text)
{
  var result = 0;
  var vt = typeof text;

  if (vt == 'string')
    result = Number(text.length);

  return result;
}


function Int2Str(number, digits)
{
  var result = number.toString();

  while (result.length < digits)
    result = '0' + result;

  return result;
}


function FormatXML(xml)
{
  var out = "";
  var tab = "  ";
  var level = 0;
  var inTag = false;
  var currentTagClosing = false;
  var lastTagClosing = false;

  function indent(level) {
    out += "\n";
    for (var i = 0; i < level; i++)
      out += tab;
  }

  var len = xml.length;
  var lastChar = ' ';

  for (var i = 0; i < len; i++) {
    var c = xml.charAt(i);
    if (c == '<') {
      inTag = true;
      currentTagClosing = false;
      if (lastChar == '>') {
        if (xml.charAt(i+1) == '/')
          currentTagClosing = true;
        if (lastTagClosing && currentTagClosing)
          level--;
        if (!lastTagClosing && !currentTagClosing)
          level++;
        indent(level);
      }
    }
    else if (c == '>') {
      inTag = false;
      lastTagClosing = currentTagClosing;
    }
    else if (c == '/' && inTag) {
      currentTagClosing = true;
    }
    out += c;
    lastChar = c;
  }

  return out;
}


function getDateTime()
{
  var now = new Date();
  var year = now.getFullYear();
  var month = now.getMonth() + 1;
  var day = now.getDate();
  var hour = now.getHours();
  var minute = now.getMinutes();
  var second = now.getSeconds();

  if (month.toString().length == 1) {
    var month = '0' + month;
  }
  if (day.toString().length == 1) {
    var day = '0' + day;
  }
  if (hour.toString().length == 1) {
    var hour = '0' + hour;
  }
  if (minute.toString().length == 1) {
    var minute = '0' + minute;
  }
  if (second.toString().length == 1) {
    var second = '0' + second;
  }
  var dateTime = year + '/' + month + '/' + day + ' ' + hour + ':' + minute + ':' + second;

  return dateTime;
}


function formatDate(date, fmt)
{
  function pad(value) {
    return (value.toString().length < 2) ? '0' + value : value;
  }
  return fmt.replace(/%([a-zA-Z])/g, function (_, fmtCode) {
    switch (fmtCode) {
      case 'Y':
        return date.getUTCFullYear();
      case 'M':
        return pad(date.getUTCMonth() + 1);
      case 'd':
        return pad(date.getUTCDate());
      case 'H':
        return pad(date.getUTCHours());
      case 'm':
        return pad(date.getUTCMinutes());
      case 's':
        return pad(date.getUTCSeconds());
      default:
        throw new Error('Unsupported format code: ' + fmtCode);
    }
  });
}


function appendTextNode(parentNode, nodeName, text)
{
  var element = xmlDoc.createElement(nodeName);
  var textNode = xmlDoc.createTextNode(text);
  element.appendChild(textNode);
  parentNode.appendChild(element);
}


function appendAttrTextNode(parentNode, nodeName, attrName, attrValue, text)
{
  var element = xmlDoc.createElement(nodeName);
  var textNode = xmlDoc.createTextNode(text);

  element.appendChild(textNode);

  if (StrLen(attrName) > 0)
    element.setAttribute(attrName, attrValue);

  parentNode.appendChild(element);
}


function appendSubTextNode(parentNode, nodeName, subNodeName, text)
{
  var node = xmlDoc.createElement(nodeName);
  parentNode.appendChild(node);
  appendTextNode(node, subNodeName, text);
}


function appendDataSupplier(parentNode)
{
  /*
	<DataSupplier>
		<SystemCountry>EU</SystemCountry>
		<Short>SDS</Short>
		<Name>Sample Data Supplier</Name>
		<Type>Generic</Type>
	</DataSupplier>
  */
  var node = xmlDoc.createElement("DataSupplier");
  parentNode.appendChild(node);

  appendTextNode(node, "SystemCountry", "EU");
  appendTextNode(node, "Short", "SDS");
  appendTextNode(node, "Name", "Sample Data Supplier");
  appendTextNode(node, "Type", "Generic");
}


function appendIdentifiers(parentNode, isin, lei, swiftBIC)
{
  /*
	<Identifiers>
		<ISIN>US0028241000</ISIN>
		<LEI>2138000SAMPLE00LEI00</LEI>
	</Identifiers>
  */
  var node = xmlDoc.createElement("Identifiers");
  parentNode.appendChild(node);

  if (StrLen(isin) == 12)
    appendTextNode(node, "ISIN", isin);

  if (StrLen(lei) == 20)
    appendTextNode(node, "LEI", lei);

  if (StrLen(swiftBIC) == 8)
    appendTextNode(node, "SwiftBIC", swiftBIC);
}


function appendCompany(parentNode, nodeName, lei, swiftBIC, name)
{
  var node = xmlDoc.createElement(nodeName);
  appendIdentifiers(node, "", lei, swiftBIC);
  appendTextNode(node, "Name", name);
  parentNode.appendChild(node);
}


function appendAmounts(parentNode, nodeName, ccy1, amount1, ccy2, amount2)
{
  /*
  <TotalNetAssetValue>
    <Amount ccy="EUR">9357424.31</Amount>
  </TotalNetAssetValue>
  */
  var node = xmlDoc.createElement(nodeName);
  parentNode.appendChild(node);

  appendAttrTextNode(node, "Amount", "ccy", ccy1, amount1.toFixed(2));

  if (StrLen(ccy2) == 3 && ccy2 != ccy1)
    appendAttrTextNode(node, "Amount", "ccy", ccy2, amount2.toFixed(2));
}


function appendTotalAssetValues(parentNode, navDate, ccy, amount)
{
  /*
	<TotalAssetValues>
		<TotalAssetValue>
			<NavDate>2016-09-30</NavDate>
			<TotalAssetNature>OFFICIAL</TotalAssetNature>
			<TotalNetAssetValue>
				<Amount ccy="EUR">9357424.31</Amount>
			</TotalNetAssetValue>
		</TotalAssetValue>
	</TotalAssetValues>
  */
  var totalAssetValuesNode = xmlDoc.createElement("TotalAssetValues");
  parentNode.appendChild(totalAssetValuesNode);

  var totalAssetValueNode = xmlDoc.createElement("TotalAssetValue");
  totalAssetValuesNode.appendChild(totalAssetValueNode);

  appendTextNode(totalAssetValueNode, "NavDate", navDate);
  appendTextNode(totalAssetValueNode, "TotalAssetNature", "OFFICIAL");
  appendAmounts(totalAssetValueNode, "TotalNetAssetValue", ccy, amount);  //, ccy2, amount2);
}


function appendPositions(parentNode)
{
  /*
	<Positions>
		<Position>
			<UniqueID>AK279855</UniqueID>
			<Identifiers>
				<ISIN>US0028241000</ISIN>
			</Identifiers>
			<Currency>USD</Currency>
			<TotalValue>
				<Amount ccy="EUR">104951.57</Amount>
				<Amount ccy="USD">117855.36</Amount>
			</TotalValue>
			<Equity>
				<Units>2844.00</Units>
				<Price>
					<Amount ccy="USD">41.44</Amount>
				</Price>
			</Equity>
		</Position>
  */
  var positionsNode = xmlDoc.createElement("Positions");
  parentNode.appendChild(positionsNode);

  for (var i = 0; i < securities.length; i++) {
    if (securities[i].pieces > 0) {
      var positionNode = xmlDoc.createElement("Position");
      var instrumentNode;

      appendTextNode(positionNode, "UniqueID", securities[i].uniqueID);
      appendIdentifiers(positionNode, securities[i].isin, '');
      appendTextNode(positionNode, "Currency", securities[i].ccy);
      appendAmounts(positionNode, "TotalValue", fundCCY, securities[i].valueFC, securities[i].ccy, securities[i].valueLC);

      if (securities[i].assetType == "EQ") {
        instrumentNode = xmlDoc.createElement("Equity");
        appendTextNode(instrumentNode, "Units", securities[i].pieces);
        appendAmounts(instrumentNode, "Price", securities[i].ccy, securities[i].price);
      }

      positionNode.appendChild(instrumentNode);
      positionsNode.appendChild(positionNode);
    }
  }

  for (var i = 0; i < fxForwards.length; i++) {
    if (fxForwards[i].sellAmount > 0) {
      var positionNode = xmlDoc.createElement("Position");
      appendTextNode(positionNode, "UniqueID", fxForwards[i].uniqueID);
      appendTextNode(positionNode, "Currency", fundCCY);
      appendAmounts(positionNode, "TotalValue", fundCCY, 0); //fxForwards[i].valueFC);

      instrumentNode = xmlDoc.createElement("FXForward");
      appendTextNode(instrumentNode, "HedgeRatio", 100);
      positionNode.appendChild(instrumentNode);

      positionsNode.appendChild(positionNode);
    }
  }
}


function appendAssetMasterData(parentNode)
{
  /*
	<Asset>
		<UniqueID>AK386833</UniqueID>
		<Identifiers>
			<ISIN>US02079K1079</ISIN>
		</Identifiers>
		<Currency>USD</Currency>
		<Country>US</Country>
		<Name>ALPHABET INC.CL C DL-,001</Name>
		<AssetType>EQ</AssetType>
	</Asset>
  */
  var nodeAssetMasterData = xmlDoc.createElement("AssetMasterData");
  parentNode.appendChild(nodeAssetMasterData);

  for (var i = 0; i < securities.length; i++) {
    if (securities[i].pieces > 0) {
      var nodeAsset = xmlDoc.createElement("Asset");
      var nodeInstrument;

      appendTextNode(nodeAsset, "UniqueID", securities[i].uniqueID);
      appendIdentifiers(nodeAsset, securities[i].isin, '');
      appendTextNode(nodeAsset, "Currency", securities[i].ccy);
      appendTextNode(nodeAsset, "Country", securities[i].isin.substr(0,2));
      appendTextNode(nodeAsset, "Name", securities[i].name);
      appendTextNode(nodeAsset, "AssetType", securities[i].assetType);
      /*
      if (securities[i].assetType == "EQ") {
        nodeInstrument = xmlDoc.createElement("Equity");
        appendTextNode(nodeInstrument, "Units", securities[i].pieces);
        appendAmounts(nodeInstrument, "Price", securities[i].ccy, securities[i].price);
      }
      nodeAsset.appendChild(nodeInstrument);
      */
      nodeAssetMasterData.appendChild(nodeAsset);
    }
  }

  for (var i = 0; i < fxForwards.length; i++) {
    if (fxForwards[i].sellAmount > 0) {
      var nodeAsset = xmlDoc.createElement("Asset");
      appendTextNode(nodeAsset, "UniqueID", fxForwards[i].uniqueID);
      appendTextNode(nodeAsset, "Currency", fundCCY);
      appendTextNode(nodeAsset, "Country", "EU");
      appendTextNode(nodeAsset, "Name", "Hedging FX-Forward " + fxForwards[i].sellCcy + "/" + fundCCY);
      appendTextNode(nodeAsset, "AssetType", "FX");

      var nodeAssetDetails = xmlDoc.createElement("AssetDetails");
      var nodeInstrument = xmlDoc.createElement("FXForward");
      appendTextNode(nodeInstrument, "CurrencyBuy", fundCCY);
      appendTextNode(nodeInstrument, "AmountBuy", fxForwards[i].buyAmount);
      appendTextNode(nodeInstrument, "CurrencySell", fxForwards[i].sellCcy);
      appendTextNode(nodeInstrument, "AmountSell", fxForwards[i].sellAmount);
      appendTextNode(nodeInstrument, "MaturityDate", "2018-09-30");
      appendCompany(nodeInstrument, "Counterparty", counterpartyLEI, "", "Sample Counterparty");
      nodeAssetDetails.appendChild(nodeInstrument);
      nodeAsset.appendChild(nodeAssetDetails);

      nodeAssetMasterData.appendChild(nodeAsset);
    }
  }
}


function CreateMSXMLDocumentObject()
{
  if (typeof (ActiveXObject) != "undefined") {
    var progIDs = ["Msxml2.DOMDocument.6.0", "Msxml2.DOMDocument.5.0", "Msxml2.DOMDocument.4.0", "Msxml2.DOMDocument.3.0", "MSXML2.DOMDocument", "MSXML.DOMDocument"];
    for (var i = 0; i < progIDs.length; i++) {
      try {
        return new ActiveXObject(progIDs[i]);
      } catch (e) { };
    }
  }
  return null;
}


function CreateXMLDocumentObject(rootName)
{
  var xmlDoc;

  try {
    xmlDoc = document.implementation.createDocument("", rootName, null);
  } catch (e) { };

  if (xmlDoc === undefined) {
    xmlDoc = CreateMSXMLDocumentObject();
    if (xmlDoc) {
      var rootNode = xmlDoc.createElement(rootName);
      xmlDoc.appendChild(rootNode);
    }
  }

  return xmlDoc;
}


function getTopPos(element)
{
  var elem = element;
  var topPos = 0;

  while (elem != null) {
    topPos += elem.offsetTop;
    elem = elem.offsetParent;
  }

  return topPos;
}


var securities = new Array();
var fxForwards = new Array();
var fxRates = new Array();
var contentDate;
var navDate;
var creationTimestamp;
var unique_document_id;
var fundName = 'FundsXML Sample Fund';
var fundLEI = '2138000SAMPLE00LEI00';
var fundCCY = 'EUR';
var counterpartyLEI = '213800COUNTERPARTY00';
var securitiesTotal = 0;
var fxForwardsTotal = 0;
var fundVolume = 0;


var aCurrencies =
['AED','AMD','AOA','ARS','ATS','AUD','AZN','BAM','BDT','BEF','BGL','BGN','BMD','BRE','BRL','BWP','BYR','CAD','CHF','CLP','CNH','CNY','COP','COU','CRC','CSD','CYP','CZK',
 'DEM','DKK','DOP','DZD','EEK','EGP','ESP','EUR','FIM','FRF','GBP','GEL','GHS','GMD','GRD','HKD','HRK','HUF','IDR','IEP','ILS','INR','ISK','ITL','JOD','JPY','KES','KGS',
 'KRW','KWD','KYD','KZT','LBP','LKR','LTL','LUF','LVL','LYD','MAD','MKD','MNT','MTL','MWK','MXN','MYR','MZM','MZN','NAD','NGN','NLG','NOK','NZD','OMR','PAB','PEN','PGK',
 'PHP','PKR','PLN','PLZ','PTE','PYG','QAR','ROL','RON','RSD','RUB','RUP','RUR','SAR','SEK','SGD','SIT','SKK','THB','TRL','TRY','TWD','TZS','UAH','UGX','USD','UYI','UYU',
 'UZS','VEB','VEF','VND','XEU','ZAL','ZAR','ZLY','ZMK','ZMW'];

 
var fxRatePercentageWarning = 15;
var fxRatePercentageError = 30;


var aFxRates = [
  {from: "ARS", to: "EUR", rate: 46},
  {from: "ATS", to: "EUR", rate: 14},
  {from: "AUD", to: "EUR", rate: 1.6},
  {from: "BEF", to: "EUR", rate: 40},
  {from: "BGN", to: "EUR", rate: 2},
  {from: "BRL", to: "EUR", rate: 4.8},
  {from: "CAD", to: "EUR", rate: 1.5},
  {from: "CHF", to: "EUR", rate: 1.1},
  {from: "CLP", to: "EUR", rate: 780},
  {from: "CNY", to: "EUR", rate: 8.1},
  {from: "COP", to: "EUR", rate: 3500},
  {from: "CZK", to: "EUR", rate: 26},
  {from: "DEM", to: "EUR", rate: 2},
  {from: "DKK", to: "EUR", rate: 7.5},
  {from: "EEK", to: "EUR", rate: 16},
  {from: "ESP", to: "EUR", rate: 170},
  {from: "EUR", to: "CHF", rate: 0.88},
  {from: "EUR", to: "GBP", rate: 1.12},
  {from: "EUR", to: "JPY", rate: 0.0075},
  {from: "EUR", to: "MXN", rate: 0.045},
  {from: "EUR", to: "USD", rate: 0.85},
  {from: "FIM", to: "EUR", rate: 6},
  {from: "FRF", to: "EUR", rate: 6.6},
  {from: "GBP", to: "EUR", rate: 0.9},
  {from: "GRD", to: "EUR", rate: 340},
  {from: "HKD", to: "EUR", rate: 9.2},
  {from: "HRK", to: "EUR", rate: 7.4},
  {from: "HUF", to: "EUR", rate: 325},
  {from: "IDR", to: "EUR", rate: 17500},
  {from: "IEP", to: "EUR", rate: 0.8},
  {from: "INR", to: "EUR", rate: 85},
  {from: "ISK", to: "EUR", rate: 130},
  {from: "ITL", to: "EUR", rate: 1900},
  {from: "JPY", to: "EUR", rate: 130},
  {from: "KRW", to: "EUR", rate: 1300},
  {from: "KZT", to: "EUR", rate: 420},
  {from: "LTL", to: "EUR", rate: 3.5},
  {from: "LUF", to: "EUR", rate: 40},
  {from: "LVL", to: "EUR", rate: 0.7},
  {from: "MXN", to: "EUR", rate: 22},
  {from: "MYR", to: "EUR", rate: 4.9},
  {from: "NLG", to: "EUR", rate: 2.2},
  {from: "NOK", to: "EUR", rate: 9.5},
  {from: "NZD", to: "EUR", rate: 1.8},
  {from: "PEN", to: "EUR", rate: 3.9},
  {from: "PHP", to: "EUR", rate: 64},
  {from: "PLN", to: "EUR", rate: 4.3},
  {from: "PTE", to: "EUR", rate: 200},
  {from: "RON", to: "EUR", rate: 4.7},
  {from: "RSD", to: "EUR", rate: 120},
  {from: "RUB", to: "EUR", rate: 77},
  {from: "SEK", to: "EUR", rate: 10},
  {from: "SGD", to: "EUR", rate: 1.6},
  {from: "SIT", to: "EUR", rate: 240},
  {from: "SKK", to: "EUR", rate: 30},
  {from: "THB", to: "EUR", rate: 38},
  {from: "TRY", to: "EUR", rate: 7.2},
  {from: "TWD", to: "EUR", rate: 36},
  {from: "UAH", to: "EUR", rate: 33},
  {from: "USD", to: "EUR", rate: 1.2},
  {from: "UYU", to: "EUR", rate: 39},
  {from: "ZAR", to: "EUR", rate: 17}];

	
function getFxRate(fromCcy, toCcy)
{
	//var aFxRates = [ ... {from: "USD", to: "EUR", rate: 1.2} ... ]
	var result, i;

  for (i = 0; i < aFxRates.length; i++)
    if (aFxRates[i].from == fromCcy && aFxRates[i].to == toCcy)
			return aFxRates[i].rate;

  for (i = 0; i < aFxRates.length; i++)
    if (aFxRates[i].from == toCcy && aFxRates[i].to == fromCcy)
			return 1 / aFxRates[i].rate;

	if (fromCcy != 'EUR' && toCcy != 'EUR') {
		var fxRate1 = getFxRate(fromCcy, 'EUR');
		var fxRate2 = getFxRate('EUR', toCcy);
		if (fxRate1 !== undefined && fxRate2 !== undefined)
			result = fxRate1 * fxRate2;
	}
			
	return result;
}


/***************************************************** Routines for parsing and anlysing an FundsXML4 document ******************************************************/

const modRoot = 0;

const modControlData = 1;

const modFunds = 2;
const modFundStaticData = 3;
const modFundDynamicData = 4;
const modSingleFund = 5;
const modSingleFundStaticData = 6;
const modSubFund = 7;
const modSubfundStaticData = 8;
const modSubfundDynamicData = 9;
const modShareClasses = 10;
const modSegments = 11
const modSegmentStaticData = 12;
const modSegmentDynamicData = 13;
const modPortfolios = 14;
const modHoldings = 15;
const modTransactions = 16;
const modEarnings = 17;
const modPositionsDecomposed = 18;
const modBreakDowns = 19;
const modRiskCodes = 20;

const modAssetMasterData = 30;

const modAssetMgmtCompanyDynData = 40;

const modDocuments = 50;

const modRegulatoryReporting = 60;
const modRegulatoryReportingEMIR = 61;
const modRegulatoryReportingEMT = 62;
const modRegulatoryReportingKIID = 63;
const modRegulatoryReportingPRIIPS = 64;
const modRegulatoryReportingSolvencyII = 65;

const modCountrySpecificDataAT = 90;
const modCountrySpecificDataDE = 91;
const modCountrySpecificDataDK = 92;
const modCountrySpecificDataFR = 93;
const modCountrySpecificDataLU = 94;
const modCountrySpecificDataNL = 95;


var aModules = new Array();
aModules[modRoot] = 'Root';
aModules[modControlData] = 'ControlData';
aModules[modFunds] = 'Funds';
aModules[modFundStaticData] = 'FundStaticData';
aModules[modFundDynamicData] = 'FundDynamicData';
aModules[modSingleFund] = 'SingleFund';
aModules[modSingleFundStaticData] = 'SingleFundStaticData';
aModules[modSubFund] = 'SubFund';
aModules[modSubfundStaticData] = 'SubfundStaticData';
aModules[modSubfundDynamicData] = 'SubfundDynamicData';
aModules[modShareClasses] = 'ShareClasses';
aModules[modSegments] = 'Segments';
aModules[modSegmentStaticData] = 'SegmentStaticData';
aModules[modSegmentDynamicData] = 'SegmentDynamicData';
aModules[modPortfolios] = 'Portfolios';
aModules[modHoldings] = 'Holdings';
aModules[modTransactions] = 'Transactions';
aModules[modEarnings] = 'Earnings';
aModules[modPositionsDecomposed] = 'PositionsDecomposed';
aModules[modBreakDowns] = 'BreakDowns';
aModules[modRiskCodes] = 'RiskCodes';
aModules[modAssetMasterData] = 'AssetMasterData';
aModules[modRegulatoryReporting] = 'RegulatoryReporting';
aModules[modRegulatoryReportingEMIR] = 'RegRep-EMIR';
aModules[modRegulatoryReportingEMT] = 'RegRep-EMT';
aModules[modRegulatoryReportingKIID] = 'RegRep-KIID';
aModules[modRegulatoryReportingPRIIPS] = 'RegRep-PRIIPS';
aModules[modRegulatoryReportingSolvencyII] = 'RegRep-SolvencyII';

var aUsedModules = new Array();

var currentModule;
var currentUniqueID;
var currentStatus;

var statusText;

var uniqueDocumentID;
var relatedDocumentID;
var documentGenerated;
var contentDate;
var dataOperation;
var docVersion;
var docLanguage;
var aFunds = new Array();
var aAssetMasterData = new Array();
var aPortfolios = new Array();
//var anErrors = new Array();


/*
Members of fund object:
-----------------------
var securities = new Array();
var fxForwards = new Array();
//var fxRates = new Array();
//var anNavDate;
var fundName = 'FundsXML Sample Fund';
var fundLEI = '2138000SAMPLE00LEI00';
var fundCCY = 'EUR';
var fundVolume = 0;
var securitiesTotal = 0;
var fxForwardsTotal = 0;
*/


//---------------------------------------------------------------------------------------------------------------------

// Needed for Internet Explorer:
Number.isInteger = Number.isInteger || function(value) {
    return typeof value === "number" && 
           isFinite(value) && 
           Math.floor(value) === value;
};


//---------------------------------------------------------------------------------------------------------------------

function getFirstChildNode(parentNode, nodeName)
{
  var node;

  try {
    node = parentNode.getElementsByTagName(nodeName)[0];
  } catch (e) {
    //return false;
  };

  return node;
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeValue(parentNode, nodeName)
{
  var result = '';
  var node;

  try {
    node = parentNode.getElementsByTagName(nodeName)[0];
  } catch (e) {
    //return false;
  };

  if (node !== undefined)
    result = node.textContent;
    //result = node.childNodes[0].nodeValue;

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeNumber(parentNode, nodeName)
{
  return Number(getNodeValue(parentNode, nodeName));
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeBoolean(parentNode, nodeName)
{
  var result;
  var text = getNodeValue(parentNode, nodeName).toLowerCase();

  if (text == "true")
    result = true;
  else
    if (text == "false")
      result = false;

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getSubNodeValue(parentNode, nodeName, subNodeName)
{
  var result = '';
  var node;

  try {
    node = parentNode.getElementsByTagName(nodeName)[0];
  } catch (e) {
    //return false;
  };

  if (node !== undefined)
    result = getNodeValue(node, subNodeName);

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function isPositiveNumber(num)
{
  result = false;
  if (!isNaN(num))
    result = (num > 0);
  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getAssetMasterDataIndex(uniqueID)
{
  var result;

  for (var i = 0; i < aAssetMasterData.length; i++)
    if (aAssetMasterData[i].uniqueID == uniqueID) {
      result = i;
      i = aAssetMasterData.length; // stop loop
    }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function addToCcySums(fundIndex, ccy, amount)
{
  var ccyIndex = -1;

  for (var i = 0; i < aFunds[fundIndex].ccySums.length; i++)
    if (aFunds[fundIndex].ccySums[i].ccy == ccy) {
      ccyIndex = i;
      i = aFunds[fundIndex].ccySums.length; // exit loop
    }

  if (ccyIndex < 0) {
    // add entry for new currency
    var ccySum = new Object();
    ccySum.ccy = ccy;
    ccySum.amount = amount;
    ccySum.count = 1;
    aFunds[fundIndex].ccySums.push(ccySum);
  }
  else {
    // update existing entry
    aFunds[fundIndex].ccySums[ccyIndex].amount += amount;
    aFunds[fundIndex].ccySums[ccyIndex].count++;
  }
}


//---------------------------------------------------------------------------------------------------------------------

function addCcyHedge(fundIndex, ccy, amount)
{
  var ccyIndex = -1;
  var ccyCount = aFunds[fundIndex].ccyFxHedges.length;

  for (var i = 0; i < ccyCount; i++)
    if (aFunds[fundIndex].ccyFxHedges[i].ccy == ccy) {
      ccyIndex = i;
      i = ccyCount; // exit loop
    }

  if (ccyIndex < 0) {
    // add entry for new currency
    var ccySum = new Object();
    ccySum.ccy = ccy;
    ccySum.amount = amount;
    ccySum.count = 1;
    aFunds[fundIndex].ccyFxHedges.push(ccySum);
  }
  else {
    // update existing entry
    aFunds[fundIndex].ccyFxHedges[ccyIndex].amount += amount;
    aFunds[fundIndex].ccyFxHedges[ccyIndex].count++;
  }
}


//---------------------------------------------------------------------------------------------------------------------

function addFxHedge(fundIndex, assetIndex)
{
  // All amounts must be in fund currency !
  // Precondition: buyCcy or sellCcy must be fund currency !
  if (aAssetMasterData[assetIndex].buyCcy == aFunds[fundIndex].ccy) {
    addCcyHedge(fundIndex, aAssetMasterData[assetIndex].buyCcy, aAssetMasterData[assetIndex].buyAmount);
    addCcyHedge(fundIndex, aAssetMasterData[assetIndex].sellCcy, 0 - aAssetMasterData[assetIndex].buyAmount);
  }
  if (aAssetMasterData[assetIndex].sellCcy == aFunds[fundIndex].ccy) {
    addCcyHedge(fundIndex, aAssetMasterData[assetIndex].buyCcy, aAssetMasterData[assetIndex].sellAmount);
    addCcyHedge(fundIndex, aAssetMasterData[assetIndex].sellCcy, 0 - aAssetMasterData[assetIndex].sellAmount);
  }
}


//---------------------------------------------------------------------------------------------------------------------

function addToHedgedCcySums(fundIndex, ccy, amount)
{
  var ccyIndex = -1;
  var ccyCount = aFunds[fundIndex].ccyHedgedSums.length;

  for (var i = 0; i < ccyCount; i++)
    if (aFunds[fundIndex].ccyHedgedSums[i].ccy == ccy) {
      ccyIndex = i;
      i = ccyCount; // exit loop
    }

  if (ccyIndex < 0) {
    // add entry for new currency
    var ccySum = new Object();
    ccySum.ccy = ccy;
    ccySum.amount = amount;
    ccySum.count = 1;
    aFunds[fundIndex].ccyHedgedSums.push(ccySum);
  }
  else {
    // update existing entry
    aFunds[fundIndex].ccyHedgedSums[ccyIndex].amount += amount;
    aFunds[fundIndex].ccyHedgedSums[ccyIndex].count++;
  }
}


//---------------------------------------------------------------------------------------------------------------------

function calculateHedgedCcyExposure(fundIndex)
{
  // starting point is nominal sum of currencies
  var ccyCount = aFunds[fundIndex].ccySums.length;
  aFunds[fundIndex].ccyHedgedSums = new Array();
  //aFunds[fundIndex].ccyHedgedSums = aFunds[fundIndex].ccySums.slice(0);

  for (var i = 0; i < ccyCount; i++) {
    var ccySum = new Object();
    ccySum.ccy = aFunds[fundIndex].ccySums[i].ccy;
    ccySum.amount = aFunds[fundIndex].ccySums[i].amount;
    ccySum.count = aFunds[fundIndex].ccySums[i].count;
    aFunds[fundIndex].ccyHedgedSums.push(ccySum);
  }

  for (var i = 0; i < aFunds[fundIndex].ccyFxHedges.length; i++)
    addToHedgedCcySums(fundIndex, aFunds[fundIndex].ccyFxHedges[i].ccy, aFunds[fundIndex].ccyFxHedges[i].amount);
}


var crlf = "\r\n";


//---------------------------------------------------------------------------------------------------------------------

function ShowResult()
{
  //resultArea.value = "Funds found: " + aFunds.length;
  var resultText = '';

  for (var fundIndex = 0; fundIndex < aFunds.length; fundIndex++) {
    resultText += "Fund name: " + aFunds[fundIndex].name + crlf;
    resultText += "Fund volume: " + aFunds[fundIndex].ccy + " " + aFunds[fundIndex].fundVolume + crlf;

    for (var i = 0; i < aFunds[fundIndex].ccySums.length; i++) {
      var amount = aFunds[fundIndex].ccySums[i].amount;
      var percentage = (amount * 100) / aFunds[fundIndex].fundVolume;
      resultText += "  Currency exposure: " + aFunds[fundIndex].ccySums[i].ccy + " " + Math.round(amount) + " (" + setDigits(percentage,2) + "%)" + crlf;
    }
  }

  resultArea.value = resultText;
}


//---------------------------------------------------------------------------------------------------------------------

function getStatusName(status)
{
  var name = '';
  if (status == cOK) name = 'OK';
  if (status == cWarning) name = 'WARNING';
  if (status == cError) name = 'ERROR';
  return name;
}


//---------------------------------------------------------------------------------------------------------------------


function addStatusToSummary(status)
{
	var summaryIndex = -1;
	if (currentModule == modRoot)
		summaryIndex = 0;  // Root
	if (currentModule == modControlData)
		summaryIndex = 1;  // ControlData
	if (currentModule == modFundDynamicData)
		summaryIndex = 3;  // FundDynamicData
	if (currentModule == modFundStaticData || currentModule == modSingleFundStaticData)
		summaryIndex = 4;  // FundStaticData
	if (currentModule == modShareClasses)
		summaryIndex = 5;  // ShareClasses
	if (currentModule == modHoldings)
		summaryIndex = 6;  // Holdings
	if (currentModule == modTransactions)
		summaryIndex = 7;  // Transactions
	if (currentModule == modAssetMasterData)
		summaryIndex = 8;  // AssetMasterData
	if (currentModule >= modRegulatoryReporting && currentModule <= modRegulatoryReportingSolvencyII)
		summaryIndex = 9;  // RegulatoryReporting
	if (summaryIndex < 0 && currentModule < modAssetMasterData)
		summaryIndex = 2;  // Funds (default for <Funds> section)

	if (summaryIndex >= 0) {
		if (status == cOK)
			gridDataSummary[summaryIndex].ok = gridDataSummary[summaryIndex].ok + 1;
		if (status == cWarning)
			gridDataSummary[summaryIndex].warning = gridDataSummary[summaryIndex].warning + 1;
		if (status == cError)
			gridDataSummary[summaryIndex].error = gridDataSummary[summaryIndex].error + 1;
	}
}


//---------------------------------------------------------------------------------------------------------------------

function AddResult(status, xpath, text)
{
  var moduleName = aModules[currentModule];
  var statusName = getStatusName(status);

  if (currentStatus === undefined)
	currentStatus = cOK;

  if (status == cWarning && currentStatus == cOK)
	currentStatus = cWarning;

  if (status == cError && currentStatus != cError)
	currentStatus = cError;

	addStatusToSummary(status);

  // add check result to text protocol
  var line = aModules[currentModule] + ' - ' + getStatusName(status) + ' @ ' + xpath;
  if (currentUniqueID !== undefined && currentUniqueID != '')
	line = line + '[UniqueID="' + currentUniqueID + '"]';
  line = line + ': ' + text;
  resultArea.innerHTML = resultArea.innerHTML + escapeHtml(line) + crlf;

  // add check result to grid data
  var checkResult = new Object();
  checkResult.module = moduleName;
  checkResult.status = statusName;
  checkResult.xpath = xpath;
  checkResult.uniqueID = currentUniqueID;
  checkResult.text = text;
	aCheckResults.push(checkResult);
  //gridDataCheckResults.push(checkResult);
}


//---------------------------------------------------------------------------------------------------------------------

function GetChildNode(parentNode, nodeName, reportStatus, xpath)
{
  var childNode;

  try {
    childNode = parentNode.getElementsByTagName(nodeName)[0];
  } catch (e) {
    // do nothing
  };

  if (childNode === undefined && reportStatus != cOK) {
    var status = reportStatus;
	  if (status == cAllOptional)
      status = cOK;
    if (status == cAllMandatory || status == cErrorMandatory)
		  status = cError;
    AddResult(status, xpath, 'Node <' + nodeName + '> missing');
  }

  return childNode;
}


//---------------------------------------------------------------------------------------------------------------------

function getAttributeCurrency(node, attributeName, reportStatus, xpath)
{
  var result = node.getAttribute(attributeName);

  if (result === undefined) {
    if (reportStatus == cErrorMandatory)
	    AddResult(cError, xpath, 'Attribute "' + attributeName + '" missing or empty');
  }
  else {
    var regEx = /^[A-Z]{3}$/;  // 3 alpha chars
    if (!result.match(regEx)) {
	    AddResult(cError, xpath, 'Content of attribute "' + attributeName + '" invalid: "' + result + '" (3 alpha chars expected)');
	    result = undefined;  // return only valid currencies
    }
  }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeText(parentNode, nodeName, reportStatus, xpath, minLen, maxLen)
{
  var status = reportStatus;
  var result = getNodeValue(parentNode, nodeName);

  if (result == '') {
		if (status == cErrorMandatory || status == cAllOptional || status == cAllMandatory) {
			status = (reportStatus == cAllOptional) ? cOK : cError;
			AddResult(status, xpath, 'Node <' + nodeName + '> missing or empty');
		}
  }
  else {
    var len = StrLen(result);
    if (len < minLen || (len > maxLen && maxLen > 0)) {
      var msg = 'Content of node <' + nodeName + '> invalid: "' + result + '" (';
      if (maxLen > 0)
        if (minLen == maxLen)
          msg = msg + minLen + ' chars expected)';
        else
          msg = msg + minLen + '-' + maxLen + ' chars expected)';
      else
        msg = msg + 'min ' + minLen + ' chars expected)';
      AddResult(cError, xpath, msg);
      result = '';  // do not return invalid values
    }
    else
      if (reportStatus == cAllOptional || reportStatus == cAllMandatory)
        AddResult(cOK, xpath, '<' + nodeName + '> = "' + result + '"');
  }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeCurrency(parentNode, nodeName, reportStatus, xpath)
{
  var status = reportStatus;
  var result = getNodeValue(parentNode, nodeName);

  if (result == '') {
		if (status == cErrorMandatory || status == cAllOptional || status == cAllMandatory) {
			status = (reportStatus == cAllOptional) ? cOK : cError;
			AddResult(status, xpath, 'Node <' + nodeName + '> missing or empty');
		}
		result = undefined;
  }
  else {
    var regEx = /^[A-Z]{3}$/;  // 3 alpha chars
    if (!result.match(regEx)) {
      var msg = 'Content of node <' + nodeName + '> invalid: "' + result + '" (3 alpha chars expected)';
      AddResult(cError, xpath, msg);
      result = undefined;  // do not return invalid values
    }
    else
      if ((result.substr(0,1) == result.substr(1,1) && result.substr(0,1) == result.substr(2,1)) || result == "ABC" || result == "XYZ") {
        AddResult(cError, xpath, 'Content of node <' + nodeName + '> invalid: "' + result + '" (not a valid currency)');
        //result = undefined;  // do not return invalid values
      }
      else
        if (aCurrencies.indexOf(result) < 0)
          AddResult(cWarning, xpath, 'Content of node <' + nodeName + '> maybe invalid: "' + result + '" (unknown currency)');
        else
          if (reportStatus == cAllOptional || reportStatus == cAllMandatory)
            AddResult(cOK, xpath, '<' + nodeName + '> = "' + result + '"');
  }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------


function IsValidIsin(isin)
{
  var regEx = /^[A-Z]{2}[0-9A-Z]{9}[0-9]{1}$/;  // ISIN = 2 alpha + 9 alphanumeric + 1 digit
  return isin.match(regEx);
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeIsin(parentNode, nodeName, reportStatus, xpath)
{
  var status = reportStatus;
  var result = getNodeValue(parentNode, nodeName);

  if (result == '') {
		if (status == cErrorMandatory || status == cAllOptional || status == cAllMandatory) {
			status = (reportStatus == cAllOptional) ? cOK : cError;
			AddResult(status, xpath, 'Node <' + nodeName + '> missing or empty');
		}
		result = undefined;
  }
  else {
    //var regEx = /^[A-Z]{2}[0-9A-Z]{9}[0-9]{1}$/;  // ISIN = 2 alpha + 9 alphanumeric + 1 digit
    //if (result.match(regEx)) {
    if (IsValidIsin(result)) {
      if (reportStatus == cAllOptional || reportStatus == cAllMandatory)
        AddResult(cOK, xpath, '<' + nodeName + '> = "' + result + '"');
    }
    else {
      var msg = 'Content of node <' + nodeName + '> invalid: "' + result + '" (not a valid ISIN)';
      AddResult(cError, xpath, msg);
      result = undefined;  // do not return invalid values
    }
  }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function isValidDate(dateString)
{
  var regEx = /^\d{4}-\d{2}-\d{2}$/;
  if (!dateString.match(regEx))
    return false;  // Invalid format
  var d = new Date(dateString);
  //if (Number.isNaN(d.getTime()))
  if (isNaN(d.getTime()))
    return false; // Invalid date
  return (d.toISOString().slice(0,10) === dateString);
}


//---------------------------------------------------------------------------------------------------------------------

function isValidDateTime(dateTimeString)
{
  var regEx = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/;
  if (!dateTimeString.match(regEx))
    return false;  // Invalid format
  var dateString = dateTimeString.substr(0,10);
  var d = new Date(dateString);
  //if (Number.isNaN(d.getTime()))
  if (isNaN(d.getTime()))
    return false; // Invalid date
  return (d.toISOString().slice(0,10) === dateString);
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeDate(parentNode, nodeName, reportStatus, xpath)
{
  var status = reportStatus;
  var result = getNodeValue(parentNode, nodeName);

  if (result == '') {
		if (status == cErrorMandatory || status == cAllOptional || status == cAllMandatory) {
			status = (reportStatus == cAllOptional) ? cOK : cError;
			AddResult(status, xpath, 'Node <' + nodeName + '> missing or empty');
		}
	result = undefined;
  }
  else {
	if (!isValidDate(result)) {
	  AddResult(cError, xpath, 'Content of node <' + nodeName + '> invalid: "' + result + '" (should be YYYY-MM-DD)');
	  result = undefined;
	}
	else
	  if (reportStatus == cAllOptional || reportStatus == cAllMandatory)
		AddResult(cOK, xpath, '<' + nodeName + '> = "' + result + '"');
  }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeDateTime(parentNode, nodeName, reportStatus, xpath)
{
  var status = reportStatus;
  var result = getNodeValue(parentNode, nodeName);

  if (result == '') {
		if (status == cErrorMandatory || status == cAllOptional || status == cAllMandatory) {
			status = (reportStatus == cAllOptional) ? cOK : cError;
			AddResult(status, xpath, 'Node <' + nodeName + '> missing or empty');
		}
	result = undefined;
  }
  else {
	if (!isValidDateTime(result)) {
	  AddResult(cError, xpath, 'Content of node <' + nodeName + '> invalid: "' + result + '" (should be YYYY-MM-DD T HH:MI:SS)');
	  result = undefined;
	}
	else
	  if (reportStatus == cAllOptional || reportStatus == cAllMandatory)
		AddResult(cOK, xpath, '<' + nodeName + '> = "' + result + '"');
  }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeItem(parentNode, nodeName, reportStatus, xpath, valueList)
{
  // valueList sample: "INITIAL,AMEND,DELETE"
  var status = reportStatus;
  var result = getNodeValue(parentNode, nodeName);

  if (result == '') {
		if (status == cErrorMandatory || status == cAllOptional || status == cAllMandatory) {
			status = (reportStatus == cAllOptional) ? cOK : cError;
			AddResult(status, xpath, 'Node <' + nodeName + '> missing or empty');
		}
	result = undefined;
  }
  else {
	var aValues = valueList.split(',');
	var index = aValues.indexOf(result);
	if (index < 0) {
	  var msg = 'Content of node <' + nodeName + '> invalid: "' + result + '" (not in "';
	  if (StrLen(valueList) > 64)
		msg = msg + valueList.substr(0,64) + ' ...")';
	  else
		msg = msg + valueList + '")';
	  AddResult(cError, xpath, msg);
	  result = undefined;  // return only valid content
	}
	else
	  if (reportStatus == cAllOptional || reportStatus == cAllMandatory)
		AddResult(cOK, xpath, '<' + nodeName + '> = "' + result + '"');
  }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeBoolean(parentNode, nodeName, reportStatus, xpath)
{
	var result;
  var status = reportStatus;
  var value = getNodeValue(parentNode, nodeName).toLowerCase();

  if (value == '') {
		if (status == cErrorMandatory || status == cAllOptional || status == cAllMandatory) {
			status = (reportStatus == cAllOptional) ? cOK : cError;
			AddResult(status, xpath, 'Node <' + nodeName + '> missing or empty');
		}
	result = undefined;
  }
  else {
	  status = cOK;
		if (value == 'true' || value == '1')
		  result = true;
		else
		  if (value == 'false' || value == '0')
				result = false;
			else
			  status = cError;

		if (status == cError)
	  AddResult(cError, xpath, 'Content of boolean node <' + nodeName + '> invalid: "' + value + '" (must be 0/1 or false/true)');
		else
	  if (reportStatus == cAllOptional || reportStatus == cAllMandatory)
		AddResult(cOK, xpath, '<' + nodeName + '> = "' + value + '"');
  }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeInteger(parentNode, nodeName, reportStatus, xpath, minValue, maxValue)
{
  var result;
  var status = reportStatus;
  var value = getNodeValue(parentNode, nodeName);

  if (value == '') {
		if (status == cErrorMandatory || status == cAllOptional || status == cAllMandatory) {
			status = (reportStatus == cAllOptional) ? cOK : cError;
			AddResult(status, xpath, 'Node <' + nodeName + '> missing or empty');
		}
    if (status == cError)
      result = undefined;
  }
  else {
		status = cOK;
		try {
			result = parseInt(value, 10);
		} catch (e) {
			status = cError;
		};

		if (status == cError || !Number.isInteger(result)) {
			AddResult(cError, xpath, 'Content of node <' + nodeName + '> invalid: "' + value + '" (not an integer value)');
			result = undefined;
		}

    if (status == cOK && result < minValue) {
			AddResult(cError, xpath, 'Content of node <' + nodeName + '> invalid: ' + value + ' is lower than minimum ' + minValue);
			result = undefined;
      status = cError;
    }

    if (status == cOK && result > maxValue) {
			AddResult(cError, xpath, 'Content of node <' + nodeName + '> invalid: ' + value + ' is bigger than maximum ' + maxValue);
			result = undefined;
      status = cError;
    }

		if (status == cOK && (reportStatus == cAllOptional || reportStatus == cAllMandatory))
			AddResult(cOK, xpath, '<' + nodeName + '> = "' + value + '"');
  }

	return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getNodeNumber(parentNode, nodeName, reportStatus, xpath, minValue)
{
  var result;
  var status = reportStatus;
  var value = getNodeValue(parentNode, nodeName);

  if (value == '') {
		if (status == cErrorMandatory || status == cAllOptional || status == cAllMandatory) {
			status = (reportStatus == cAllOptional) ? cOK : cError;
			AddResult(status, xpath, 'Node <' + nodeName + '> missing or empty');
		}
    if (status == cError)
      result = undefined;
  }
  else {
		if (isNaN(value))
			status = cError;
		else {
			status = cOK;
			try {
				result = Number(value);
			} catch (e) {
				status = cError;
			};
		}

		if (status == cOK && (reportStatus == cAllOptional || reportStatus == cAllMandatory)) {
			if (minValue != undefined)
				if (result < minValue) {
					AddResult(cError, xpath, 'Content of node <' + nodeName + '> invalid: ' + value + ' (lower limit ' + minValue + ')');
					status = cError;
				}
			if (status == cOK)
				AddResult(cOK, xpath, '<' + nodeName + '> = ' + value);
		}

		if (status == cError || isNaN(value)) {
			AddResult(cError, xpath, 'Content of node <' + nodeName + '> invalid: "' + value + '" (not a number)');
			result = undefined;
		}
  }

	return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getDataSupplier(parentNode, reportStatus, xpath)
{
  var dataSupplier;

  try {
	var node = parentNode.getElementsByTagName("DataSupplier")[0];
	if (node !== undefined) {
	  xpath = xpath + '/DataSupplier';
	  dataSupplier = new Object();
	  dataSupplier.systemCountry = getNodeText(node, "SystemCountry", reportStatus, xpath, 2, 2);
	  dataSupplier.short = getNodeText(node, "Short", reportStatus, xpath, 1, 64);
	  dataSupplier.name = getNodeText(node, "Name", reportStatus, xpath, 1, 256);
	  dataSupplier.type = getNodeText(node, "Type", reportStatus, xpath, 1, 64);
	}
  } catch (e) {
	//AddResult(cError, xpath, 'Mandatory node <DataSupplier> not found');
  };

  if (dataSupplier === undefined && (reportStatus == cErrorMandatory || reportStatus == cAllOptional || reportStatus == cAllMandatory)) {
		var status = (reportStatus == cAllOptional) ? cOK : cError;
	AddResult(status, xpath, 'Node <DataSupplier> missing');
	}

  return dataSupplier;
};


//---------------------------------------------------------------------------------------------------------------------

function getBloombergIdentifiers(parentNode, reportStatus, xpath)
{
  var result;
	var status;

  try {
    var node = parentNode.getElementsByTagName("Bloomberg")[0];
    if (node !== undefined) {
      var xpath2 = xpath + '/Bloomberg';
      result = new Object();
      result.ticker = getNodeText(node, "Ticker", reportStatus, xpath2, 0, 32);
			status = (reportStatus > cError) ? cError : reportStatus;
      result.exchange = getNodeText(node, "Exchange", status, xpath2, 0, 16);
      result.market = getNodeText(node, "Market", status, xpath2, 0, 16);
      result.bbgid = getNodeText(node, "BBGID", status, xpath2, 1, 12);
    }
  } catch (e) {
    //do nothing
  };

  return result;
};


//---------------------------------------------------------------------------------------------------------------------

var assetTypesIsin = ['EQ','BO','SC','CE'];
var assetTypesBloomberg = ['OP','FU'];

function getIdentifiers(parentNode, nodeName, reportStatus, assetType, xpath)
{
  var result;
	var status;
	var xpath2;

  try {
    var node = parentNode.getElementsByTagName(nodeName)[0];
    if (node !== undefined) {
      xpath2 = xpath + '/' + nodeName;
      result = new Object();

			status = (assetTypesIsin.indexOf(assetType) < 0) ? cError : cAllMandatory;
      result.isin = getNodeIsin(node, "ISIN", status, xpath2);
      if (StrLen(result.isin) == 0 && assetTypesIsin.indexOf(assetType) >= 0)
        AddResult(cWarning, xpath2, 'Node <ISIN> missing or invalid');

			status = (assetTypesBloomberg.indexOf(assetType) < 0) ? cError : cAllMandatory;
      result.bloomberg = getBloombergIdentifiers(node, status, xpath2);
      if (assetTypesBloomberg.indexOf(assetType) >= 0) {
        var ticker;
        if (result.bloomberg !== undefined)
          ticker = result.bloomberg.ticker;
        if (StrLen(ticker) == 0)
          AddResult(cWarning, xpath2, 'Node <Bloomberg/Ticker> missing or invalid');
      }

      result.cusip = getNodeText(node, "CUSIP", cError, xpath2, 9, 9);
      result.germanWKN = getNodeText(node, "GermanWKN", cError, xpath2, 6, 6);
      result.LEI = getNodeText(node, "LEI", cError, xpath2, 20, 20);
      result.mexID = getNodeText(node, "MexID", cError, xpath2, 1, 64);
      result.reutersRIC = getNodeText(node, "ReutersRIC", cError, xpath2, 1, 32);
      result.sedol = getNodeText(node, "SEDOL", cError, xpath2, 6, 6);
      result.swissValorenCode = getNodeInteger(node, "SwissValorenCode", cError, xpath2);
			result.swiftBIC = getNodeText(node, "SwiftBIC", cError, xpath2, 3, 12);

      if (StrLen(result.LEI) == 0 && StrLen(result.swiftBIC) == 0 && assetType == 'CO' && parentNode.nodeName == "Counterparty")
        AddResult(cWarning, xpath2, 'Nodes <LEI> and <SwiftBIC> missing or invalid (LEI or SwiftBIC should be filled)');

      // OtherID[ListedType]
      // OtherID[FreeType]
    }
  } catch (e) {
    //AddResult(cError, xpath, 'Mandatory node <' + nodeName + '> not found');
  };

  if (result === undefined && (reportStatus == cErrorMandatory || reportStatus == cAllMandatory))
    AddResult(status, xpath, 'Node <' + nodeName + '> missing');

  return result;
};


//---------------------------------------------------------------------------------------------------------------------

function getAddress(parentNode, reportStatus, xpath)
{
  var result;

  try {
    var node = parentNode.getElementsByTagName("Address")[0];
    if (node !== undefined) {
      var xpath2 = xpath + '/Address';
      result = new Object();
      result.streetName = getNodeText(node, "StreetName", cError, xpath2, 0, 256);
      result.streetNumber = getNodeText(node, "StreetNumber", cError, xpath2, 0, 32);
      result.building = getNodeText(node, "Building", cError, xpath2, 0, 256);
      result.cityName = getNodeText(node, "CityName", cError, xpath2, 0, 256);
      result.cityCode = getNodeText(node, "CityCode", cError, xpath2, 0, 32);
      result.state = getNodeText(node, "State", cError, xpath2, 0, 256);
      result.country = getNodeText(node, "Country", cErrorMandatory, xpath2, 2, 2);
      result.phone = getNodeText(node, "Phone", cError, xpath2, 0, 256);
      result.fax = getNodeText(node, "Fax", cError, xpath2, 0, 64);
      result.email = getNodeText(node, "Email", cError, xpath2, 0, 256);
      result.homepage = getNodeText(node, "Homepage", cError, xpath2, 0, 256);
    }
  } catch (e) {
    //do nothing
  };

  if (result === undefined && (reportStatus == cErrorMandatory || reportStatus == cAllMandatory))
    AddResult(status, xpath, 'Node <' + nodeName + '> missing');

  return result;
};


//---------------------------------------------------------------------------------------------------------------------

function getCompany(parentNode, nodeName, reportStatus, xpath)
{
  var result;

  try {
    var node = parentNode.getElementsByTagName(nodeName)[0];
    if (node !== undefined) {
      var xpath2 = xpath + '/' + nodeName;
      result = new Object();
      result.identifiers = getIdentifiers(node, "Identifiers", cErrorMandatory, "CO", xpath2);
      result.name = getNodeText(node, "Name", cErrorMandatory, xpath2, 1, 500);
      result.legalName = getNodeText(node, "LegalName", cError, xpath2, 0, 500);
      result.legalForm = getNodeText(node, "LegalForm", cError, xpath2, 0, 256);
      result.address = getAddress(node, cError, xpath2);
      result.businessCountry = getNodeText(node, "BusinessCountry", cError, xpath2, 2, 2);
      //TODO: ParentCompany
    }
  } catch (e) {
    //AddResult(cError, xpath, 'Mandatory node <' + nodeName + '> not found');
  };

  if (result === undefined && (reportStatus == cErrorMandatory || reportStatus == cAllMandatory))
    AddResult(cError, xpath, 'Node <' + nodeName + '> missing');

  return result;
};


//---------------------------------------------------------------------------------------------------------------------

function getNames(parentNode, reportStatus, xpath)
{
  var result;
	var nodeName = 'Names';

  try {
    var node = parentNode.getElementsByTagName(nodeName)[0];
    if (node !== undefined) {
      var xpath2 = xpath + '/' + nodeName;
      result = new Object();
      result.officialName = getNodeText(node, "OfficialName", cErrorMandatory, xpath2, 1, 500);
      result.fullName = getNodeText(node, "FullName", cError, xpath2, 0, 500);
      result.marketingForm = getNodeText(node, "MarketingName", cError, xpath2, 0, 500);
      result.shortName = getNodeText(node, "ShortName", cError, xpath2, 0, 100);
      result.previousName = getNodeText(node, "PreviousName", cError, xpath2, 0, 500);  // attribute "until"
      //result.dynLenNames = getDynLenNames(node, cError, xpath2);
      //result.languageNames = getLanguageNames(node, cError, xpath2);
    }
  } catch (e) {
    //AddResult(cError, xpath, 'Mandatory node <' + nodeName + '> not found');
  };

  if (result === undefined && (reportStatus == cErrorMandatory || reportStatus == cAllOptional || reportStatus == cAllMandatory)) {
		var status = (reportStatus == cAllOptional) ? cOK : cError;
    AddResult(cError, xpath, 'Mandatory node <' + nodeName + '> missing');
	}

  return result;
};


//---------------------------------------------------------------------------------------------------------------------

function getFiscalYear(parentNode, nodeName, reportStatus, xpath)
{
  var result;
  /*
  <EndOfFiscalYear>
    <Day>31</Day>
    <Month>12</Month>
  </EndOfFiscalYear>
  */
  try {
    var node = parentNode.getElementsByTagName(nodeName)[0];
    if (node !== undefined) {
      var xpath2 = xpath + '/' + nodeName;
      result = new Object();
      // getNodeInteger(parentNode, nodeName, reportStatus, xpath, minValue, maxValue);
      result.day = getNodeInteger(node, "Day", cErrorMandatory, xpath2, 1, 31);
      result.month = getNodeInteger(node, "Month", cErrorMandatory, xpath2, 1, 12);
    }
  } catch (e) {
    //AddResult(cError, xpath, 'Mandatory node <' + nodeName + '> not found');
  };

  if (result === undefined && (reportStatus == cErrorMandatory || reportStatus == cAllMandatory))
    AddResult(cError, xpath, 'Node <' + nodeName + '> missing');

  return result;
};


//---------------------------------------------------------------------------------------------------------------------

function getCcyAmount(parentNode, nodeName, ccy, reportStatus, xpath)
{
  /*
  <TotalValue>
    <Amount ccy="EUR">30484.14</Amount>
    <Amount ccy="USD">35971.29</Amount>
  </TotalValue>
  */
  var result;
  var xpath2;
  var attrCcy;
  var nodeAmounts = getFirstChildNode(parentNode, nodeName);

  if (nodeAmounts !== undefined) {
    xpath2 = xpath + '/' + nodeName;
    var nlAmount = nodeAmounts.getElementsByTagName("Amount");

    for (var i = 0; i < nlAmount.length; i++) {
      var nodeAmount = nlAmount[i];
      xpath2 = xpath + '/' + nodeName + '/Amount[' + i + ']';
      if (isNaN(nodeAmount.textContent))
        AddResult(cError, xpath2, 'Invalid node content: "' + nodeAmount.textContent + '" is not a number');
      else
		attrCcy = getAttributeCurrency(nodeAmount, "ccy", cErrorMandatory, xpath2);
		if (attrCcy == ccy)
		  result = Number(nodeAmount.textContent);
	}
  }

  if (result === undefined && (reportStatus == cErrorMandatory || reportStatus == cAllOptional || reportStatus == cAllMandatory)) {
		var status = (reportStatus == cAllOptional) ? cOK : cError;
    AddResult(cError, xpath, 'Mandatory node <' + nodeName + '/Amount[ccy="' + ccy + '"]> missing or invalid');
	}

  if (result !== undefined && (reportStatus == cAllOptional || reportStatus == cAllMandatory))
    AddResult(cOK, xpath, '<' + nodeName + '/Amount[ccy="' + ccy + '"]> = ' + result);

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getFxRates(parentNode, nodeName, fundCcy, assetCcy, reportStatus, xpath)
{
	/*
	<FXRates>
		<FXRate fromCcy="USD" toCcy="EUR" mulDiv="D">1.12345</FXRate>
	</FXRates>
	*/
  var result;
  var xpath2;
	var status;
  var value;
  var fromCcy;
	var toCcy;
	var mulDiv;
  var nodeFXRates = getFirstChildNode(parentNode, nodeName);

  if (nodeFXRates !== undefined) {
    xpath2 = xpath + '/' + nodeName;
    result = new Object();
    var nlFXRate = nodeFXRates.getElementsByTagName("FXRate");

    for (var i = 0; i < nlFXRate.length; i++) {
      var nodeFXRate = nlFXRate[i];
      xpath2 = xpath + '/' + nodeName + '/FXRate[' + i + ']';
			status = cOK;

      fromCcy = nodeFXRate.getAttribute("fromCcy");
			if (StrLen(fromCcy) != 3) {
        AddResult(cError, xpath2, 'Invalid content "' + fromCcy + '" in mandatory attribute "fromCcy"');
				status = cError;
			}

      toCcy = nodeFXRate.getAttribute("toCcy");
			if (StrLen(toCcy) != 3) {
        AddResult(cError, xpath2, 'Invalid content "' + toCcy + '" in mandatory attribute "toCcy"');
				status = cError;
			}

      mulDiv = nodeFXRate.getAttribute("mulDiv");
			if (mulDiv != "M" && mulDiv != "D") {
        AddResult(cError, xpath2, 'Invalid content "' + mulDiv + '" in mandatory attribute "mulDiv" (must be "M" or "D")');
				status = cError;
			}

      value = nodeFXRate.textContent;
      if (isNaN(value)) {
        AddResult(cError, xpath2, 'Invalid node content: "' + value + '" is not a number');
				status = cError;
			}

      if (status == cOK) {
        if (fromCcy == assetCcy && toCcy == fundCcy && mulDiv == "M")
          result.mulAssetToFund = Number(value);
        if (fromCcy == assetCcy && toCcy == fundCcy && mulDiv == "D")
          result.divAssetToFund = Number(value);
        if (fromCcy == fundCcy && toCcy == assetCcy && mulDiv == "M")
          result.mulFundToAsset = Number(value);
        if (fromCcy == fundCcy && toCcy == assetCcy && mulDiv == "D")
          result.divFundToAsset = Number(value);
      }
	}
  }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getCcyAmounts(parentNode, nodeName, fundCcy, assetCcy, reportStatus1, reportStatus2, xpath, errMinValueFC, errMaxValueFC, warnMinValueFC, warnMaxValueFC)
{
  /*
  <TotalValue>
		<Amount ccy="EUR">30484.14</Amount>
		<Amount ccy="USD">35971.29</Amount>
  </TotalValue>
  */
  var result;
  var valueFC;
  var valueAC;
	var valueEUR;
  var xpath2;
  var value;
  var ccy;
	var loadEuroValue = (fundCcy != 'EUR' && assetCcy != 'EUR');
  var nodeAmounts = getFirstChildNode(parentNode, nodeName);

  if (nodeAmounts !== undefined) {
    xpath2 = xpath + '/' + nodeName;
    result = new Object();
    var nlAmount = nodeAmounts.getElementsByTagName("Amount");

    for (var i = 0; i < nlAmount.length; i++) {
	    var nodeAmount = nlAmount[i];
	    xpath2 = xpath + '/' + nodeName + '/Amount[' + i + ']';
	    //ccy = nodeAmount.getAttribute("ccy");
	    ccy = getAttributeCurrency(nodeAmount, "ccy", cErrorMandatory, xpath2);
	    value = nodeAmount.textContent;
	    if (isNaN(value))
        AddResult(cError, xpath2, 'Invalid node content: "' + nodeAmount.textContent + '" is not a number [ccy="' + ccy + '"]');
	    else {
				value = Number(value);
        if (ccy == fundCcy) {
	        valueFC = value;
          // check lower limits for value in fund currency
          if (value < errMinValueFC)
						AddResult(cError, xpath2, 'Invalid ' + nodeName + ' in ' + ccy + ': ' + value + ' is less than mimimum ' + errMinValueFC);
          else
            if (value < warnMinValueFC)
						  AddResult(cWarning, xpath2, 'Strange ' + nodeName + ' in ' + ccy + ': ' + value + ' is less than ' + warnMinValueFC);
          // check upper limits for value in fund currency
          if (value > errMaxValueFC)
						AddResult(cError, xpath2, 'Invalid ' + nodeName + ' in ' + ccy + ': ' + value + ' is bigger than maximum ' + errMaxValueFC);
          else
            if (value > warnMaxValueFC)
						  AddResult(cWarning, xpath2, 'Strange ' + nodeName + ' in ' + ccy + ': ' + value + ' is bigger than ' + warnMaxValueFC);
        }
        if (ccy == assetCcy)
	        valueAC = value;
				if (loadEuroValue && ccy == 'EUR')
					valueEUR = value;
        // check lower limit for prices
				if (nodeName == "Price")
					if (value < 0)
						AddResult(cError, xpath2, 'Invalid price: "' + value + '" must be positive [ccy="' + ccy + '"]');
					else
						if (value == 0)
							AddResult(cWarning, xpath2, 'Unusual price: "' + value + '" is zero [ccy="' + ccy + '"]');
	    }
    }
  }

  if (valueFC === undefined && (reportStatus1 == cErrorMandatory || reportStatus1 == cAllOptional || reportStatus1 == cAllMandatory)) {
		var status = (reportStatus1 == cAllOptional) ? cOK : cError;
    AddResult(status, xpath, 'Mandatory node <' + nodeName + '/Amount[ccy="' + fundCcy + '"]> missing or invalid');
	}

  if (valueAC === undefined && (reportStatus2 == cErrorMandatory || reportStatus2 == cAllOptional || reportStatus2 == cAllMandatory)) {
		var status = (reportStatus2 == cAllOptional) ? cOK : cError;
    AddResult(status, xpath, 'Mandatory node <' + nodeName + '/Amount[ccy="' + assetCcy + '"]> missing or invalid');
	}

  if (valueFC !== undefined && (reportStatus1 == cAllOptional || reportStatus1 == cAllMandatory))
    AddResult(cOK, xpath, '<' + nodeName + '/Amount[ccy="' + fundCcy + '"]> = ' + valueFC);

  if (valueAC !== undefined && (reportStatus2 == cAllOptional || reportStatus2 == cAllMandatory))
    AddResult(cOK, xpath, '<' + nodeName + '/Amount[ccy="' + assetCcy + '"]> = ' + valueAC);

	if (nodeName != 'PurchaseValue') {
		if (valueFC !== undefined && valueAC !== undefined && fundCcy != assetCcy) {
			var fxRate = getFxRate(assetCcy, fundCcy);
			var estValueFC = valueAC / fxRate;
			var percDiff = ((valueFC - estValueFC) / estValueFC) * 100;
			if (Math.abs(percDiff) >= fxRatePercentageError || (valueFC == valueAC && valueFC != 0 && valueFC != 0))
				AddResult(cError, xpath + '/' + nodeName, 'Wrong fx-rate between ' + assetCcy + ' ' + valueAC + ' and ' + fundCcy + ' ' + valueFC + ' (' + setDigits(valueAC / valueFC, 6) + ' instead of ~' + setDigits(fxRate,6) + ')');
			else
				if (Math.abs(percDiff) >= fxRatePercentageWarning)
					AddResult(cWarning, xpath + '/' + nodeName, 'Strange fx-rate between ' + assetCcy + ' ' + valueAC + ' and ' + fundCcy + ' ' + valueFC + ' (' + setDigits(valueAC / valueFC, 6) + ' instead of ~' + setDigits(fxRate,6) + ')');
		}

		if (loadEuroValue && valueEUR !== undefined) {
			if (valueFC !== undefined) {
				var fxRate = getFxRate(valueFC, 'EUR');
				var estValueEUR = valueFC / fxRate;
				var percDiff = ((valueEUR - estValueEUR) / estValueEUR) * 100;
				if (Math.abs(percDiff) >= fxRatePercentageError || (valueFC == valueEUR && valueFC != 0 && valueEUR != 0))
					AddResult(cError, xpath + '/' + nodeName, 'Wrong fx-rate between ' + fundCcy + ' ' + valueFC + ' and EUR ' + valueEUR + ' (' + setDigits(valueFC / valueEUR, 6) + ' instead of ~' + setDigits(fxRate,6) + ')');
				else
					if (Math.abs(percDiff) >= fxRatePercentageWarning)
						AddResult(cWarning, xpath + '/' + nodeName, 'Strange fx-rate between ' + fundCcy + ' ' + valueFC + ' and EUR ' + valueEUR + ' (' + setDigits(valueFC / valueEUR, 6) + ' instead of ~' + setDigits(fxRate,6) + ')');
			}

			if (valueAC !== undefined) {
				var fxRate = getFxRate(valueAC, 'EUR');
				var estValueEUR = valueAC / fxRate;
				var percDiff = ((valueEUR - estValueEUR) / estValueEUR) * 100;
				if (Math.abs(percDiff) >= fxRatePercentageError || (valueAC == valueEUR && valueAC != 0 && valueEUR != 0))
					AddResult(cError, xpath + '/' + nodeName, 'Wrong fx-rate between ' + assetCcy + ' ' + valueAC + ' and EUR ' + valueEUR + ' (' + setDigits(valueAC / valueEUR, 6) + ' instead of ~' + setDigits(fxRate,6) + ')');
				else
					if (Math.abs(percDiff) >= fxRatePercentageWarning)
						AddResult(cWarning, xpath + '/' + nodeName, 'Strange fx-rate between ' + assetCcy + ' ' + valueAC + ' and EUR ' + valueEUR + ' (' + setDigits(valueAC / valueEUR, 6) + ' instead of ~' + setDigits(fxRate,6) + ')');
			}
		}
	}

  if (valueFC !== undefined)
    result.valueFC = valueFC;
  if (valueAC !== undefined)
    result.valueAC = valueAC;
  if (valueEUR !== undefined)
    result.valueEUR = valueEUR;

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getExposures(parentNode, nodeName1, nodeName2, fundCcy, assetCcy, reportStatus1, reportStatus2, xpath, errMaxValueFC, warnMaxValueFC)
{
  /*
  <Exposures>
    <Exposure>
      <Type>Commitment Method</Type>
      <Value>
		    <Amount ccy="EUR">30484.14</Amount>
		    <Amount ccy="USD">35971.29</Amount>
      </Value>
    </Exposure>
  </Exposures>
  */
  var result;
  var xpath2;
  var nodeExposures = getFirstChildNode(parentNode, nodeName1);

  if (nodeExposures !== undefined) {
    xpath2 = xpath + '/' + nodeName1;
    result = new Array();
    var nlExposure = nodeExposures.getElementsByTagName(nodeName2);

    for (var i = 0; i < nlExposure.length; i++) {
	    var nodeExposure = nlExposure[i];
	    xpath2 = xpath + '/' + nodeName1 + '/' + nodeName2 + '[' + i + ']';
      var exposure = new Object();
      exposure.type = getNodeText(nodeExposure, "Type", cErrorMandatory, xpath2, 1, 0);
      exposure.value = getCcyAmounts(nodeExposure, "Value", fundCcy, assetCcy, reportStatus1, reportStatus2, xpath2, 0 - errMaxValueFC, errMaxValueFC, 0 - warnMaxValueFC, warnMaxValueFC);
      result.push(exposure);
    }
  }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function getTotalAssetValues(parentNode, contentDate, fundIndex, reportStatus, xpath)
{
  var fundVolume;
  var xpath2;
  var nodeTotalAssetValue;
  var navDate;
  var navNature;
  /*
  <TotalAssetValues>
    <TotalAssetValue>
      <NavDate>2017-08-12</NavDate>
      <TotalAssetNature>OFFICIAL</TotalAssetNature>
      <TotalNetAssetValue>
        <Amount ccy="EUR">901067.30</Amount>
      </TotalNetAssetValue>
    </TotalAssetValue>
  </TotalAssetValues>
  */

  var nodeTotalAssetValues = getFirstChildNode(parentNode, "TotalAssetValues");

  if (nodeTotalAssetValues !== undefined) {
    xpath2 = xpath + '/TotalAssetValues';
    nlTotalAssetValue = nodeTotalAssetValues.getElementsByTagName("TotalAssetValue");

    for (var i = 0; i < nlTotalAssetValue.length; i++) {
      nodeTotalAssetValue = nlTotalAssetValue[i];
      xpath2 = xpath + '/TotalAssetValues/TotalAssetValue[' + i + ']';

      navDate = getNodeDate(nodeTotalAssetValue, "NavDate", cErrorMandatory, xpath2);
      navNature = getNodeItem(nodeTotalAssetValue, "TotalAssetNature", cErrorMandatory, xpath2, "OFFICIAL,ESTIMATED,TECHNICAL");

      if (navDate == contentDate && navNature == "OFFICIAL")
        aFunds[fundIndex].fundVolume = getCcyAmount(nodeTotalAssetValue, "TotalNetAssetValue", aFunds[fundIndex].ccy, reportStatus, xpath2);

      if (navDate == contentDate && navNature == "ESTIMATED")
        aFunds[fundIndex].fundVolumeEstimated = getCcyAmount(nodeTotalAssetValue, "TotalNetAssetValue", aFunds[fundIndex].ccy, cError, xpath2);

      if (navDate == contentDate && navNature == "TECHNICAL")
        aFunds[fundIndex].fundVolumeTechnical = getCcyAmount(nodeTotalAssetValue, "TotalNetAssetValue", aFunds[fundIndex].ccy, cError, xpath2);
    }
  }

  return fundVolume;
}


//---------------------------------------------------------------------------------------------------------------------

function getTotalAssetValuesSC(parentNode, ccy, reportStatus, xpath)
{
  var result;
  var xpath2;
  var nodeTotalAssetValue;
  var navDate;
  var navNature;
  /*
  <TotalAssetValues>
    <TotalAssetValue>
      <NavDate>2017-08-12</NavDate>
      <TotalAssetNature>OFFICIAL</TotalAssetNature>
      <TotalNetAssetValue>
        <Amount ccy="EUR">901067.30</Amount>
      </TotalNetAssetValue>
    </TotalAssetValue>
  </TotalAssetValues>
  */

  var nodeTotalAssetValues = getFirstChildNode(parentNode, "TotalAssetValues");

  if (nodeTotalAssetValues !== undefined) {
    xpath2 = xpath + '/TotalAssetValues';
    result = new Object();
    nlTotalAssetValue = nodeTotalAssetValues.getElementsByTagName("TotalAssetValue");

    for (var i = 0; i < nlTotalAssetValue.length; i++) {
      nodeTotalAssetValue = nlTotalAssetValue[i];
      xpath2 = xpath + '/TotalAssetValues/TotalAssetValue[' + i + ']';

      navDate = getNodeDate(nodeTotalAssetValue, "NavDate", cErrorMandatory, xpath2);
      navNature = getNodeItem(nodeTotalAssetValue, "TotalAssetNature", cErrorMandatory, xpath2, "OFFICIAL,ESTIMATED,TECHNICAL");

      if (navDate == contentDate && navNature == "OFFICIAL") {
        result.volume = getCcyAmount(nodeTotalAssetValue, "TotalNetAssetValue", ccy, reportStatus, xpath2);
        result.sharesOutstanding = getNodeNumber(nodeTotalAssetValue, "SharesOutstanding", cError, xpath2);
        result.ratio = getNodeNumber(nodeTotalAssetValue, "Ratio", cError, xpath2);
      }
    }
  }

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

// AssetTypes: "EQ,BO,SC,WA,CE,OP,FU,FX,SW,RP,FT,CM,AC,FE,RE,RT,LO,RI"

var aAssetTypesNegValue = ["OP","FU","FX","SW","AC","FE"];
var aAssetTypesDerivatives = ["OP","FU","FX","SW"];


function getPortfolios(parentNode, contentDate, fundIndex, reportStatus, xpath)
{
  /*
	<Portfolios>
		<Portfolio>
			<NavDate>2016-09-30</NavDate>
			<Positions>
				<Position>
					<UniqueID>AK279855</UniqueID>
					<Identifiers>
						<ISIN>US0028241000</ISIN>
					</Identifiers>
					<Currency>USD</Currency>
					<TotalValue>
						<Amount ccy="EUR">104951.57</Amount>
						<Amount ccy="USD">117855.36</Amount>
					</TotalValue>
					<Equity>
						<Units>2844.00</Units>
						<Price>
							<Amount ccy="USD">41.44</Amount>
						</Price>
					</Equity>
				</Position>
  */
  var fundCcy = aFunds[fundIndex].ccy;
  var nodePortfolios;
  var nlPortfolio;
  var nodePortfolio;
  var nodeInstrument;
  var asset;
  var navDate;
  var xpath2;
  var xpath3;
  var status;
  var countOK;
  var countWarning;
  var countError;
  var posSum;
  var absDifference;
  var relDifference;
	var calcTotalPercentage;
	var calcTotalValueFC;
  var errMaxValueFC;
  var warnMaxValueFC;
  var errorText;

  //aFunds[fundIndex].positions = new Array();
  //aFunds[fundIndex].ccySums = new Array();
  //aFunds[fundIndex].ccyFxHedges = new Array();
  var portfolio = new Object();
  portfolio.positions = new Array();
  portfolio.ccySums = new Array();
  portfolio.ccyFxHedges = new Array();
  portfolio.transactions = new Array();
  portfolio.earnings = new Array();
  portfolio.breakDowns = new Array();
  portfolio.riskCodes = new Array();

  currentModule = modPortfolios;
  currentUniqueID = undefined;

  aFunds[fundIndex].portfolioIndex = aPortfolios.length;

  nodePortfolios = getFirstChildNode(parentNode, "Portfolios");
  if (nodePortfolios !== undefined) {
    xpath2 = xpath + '/Portfolios';
    nlPortfolio = nodePortfolios.getElementsByTagName("Portfolio");

    for (var indexPortfolio = 0; indexPortfolio < nlPortfolio.length; indexPortfolio++) {
      nodePortfolio = nlPortfolio[indexPortfolio];
      xpath2 = xpath + '/Portfolios/Portfolio[' + indexPortfolio + ']';
      navDate = getNodeDate(nodePortfolio, "NavDate", cErrorMandatory, xpath2);

      if (navDate == contentDate) {
        //------------------------------------------------------------------------------------------------------------
        // POSITIONS
        //
        var nodePositions = getFirstChildNode(nodePortfolio, "Positions");

        if (nodePositions !== undefined) {
          currentModule = modHoldings;
          xpath2 = xpath + '/Portfolios/Portfolio[' + indexPortfolio + ']/Positions';
          countOK = 0;
          countWarning = 0;
          countError = 0;
          posSum = 0;
          var nlPosition = nodePositions.getElementsByTagName("Position");

          for (var indexPosition = 0; indexPosition < nlPosition.length; indexPosition++) {
            var nodePosition = nlPosition[indexPosition];
            var position = new Object();
            currentUniqueID = undefined;
            currentStatus = cOK;

            xpath2 = xpath + '/Portfolios/Portfolio[' + indexPortfolio + ']/Positions/Position[' + indexPosition + ']';
            position.uniqueID = getNodeText(nodePosition, "UniqueID", cErrorMandatory, xpath2);
            currentUniqueID = position.uniqueID;
            position.assetIndex = getAssetMasterDataIndex(position.uniqueID);

            if (position.assetIndex === undefined) {
              AddResult(cError, xpath2, 'Missing AssetMasterData for UniqueID "' + asset.uniqueID + '"');
            }
            else {
              asset = aAssetMasterData[position.assetIndex];
              position.identifiers = getIdentifiers(nodePosition, "Identifiers", cError, asset.assetType, xpath2);

              position.ccy = getNodeCurrency(nodePosition, "Currency", cError, xpath2);
              if (position.ccy != aAssetMasterData[position.assetIndex].ccy && asset.assetType != "FX" /*FXForward*/)
                AddResult(cWarning, xpath2, 'Currency in AssetMasterData "' + asset.ccy + '" different to currency in position "' + position.ccy + '"');
              //position.ccy = aAssetMasterData[position.assetIndex].ccy;  // overwite local position currency with currency in AssetMasterData

							if (position.identifiers !== undefined)
								if (position.identifiers.isin !== undefined && asset.identifiers.isin !== undefined && position.identifiers.isin != asset.identifiers.isin)
									AddResult(cError, xpath2, 'ISIN in AssetMasterData "' + asset.identifiers.isin + '" different to ISIN in position "' + position.identifiers.isin + '"');

              position.assetType = asset.assetType;              
              position.totalValue = getCcyAmounts(nodePosition, "TotalValue", fundCcy, position.ccy, cAllMandatory, cError, xpath2);
              position.totalPercentage = getNodeNumber(nodePosition, "TotalPercentage", cError, xpath2);
							position.calcTotalPercentage = (position.totalValue.valueFC / aFunds[fundIndex].fundVolume) * 100;

							if (position.totalPercentage !== undefined) {
								calcTotalValueFC = (aFunds[fundIndex].fundVolume * position.totalPercentage) * 0.01;
								absDifference = Math.abs(calcTotalValueFC - position.totalValue.valueFC);
								if (absDifference >= 1000)
									AddResult(cError, xpath2, 'TotalPercentage should be ' + position.calcTotalPercentage + ' instead of ' + position.totalPercentage + ' (' + position.totalValue.valueFC + ' of ' + aFunds[fundIndex].fundVolume + ', difference bigger than ' + fundCcy + ' 1000)');
								else
									if (absDifference >= 10)
										AddResult(cWarning, xpath2, 'TotalPercentage should be ' + position.calcTotalPercentage + ' instead of ' + position.totalPercentage + ' (' + position.totalValue.valueFC + ' of ' + aFunds[fundIndex].fundVolume + ', difference bigger than ' + fundCcy + ' 10)');
							}

							if (Math.abs(position.calcTotalPercentage) > 120)
								AddResult(cError, xpath2, 'TotalPercentage ' + position.calcTotalPercentage + ' is too big (' + position.totalValue.valueFC + ' of ' + aFunds[fundIndex].fundVolume + ' is more than 120%)');
							else
								if (Math.abs(position.calcTotalPercentage) > 20)
									AddResult(cWarning, xpath2, 'TotalPercentage ' + position.calcTotalPercentage + ' is too big (' + position.totalValue.valueFC + ' of ' + aFunds[fundIndex].fundVolume + ' is more than 20%)');

							//var aAssetTypesNegValue = ["OP","FU","FX","SW","AC","FE"];
							if (aAssetTypesNegValue.indexOf(asset.assetType) < 0 && position.totalValue.valueFC < 0)
								AddResult(cError, xpath2, 'Negative TotalValue ' + position.totalValue.valueFC + ' not allowed for asset type ' + asset.assetType);

              position.averagePurchasePrice = getCcyAmounts(nodePosition, "AveragePurchasePrice", fundCcy, position.ccy, cError, cError, xpath2);
              position.averagePurchaseFxRate = getFxRates(nodePosition, "AveragePurchaseFxRate", fundCcy, position.ccy, cError, xpath2);

              // check exposure values
              if (aAssetTypesDerivatives.indexOf(asset.assetType) >= 0) {
                // maximum exposure values for derivative positions
                errMaxValueFC = aFunds[fundIndex].fundVolume;
                warnMaxValueFC = errMaxValueFC * 0.5;
              }
              else {
                // maximum exposure values for non-derivative positions
                errMaxValueFC = position.totalValue.valueFC * 2.2;
                warnMaxValueFC = position.totalValue.valueFC * 1.1;
              }
              position.exposures = getExposures(nodePosition, "Exposures", "Exposure", fundCcy, position.ccy, cError, cError, xpath2, errMaxValueFC, warnMaxValueFC);

						  position.fxRates = getFxRates(nodePosition, "FXRates", fundCcy, position.ccy, cError, xpath2);
              // "PricingSource"

              if (asset.assetType == "EQ" /*Equity*/) {
                nodeInstrument = GetChildNode(nodePosition, "Equity", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Equity';
                  position.units = getNodeNumber(nodeInstrument, "Units", cAllMandatory, xpath3);
                  position.price = getCcyAmounts(nodeInstrument, "Price", fundCcy, position.ccy, cError, cError, xpath3);
                  // "OtherPrices"
                  position.marketValue = getCcyAmounts(nodeInstrument, "MarketValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.bookRate = getCcyAmounts(nodeInstrument, "BookRate", fundCcy, position.ccy, cError, cError, xpath3);
                  position.purchaseValue = getCcyAmounts(nodeInstrument, "PurchaseValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.dividendsDue = getCcyAmounts(nodeInstrument, "DividendsDue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.lended = getNodeBoolean(nodeInstrument, "LendedFlag", cError, xpath3);
                  position.lendedUnits = getNodeNumber(nodeInstrument, "LendedUnits", cError, xpath3);
                  position.raffled = getNodeBoolean(nodeInstrument, "IndicatorRaffled", cError, xpath3);

									if (position.units < 0)
										AddResult(cError, xpath2, 'Negative units ' + position.units + ' not allowed for equities');
								}
				      }

              if (asset.assetType == "BO" /*Bond*/) {
                nodeInstrument = GetChildNode(nodePosition, "Bond", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Bond';
                  position.nominal = getNodeNumber(nodeInstrument, "Nominal", cAllMandatory, xpath3);
                  position.units = position.nominal;  // for easier access
                  position.originalFace = getNodeNumber(nodeInstrument, "OriginalFace", cError, xpath3);
                  position.price = getCcyAmounts(nodeInstrument, "Price", fundCcy, position.ccy, cError, cError, xpath3);
                  // "OtherPrices"
                  position.dirtyPrice = getCcyAmounts(nodeInstrument, "DirtyPrice", fundCcy, position.ccy, cError, cError, xpath3);
                  position.marketValue = getCcyAmounts(nodeInstrument, "MarketValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.interestClaimNet = getCcyAmounts(nodeInstrument, "InterestClaimNet", fundCcy, position.ccy, cError, cError, xpath3);
                  position.interestClaimGross = getCcyAmounts(nodeInstrument, "InterestClaimGross", fundCcy, position.ccy, cError, cError, xpath3);
                  position.accruedInterestDays = getNodeNumber(nodeInstrument, "AccruedInterestDays", cError, xpath3);
                  position.zeroBondInterestClaimNet = getCcyAmounts(nodeInstrument, "ZeroBondInterestClaimNet", fundCcy, position.ccy, cError, cError, xpath3);
                  position.zeroBondInterestClaimGross = getCcyAmounts(nodeInstrument, "ZeroBondInterestClaimGross", fundCcy, position.ccy, cError, cError, xpath3);
                  position.zeroBondCapitalYieldsTaxClaim = getCcyAmounts(nodeInstrument, "ZeroBondCapitalYieldsTaxClaim", fundCcy, position.ccy, cError, cError, xpath3);
                  position.zeroBondYield = getNodeNumber(nodeInstrument, "ZeroBondYield", cError, xpath3);
                  position.indexfactor = getNodeNumber(nodeInstrument, "Indexfactor", cError, xpath3);
                  position.poolfactor = getNodeNumber(nodeInstrument, "Poolfactor", cError, xpath3);
                  position.bookRate = getCcyAmounts(nodeInstrument, "BookRate", fundCcy, position.ccy, cError, cError, xpath3);
                  position.purchaseValue = getCcyAmounts(nodeInstrument, "PurchaseValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.acrualIndexedBond = getNodeBoolean(nodeInstrument, "AcrualIndexedBond", cError, xpath3);
                  position.dateLastCouponPayment = getNodeDate(nodeInstrument, "DateLastCouponPayment", cError, xpath3);
                  position.lended = getNodeBoolean(nodeInstrument, "LendedFlag", cError, xpath3);
                  position.lendedUnits = getNodeNumber(nodeInstrument, "LendedUnits", cError, xpath3);
                  position.raffled = getNodeBoolean(nodeInstrument, "IndicatorRaffled", cError, xpath3);
                  position.collateralValue = getCcyAmounts(nodeInstrument, "CollateralValue", fundCcy, position.ccy, cError, cError, xpath3);

									if (position.nominal < 0)
										AddResult(cError, xpath2, 'Negative nominal ' + position.nominal + ' not allowed for bonds');
					      }
				      }

              if (asset.assetType == "SC" /*ShareClass*/) {
                nodeInstrument = GetChildNode(nodePosition, "ShareClass", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/ShareClass';
                  position.shares = getNodeNumber(nodeInstrument, "Shares", cAllMandatory, xpath3);
                  position.units = position.shares;  // for easier access
                  position.price = getCcyAmounts(nodeInstrument, "Price", fundCcy, position.ccy, cError, cError, xpath3);
                  // "OtherPrices"
                  position.bookRate = getCcyAmounts(nodeInstrument, "BookRate", fundCcy, position.ccy, cError, cError, xpath3);
                  position.purchaseValue = getCcyAmounts(nodeInstrument, "PurchaseValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.dividendsDue = getCcyAmounts(nodeInstrument, "DividendsDue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.lended = getNodeBoolean(nodeInstrument, "LendedFlag", cError, xpath3);
                  position.lendedUnits = getNodeNumber(nodeInstrument, "LendedUnits", cError, xpath3);
                  position.raffled = getNodeBoolean(nodeInstrument, "IndicatorRaffled", cError, xpath3);

									if (position.shares < 0)
										AddResult(cError, xpath2, 'Negative shares ' + position.shares + ' not allowed for equities');
					      }
				      }

              if (asset.assetType == "WA" /*Warrant*/) {
                nodeInstrument = GetChildNode(nodePosition, "Warrant", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Warrant';
                  position.units = getNodeNumber(nodeInstrument, "Units", cAllMandatory, xpath3);
                  position.price = getCcyAmounts(nodeInstrument, "Price", fundCcy, position.ccy, cError, cError, xpath3);
                  // "OtherPrices"
                  position.bookRate = getCcyAmounts(nodeInstrument, "BookRate", fundCcy, position.ccy, cError, cError, xpath3);
                  position.purchaseValue = getCcyAmounts(nodeInstrument, "PurchaseValue", fundCcy, position.ccy, cError, cError, xpath3);

									if (position.units < 0)
										AddResult(cError, xpath2, 'Negative units ' + position.units + ' not allowed for warrants');
					      }
				      }

              if (asset.assetType == "CE" /*Certificate*/) {
                nodeInstrument = GetChildNode(nodePosition, "Certificate", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Certificate';
                  position.units = getNodeNumber(nodeInstrument, "Units", cAllMandatory, xpath3);
                  position.lended = getNodeBoolean(nodeInstrument, "LendedFlag", cError, xpath3);
                  position.lendedUnits = getNodeNumber(nodeInstrument, "LendedUnits", cError, xpath3);

									if (position.units < 0)
										AddResult(cError, xpath2, 'Negative units ' + position.units + ' not allowed for certificates');
					      }
				      }

              if (asset.assetType == "OP" /*Option*/) {
                nodeInstrument = GetChildNode(nodePosition, "Option", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Option';
                  position.contracts = getNodeNumber(nodeInstrument, "Contracts", cAllMandatory, xpath3);
                  position.units = position.contracts;  // for easier access
                  position.price = getCcyAmounts(nodeInstrument, "Price", fundCcy, position.ccy, cError, cError, xpath3);
                  // "OtherPrices"
                  position.bookRate = getCcyAmounts(nodeInstrument, "BookRate", fundCcy, position.ccy, cError, cError, xpath3);
                  position.purchaseValue = getCcyAmounts(nodeInstrument, "PurchaseValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.hedgeRatio = getNodeNumber(nodeInstrument, "HedgeRatio", cError, xpath3);  // percentage
					      }
				      }

              if (asset.assetType == "FU" /*Future*/) {
                nodeInstrument = GetChildNode(nodePosition, "Future", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Future';
                  position.contracts = getNodeNumber(nodeInstrument, "Contracts", cAllMandatory, xpath3);
									if (Math.abs(position.contracts) >= 50)
										AddResult(cWarning, xpath3, 'Unusual high number of contracts ' + position.contracts);
                  position.units = position.contracts;  // for easier access
                  position.price = getCcyAmounts(nodeInstrument, "Price", fundCcy, position.ccy, cError, cError, xpath3);
                  // "OtherPrices"
                  position.prelProfitLoss = getCcyAmounts(nodeInstrument, "PrelProfitLoss", fundCcy, position.ccy, cError, cError, xpath3);
                  position.bookRate = getCcyAmounts(nodeInstrument, "BookRate", fundCcy, position.ccy, cError, cError, xpath3);
                  position.variationMarginDaily = getCcyAmounts(nodeInstrument, "VariationMarginDaily", fundCcy, position.ccy, cError, cError, xpath3);
                  position.variationMarginOverall = getCcyAmounts(nodeInstrument, "VariationMarginOverall", fundCcy, position.ccy, cError, cError, xpath3);
                  position.hedgeRatio = getNodeNumber(nodeInstrument, "HedgeRatio", cError, xpath3);  // percentage
					      }
				      }

              if (asset.assetType == "FX" /*FXForward*/) {
                nodeInstrument = GetChildNode(nodePosition, "FXForward", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/FXForward';
                  position.hedgeRatio = getNodeNumber(nodeInstrument, "HedgeRatio", cError, xpath3);  // percentage
                  position.fxRateForEvaluation = getNodeNumber(nodeInstrument, "FxRateForEvaluation", cError, xpath3);
					      }
				      }

              if (asset.assetType == "SW" /*Swap*/) {
                nodeInstrument = GetChildNode(nodePosition, "Swap", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Swap';
                  position.hedgeRatio = getNodeNumber(nodeInstrument, "HedgeRatio", cError, xpath3);  // percentage
                  position.currentSpread = getNodeNumber(nodeInstrument, "CurrentSpread", cError, xpath3);
                  position.presentValueOfPayments = getCcyAmounts(nodeInstrument, "PresentValueOfPayments", fundCcy, position.ccy, cError, cError, xpath3);
                  // "LegValues"
					      }
				      }

              if (asset.assetType == "RP" /*Repo*/) {
                nodeInstrument = GetChildNode(nodePosition, "Repo", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Repo';
                  // this node must be empty!
					      }
				      }

              if (asset.assetType == "FT" /*FixedTimeDeposit*/) {
                nodeInstrument = GetChildNode(nodePosition, "FixedTimeDeposit", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/FixedTimeDeposit';
                  position.marketValue = getCcyAmounts(nodeInstrument, "MarketValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.interests = getCcyAmounts(nodeInstrument, "Interests", fundCcy, position.ccy, cError, cError, xpath3);
					      }
				      }

              if (asset.assetType == "CM" /*CallMoney*/) {
                nodeInstrument = GetChildNode(nodePosition, "CallMoney", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/CallMoney';
                  position.marketValue = getCcyAmounts(nodeInstrument, "MarketValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.interests = getCcyAmounts(nodeInstrument, "Interests", fundCcy, position.ccy, cError, cError, xpath3);
                  position.collateralValue = getCcyAmounts(nodeInstrument, "CollateralValue", fundCcy, position.ccy, cError, cError, xpath3);
					      }
				      }

              if (asset.assetType == "AC" /*Account*/) {
                nodeInstrument = GetChildNode(nodePosition, "Account", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Account';
                  position.marketValue = getCcyAmounts(nodeInstrument, "MarketValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.interests = getCcyAmounts(nodeInstrument, "Interests", fundCcy, position.ccy, cError, cError, xpath3);
					      }
				      }

              if (asset.assetType == "FE" /*Fee*/) {
                nodeInstrument = GetChildNode(nodePosition, "Fee", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Fee';
                  // this node must be empty!
					      }
				      }

              if (asset.assetType == "RE" /*RealEstate*/) {
                nodeInstrument = GetChildNode(nodePosition, "RealEstate", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/RealEstate';
                  position.marketValue = getCcyAmounts(nodeInstrument, "MarketValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.rentIncome = getCcyAmounts(nodeInstrument, "RentIncome", fundCcy, position.ccy, cError, cError, xpath3);
                  position.rentAccruals = getCcyAmounts(nodeInstrument, "RentAccruals", fundCcy, position.ccy, cError, cError, xpath3);
                  // ...
					      }
				      }

              if (asset.assetType == "RE" /*REIT*/) {
                nodeInstrument = GetChildNode(nodePosition, "REIT", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/REIT';
                  position.units = getNodeNumber(nodeInstrument, "Units", cAllMandatory, xpath3);
                  position.price = getCcyAmounts(nodeInstrument, "Price", fundCcy, position.ccy, cError, cError, xpath3);
                  // "OtherPrices"
                  position.marketValue = getCcyAmounts(nodeInstrument, "MarketValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.purchaseValue = getCcyAmounts(nodeInstrument, "PurchaseValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.dividendsDue = getCcyAmounts(nodeInstrument, "DividendsDue", fundCcy, position.ccy, cError, cError, xpath3);
					      }
				      }

              if (asset.assetType == "LO" /*Loan*/) {
                nodeInstrument = GetChildNode(nodePosition, "Loan", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Loan';
                  position.marketValue = getCcyAmounts(nodeInstrument, "MarketValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.interestAccruals = getCcyAmounts(nodeInstrument, "InterestAccruals", fundCcy, position.ccy, cError, cError, xpath3);
					      }
				      }

              if (asset.assetType == "RI" /*Right*/) {
                nodeInstrument = GetChildNode(nodePosition, "Right", cErrorMandatory, xpath2);
                if (nodeInstrument !== undefined) {
                  xpath3 = xpath2 + '/Right';
                  position.units = getNodeNumber(nodeInstrument, "Units", cAllMandatory, xpath3);
                  position.price = getCcyAmounts(nodeInstrument, "Price", fundCcy, position.ccy, cError, cError, xpath3);
                  // "OtherPrices"
                  position.marketValue = getCcyAmounts(nodeInstrument, "MarketValue", fundCcy, position.ccy, cError, cError, xpath3);
                  position.purchaseValue = getCcyAmounts(nodeInstrument, "PurchaseValue", fundCcy, position.ccy, cError, cError, xpath3);
					      }
				      }

              position.capitalYieldsTaxClaim = getCcyAmounts(nodeInstrument, "CapitalYieldsTaxClaim", fundCcy, position.ccy, cError, cError, xpath2);
              position.inflationaryAdjustment = getNodeNumber(nodeInstrument, "InflationaryAdjustment", cError, xpath2);  // percentage
              // "RiskCodes"
              // "Underlyings"
              // "CustomAttributes"

              portfolio.positions.push(position);

              if (currentStatus == cOK)
                countOK = countOK + 1;
              if (currentStatus == cWarning)
                countWarning = countWarning + 1;
              if (currentStatus == cError)
                countError = countError + 1;

			        if (!isNaN(position.totalValue.valueFC))
                posSum += position.totalValue.valueFC;

              /*
              addToCcySums(fundIndex, position.ccy, position.totalValueFC);

              if (position.assetType == "FX")
                addFxHedge(fundIndex, position.assetIndex);
              */
            }
          }

          currentUniqueID = undefined;
          xpath2 = xpath + '/Portfolios/Portfolio[' + indexPortfolio + ']/Positions';

          status = (countError > 0) ? cError : (countWarning > 0) ? cWarning : cOK;
          AddResult(status, xpath2, 'Summary: ' + countOK + ' OK, ' + countWarning + ' Warning, ' + countError + ' Error');

          absDifference = setDigits(Math.abs(aFunds[fundIndex].fundVolume - posSum), 2);
          relDifference = setDigits((absDifference * 100) / aFunds[fundIndex].fundVolume, 2);
          status = (absDifference <= 1) ? cOK : cError;
          AddResult(status, xpath2, 'Difference of ' + fundCcy + ' ' + absDifference + ' (' + relDifference + '%) between fund volume ' + fundCcy + ' ' + aFunds[fundIndex].fundVolume + ' and sum of all positions ' + fundCcy + ' ' + setDigits(posSum,2));

          //calculateHedgedCcyExposure(fundIndex);
        }

        //------------------------------------------------------------------------------------------------------------
        // TRANSACTIONS
        //
        currentUniqueID = undefined;
        var nodeTransactions = getFirstChildNode(nodePortfolio, "Transactions");

        if (nodeTransactions !== undefined) {
          currentModule = modTransactions;
          xpath2 = xpath + '/Portfolios/Portfolio[' + indexPortfolio + ']/Transactions';
          var nlTransaction = nodeTransactions.getElementsByTagName("Transaction");

          for (var indexTransaction = 0; indexTransaction < nlTransaction.length; indexTransaction++) {
            var nodeTransaction = nlTransaction[indexTransaction];
            var transaction = new Object();
            currentUniqueID = undefined;

            xpath2 = xpath + '/Portfolios/Portfolio[' + indexPortfolio + ']/Transactions/Transaction[' + indexTransaction + ']';
            transaction.ID = getNodeText(nodeTransaction, "TransactionID", cAllMandatory, xpath2);
            transaction.kind = getNodeItem(nodeTransaction, "TransactionKind", cAllMandatory, xpath2, 'BUY,SELL,LENDING_BUY,LENDING_SELL,CORP_ACTION');

            transaction.entryDate = getNodeDate(nodeTransaction, "EntryDate", cAllMandatory, xpath2);  // optional in schema, but mandatory for us
            transaction.valutaDate = getNodeDate(nodeTransaction, "ValutaDate", cError, xpath2);
            transaction.closingDate = getNodeDate(nodeTransaction, "ClosingDate", cError, xpath2);
            transaction.units = getNodeNumber(nodeTransaction, "NominalOrUnitsOrContracts", cAllMandatory, xpath2);

            if (transaction.kind == 'CORP_ACTION') {
              nodeInstrument = GetChildNode(nodePosition, "CorporateAction", cErrorMandatory, xpath2);
              if (nodeInstrument !== undefined) {
                xpath3 = xpath2 + '/CorporateAction';
                // from
                // to
                transaction.corporateActionKind = getNodeItem(nodeInstrument, "CorporateActionKind", cError, xpath3, 'S,RS,M,SD,NSinS,DEM,RI,ESC,CD,GenM');
                transaction.exDividendDate = getNodeNumber(nodeTransaction, "ExDividendDate", cError, xpath2);
                transaction.expensesValutaDate = getNodeNumber(nodeTransaction, "ExpensesValutaDate", cError, xpath2);
                transaction.expensesExchangeRate = getNodeNumber(nodeTransaction, "ExpensesExchangeRate", cError, xpath2);
                // Expenses
                // AccountNumberExpenses
                // UnitInterestEUWithholdingTax
                // CorporateActionDocument
              }
            }
            else {
              asset = new Object();
              transaction.uniqueID = getNodeText(nodeTransaction, "AssetUniqueID", cError, xpath2);
              currentUniqueID = transaction.uniqueID;
              transaction.assetIndex = getAssetMasterDataIndex(transaction.uniqueID);
              transaction.ccy = getNodeCurrency(nodeTransaction, "Currency", cError, xpath2);
              transaction.settlementCurrency = getNodeCurrency(nodeTransaction, "SettlementCurrency", cError, xpath2);

              if (currentUniqueID === undefined) {
                AddResult(cWarning, xpath2, '<AssetUniqueID> missing');
              }
              else {
                if (transaction.assetIndex === undefined) {
                  AddResult(cError, xpath2, 'Missing AssetMasterData for UniqueID "' + transaction.uniqueID + '"');
                }
                else {
                  asset = aAssetMasterData[transaction.assetIndex];
                  if (transaction.ccy != aAssetMasterData[transaction.assetIndex].ccy && asset.assetType != "FX" /*FXForward*/)
                    AddResult(cError, xpath2, 'Currency in AssetMasterData "' + asset.ccy + '" different to currency in transaction "' + transaction.ccy + '"');
                  transaction.ccy = aAssetMasterData[transaction.assetIndex].ccy;  // overwite local transaction currency with currency in AssetMasterData
                  transaction.assetType = asset.assetType;              
                }
              }

							// moved down in order to have asset type available
              transaction.identifiers = getIdentifiers(nodeTransaction, "Identifiers", cError, transaction.assetType, xpath2);

              transaction.cleanPrice = getCcyAmounts(nodeTransaction, "CleanPrice", fundCcy, transaction.ccy, cError, cError, xpath2);
              transaction.dirtyPrice = getCcyAmounts(nodeTransaction, "DirtyPrice", fundCcy, transaction.ccy, cError, cError, xpath2);
              transaction.agreedPrice = getCcyAmounts(nodeTransaction, "AgreedPrice", fundCcy, transaction.ccy, cError, cError, xpath2);

              transaction.marketValue = getCcyAmounts(nodeTransaction, "MarketValue", fundCcy, transaction.ccy, cError, cError, xpath2);
              transaction.interestClaimGross = getCcyAmounts(nodeTransaction, "InterestClaimGross", fundCcy, transaction.ccy, cError, cError, xpath2);
              transaction.zeroBondInterestClaimGross = getCcyAmounts(nodeTransaction, "ZeroBondInterestClaimGross", fundCcy, transaction.ccy, cError, cError, xpath2);
              transaction.dirtyValue = getCcyAmounts(nodeTransaction, "DirtyValue", fundCcy, transaction.ccy, cError, cError, xpath2);
              transaction.settlementAmount = getCcyAmounts(nodeTransaction, "SettlementAmount", fundCcy, transaction.ccy, cError, cError, xpath2);
              // ...
            }

            portfolio.transactions.push(transaction);
          }
        }

        //------------------------------------------------------------------------------------------------------------
        // EARNINGS
        //
      }
    }
  }

  aPortfolios.push(portfolio);
}


//---------------------------------------------------------------------------------------------------------------------

function getShareClasses(parentNode, fundIndex, reportStatus, xpath)
{
  var result = new Array();
  var status;
  var xpath2;
  var xpath3;
  var previousModule = currentModule;
  var tempNode;
  var shareClass;
	var nodeShareClasses;
  var nlShareClass;
  var nodeShareClass;
  var nodePrices;
  var nlPrice;
  var nodePrice;
	var actionCode;
	var navDate;
	var priceCurrency;
	var priceNature;

	nodeShareClasses = GetChildNode(parentNode, "ShareClasses", reportStatus, xpath);

	if (nodeShareClasses !== undefined) {
		xpath2 = xpath + '/ShareClasses';
    currentModule = modShareClasses;

    nlShareClass = nodeShareClasses.getElementsByTagName("ShareClass");

    for (var shareClassIndex = 0; shareClassIndex < nlShareClass.length; shareClassIndex++) {
      shareClass = new Object();
      nodeShareClass = nlShareClass[shareClassIndex];
      xpath2 = xpath + '/ShareClasses/ShareClass[' + shareClassIndex + ']';

      shareClass.identifiers = getIdentifiers(nodeShareClass, "Identifiers", cErrorMandatory, "SC", xpath2);
      status = (StrLen(shareClass.identifiers.isin) == 12) ? cOK : cError;
		  AddResult(status, xpath2 + '/Identifiers', '<ISIN> = "' + shareClass.identifiers.isin + '"');
      shareClass.names = getNames(nodeShareClass, cErrorMandatory, xpath2);
		  //AddResult(cOK, xpath2 + '/Names', '<OfficialName> = "' + shareClass.names.officialName + '"');
      shareClass.ccy = getNodeCurrency(nodeShareClass, "Currency", cAllMandatory, xpath2);

		  tempNode = GetChildNode(nodeShareClass, "ShareClassType", cWarning, xpath2);
		  if (tempNode !== undefined) {
			  xpath3 = xpath2 + '/ShareClassType';
			  shareClass.typeCode = getNodeText(tempNode, "Code", cAllMandatory, xpath3, 1, 32);
			  shareClass.typeEarningUse = getNodeItem(tempNode, "EarningUse", cError, xpath3, 'D,P,R');
			  shareClass.typeName = getNodeText(tempNode, "Name", cError, xpath3, 1, 256);
			  shareClass.typeDescription = getNodeText(tempNode, "Description", cError, xpath3, 1, 1000);
		  }

		  shareClass.inceptionDate = getNodeDate(nodeShareClass, "InceptionDate", cError, xpath2);
			shareClass.liquidationDate = getNodeDate(nodeShareClass, "LiquidationDate", cError, xpath2);
			shareClass.liquidationReason = getNodeItem(nodeShareClass, "LiquidationReason", cError, xpath2, 'CLIENT EXIT,LOW VOLUME,MERGER,OTHER');
      // MinimumInvestment
      shareClass.openToNewInvestors = getNodeBoolean(nodeShareClass, "OpenToNewInvestorsFlag", cError, xpath2);
      shareClass.currencyHedged = getNodeBoolean(nodeShareClass, "CurrencyHedgedFlag", cError, xpath2);
      shareClass.isLeveraged = getNodeBoolean(nodeShareClass, "IsLeveragedFlag", cError, xpath2);
      shareClass.isReferenceShareClass = getNodeBoolean(nodeShareClass, "IsReferenceShareClass", cError, xpath2);
      shareClass.isPublic = getNodeBoolean(nodeShareClass, "IsPublicFlag", cError, xpath2);

		  nodePrices = GetChildNode(nodeShareClass, "Prices", cWarning, xpath2);
		  if (nodePrices !== undefined) {
			  xpath3 = xpath2 + '/Prices';
        nlPrice = nodePrices.getElementsByTagName("Price");

        for (var priceIndex = 0; priceIndex < nlPrice.length; priceIndex++) {
          nodePrice = nlPrice[priceIndex];
          xpath3 = xpath2 + '/Prices/Price[' + priceIndex + ']';

			    actionCode = getNodeItem(nodePrice, "ActionCode", cErrorMandatory, xpath3, 'C,D,M');
			    navDate = getNodeDate(nodePrice, "NavDate", cErrorMandatory, xpath3);
			    priceCurrency = getNodeCurrency(nodePrice, "PriceCurrency", cErrorMandatory, xpath3);
			    priceNature = getNodeItem(nodePrice, "PriceNature", cErrorMandatory, xpath3, 'OFFICIAL,ESTIMATED,TECHNICAL');

          if (actionCode != "D" && navDate == contentDate && priceCurrency == shareClass.ccy && priceNature == "OFFICIAL") {
            shareClass.priceNature = priceNature;
			      shareClass.priceCalculationDate = getNodeDate(nodePrice, "PriceCalculationDate", cError, xpath3);
			      shareClass.priceValuationDate = getNodeDate(nodePrice, "PriceValuationDate", cError, xpath3);
			      shareClass.navPrice = getNodeNumber(nodePrice, "NavPrice", cAllMandatory, xpath3);
			      shareClass.subscriptionPrice = getNodeNumber(nodePrice, "SubscriptionPrice", cError, xpath3);
			      shareClass.redemptionPrice = getNodeNumber(nodePrice, "RedemptionPrice", cError, xpath3);
            // OtherPrices
			      shareClass.splitFactor = getNodeNumber(nodePrice, "SplitFactor", cError, xpath3);
			    }
        }
		  }

      shareClass.totalAssetValues = getTotalAssetValuesSC(nodeShareClass, shareClass.ccy, cError, xpath2);

      // Distributions
      // Fees
      // Flows
      // PerformanceFigures
      // Portfolios
      // BlockedInvestorCountries
      // HighWatermark
      // PEA_EligibleFlag
      // RetailInvestorsOnly
      // UK_RDR_Flag
      // TransferAgent
      // Investors
      // InvestorAllocation
      // CustomAttributes
      // CountrySpecificData

      result.push(shareClass);
    }
  }

  // restore previous current module
  currentModule = previousModule;

  return result;
}


//---------------------------------------------------------------------------------------------------------------------

function AnalyseRegRepEMT(mainNode, contentDate, xpath)
{
  var instrument;
  var nlInstrument;
  var nodeInstrument;
  var nodeISINs;
  var nlISINs;
  var nodeISIN;
  var nodeCountrySpecificData;
  var nodeDE;
  var nodeEMT_Additional;
  var nodeBlock;
  var nodeTemp;
  var nodeTemp2;
  var isin;
  var xpath2;
  var xpath3;
  var xpath4;
  var xpath5;
  var status;
  var countOK;
  var countWarning;
  var countError;
  var posSum;
  var errorText;

  //aInstruments = new Array();

  currentModule = modRegulatoryReportingEMT;
  currentUniqueID = undefined;

  /*
	<EMT>
		<FinancialInstrument>
			<FundOrShareClassIdentifiers>  <!-- Optional -->
				<LEI></LEI>
				<ISINs>
					<ISIN></ISIN>
				</ISINs>
			</FundOrShareClassIdentifiers>
			<DataSupplier>  <!-- Optional -->
				<SystemCountry>Austria</SystemCountry>
				<Short></Short>
				<Name></Name>
				<Type></Type>
			</DataSupplier>
  */
  nlInstrument = mainNode.getElementsByTagName("FinancialInstrument");

  for (var instrumentIndex = 0; instrumentIndex < nlInstrument.length; instrumentIndex++) {
    nodeInstrument = nlInstrument[instrumentIndex];
    xpath2 = xpath + '/FinancialInstrument[' + instrumentIndex + ']';
    instrument = new Object();
    instrument.ISINs = new Array();

    nodeTemp = getFirstChildNode(nodeInstrument, "FundOrShareClassIdentifiers");
    if (nodeTemp !== undefined) {
      xpath3 = xpath2 + '/FundOrShareClassIdentifiers';
      instrument.LEI = getNodeText(nodeTemp, "LEI", cError, xpath3, 20, 20);

      nodeISINs = getFirstChildNode(nodeTemp, "ISINs");
      if (nodeISINs !== undefined) {
        xpath4 = xpath3 + '/ISINs';
        nlISINs = nodeISINs.getElementsByTagName("ISINs");

        for (var isinIndex = 0; isinIndex < nlISINs.length; isinIndex++) {
          nodeISIN = nlISINs[isinIndex];
          xpath5 = xpath4 + '/ISIN[' + isinIndex + ']';
          isin = nodeISIN.textContent;
          if (IsValidIsin(isin))
            instrument.ISINs.push(isin);
          else
            AddResult(cError, xpath5, 'Invalid node content: "' + isin + '" (not a valid ISIN)');
        }
      }
    }

    instrument.dataSupplier = getDataSupplier(nodeInstrument, cError, xpath2);

    /*
		<GeneralInformation>
			<Code>ISIN</Code>  <!-- ISIN -->
			<CodificationSystem>1</CodificationSystem>
			<InstrumentName>Instrument Name</InstrumentName>
			<InstrumentCurrency>EUR</InstrumentCurrency>
			<ReportingDate>2018-10-31</ReportingDate>
			<LegalStructure>U</LegalStructure>
			<IssuerName>Issuer Name</IssuerName>
			<GuarantorName>Optional</GuarantorName>  <!-- Optional -->
			<ProductCategoryNature>Optional</ProductCategoryNature>  <!-- Optional -->
			<LeveragedOrContingentLiability>N</LeveragedOrContingentLiability>  <!-- Optional -->
		</GeneralInformation>
    */
    /*
    00020: Codification system used. Integer corresponding to the following closed list:
      1 - ISO 6166 for ISIN code
      2 - CUSIP (The Committee on Uniform Securities Identification Procedures number assigned by the CUSIP Service Bureau for U.S. and Canadian companies)
      3 - SEDOL (Stock Exchange Daily Official List for the London Stock Exchange)
      4 – WKN (Wertpapier Kenn-Nummer, the alphanumeric German identification number)
      5 - Bloomberg Ticker (Bloomberg letters code that identify a company's securities)
      6 - BBGID (The Bloomberg Global ID)
      7 - Reuters RIC (Reuters instrument code)
      8 – FIGI (Financial Instrument Global Identifier)
      9 - Other code by members of the Association of National Numbering Agencies
      99 - Code attributed by the undertaking
    */
		nodeTemp = GetChildNode(nodeInstrument, "GeneralInformation", cErrorMandatory, xpath2);
    if (nodeTemp !== undefined) {
      xpath3 = xpath2 + '/GeneralInformation';
      instrument.code = getNodeText(nodeTemp, "Code", cErrorMandatory, xpath3, 1, 255);
      currentUniqueID = instrument.code;
      instrument.codeSystem = getNodeItem(nodeTemp, "CodificationSystem", cErrorMandatory, xpath3, "1,2,3,4,5,6,7,8,9,99");
      instrument.name = getNodeText(nodeTemp, "InstrumentName", cErrorMandatory, xpath3, 1, 255);
      instrument.ccy = getNodeText(nodeTemp, "InstrumentCurrency", cErrorMandatory, xpath3, 3, 3);
      instrument.date = getNodeDate(nodeTemp, "ReportingDate", cErrorMandatory, xpath3);
      instrument.legalStructure = getNodeItem(nodeTemp, "LegalStructure", cErrorMandatory, xpath3, "S,SF,SP,U,N");
      instrument.issuerName = getNodeText(nodeTemp, "IssuerName", cErrorMandatory, xpath3, 1, 255);
      instrument.guarantorName = getNodeText(nodeTemp, "GuarantorName", cError, xpath3, 0, 255);
      instrument.productCategoryNature = getNodeText(nodeTemp, "ProductCategoryNature", cError, xpath3, 0, 255);
      instrument.leveraged = getNodeItem(nodeTemp, "LeveragedOrContingentLiability", cError, xpath3, "Y,N");
    }

    /*
	  <InvestorType>
		  <Retail>Y</Retail>  <!-- Y,N,Neutral -->
		  <Professional>Y</Professional>  <!-- Y,N,Neutral,P,E,B -->
		  <EligibleCounterparty>Y</EligibleCounterparty>  <!-- Y,N,Neutral -->
	  </InvestorType>
    */
		nodeTemp = GetChildNode(nodeInstrument, "InvestorType", cErrorMandatory, xpath2);
    if (nodeTemp !== undefined) {
      xpath3 = xpath2 + '/InvestorType';
      instrument.retail = getNodeItem(nodeTemp, "Retail", cErrorMandatory, xpath3, "Y,N,Neutral");
      instrument.professional = getNodeItem(nodeTemp, "Professional", cErrorMandatory, xpath3, "Y,N,Neutral,P,E,B");
      instrument.eligibleCounterparty = getNodeItem(nodeTemp, "EligibleCounterparty", cErrorMandatory, xpath3, "Y,N,Neutral");
    }
    /*
	  <KnowledgeAndExperience>
		  <BasicInvestor></BasicInvestor>  <!-- Y,N,Neutral -->
		  <InformedInvestor></InformedInvestor>  <!-- Y,N,Neutral -->
		  <AdvancedInvestor></AdvancedInvestor>  <!-- Y,N,Neutral -->
		  <ExpertInvestorGermany>N</ExpertInvestorGermany>  <!-- Optional: Y,N,Neutral -->
	  </KnowledgeAndExperience>
    */
		nodeTemp = GetChildNode(nodeInstrument, "KnowledgeAndExperience", cErrorMandatory, xpath2);
    if (nodeTemp !== undefined) {
      xpath3 = xpath2 + '/KnowledgeAndExperience';
      instrument.basicInvestor = getNodeItem(nodeTemp, "BasicInvestor", cErrorMandatory, xpath3, "Y,N,Neutral");
      instrument.informedInvestor = getNodeItem(nodeTemp, "InformedInvestor", cErrorMandatory, xpath3, "Y,N,Neutral");
      instrument.advancedInvestor = getNodeItem(nodeTemp, "AdvancedInvestor", cErrorMandatory, xpath3, "Y,N,Neutral");
      instrument.expertInvestorGermany = getNodeItem(nodeTemp, "ExpertInvestorGermany", cError, xpath3, "Y,N,Neutral");
    }

    /*
		<AbilityToBearLosses>
			<NoCapitalLoss></NoCapitalLoss>  <!-- Y,N,Neutral -->
			<LimitedCapitalLoss></LimitedCapitalLoss>  <!-- Y,N,Neutral -->
			<LimitedCapitalLossLevel>0.5</LimitedCapitalLossLevel>  <!-- Percentage -->
			<NoCapitalGuarantee></NoCapitalGuarantee>  <!-- Y,N,Neutral -->
			<LossBeyondCapital></LossBeyondCapital>  <!-- Y,N,Neutral -->
		</AbilityToBearLosses>
    */
		nodeTemp = GetChildNode(nodeInstrument, "AbilityToBearLosses", cErrorMandatory, xpath2);
    if (nodeTemp !== undefined) {
      xpath3 = xpath2 + '/AbilityToBearLosses';
      instrument.noCapitalLoss = getNodeItem(nodeTemp, "NoCapitalLoss", cErrorMandatory, xpath3, "Y,N,Neutral");
      instrument.limitedCapitalLoss = getNodeItem(nodeTemp, "LimitedCapitalLoss", cErrorMandatory, xpath3, "Y,N,Neutral");
      instrument.limitedCapitalLossLevel = getNodeNumber(nodeTemp, "LimitedCapitalLossLevel", cErrorMandatory, xpath3, 0, 100);
      instrument.noCapitalGuarantee = getNodeItem(nodeTemp, "NoCapitalGuarantee", cErrorMandatory, xpath3, "Y,N,Neutral");
      instrument.lossBeyondCapital = getNodeItem(nodeTemp, "LossBeyondCapital", cError, xpath3, "Y,N,Neutral");
    }

    /*
		<RiskTolerance>
			<PRIIPSMethodology>8</PRIIPSMethodology>  <!-- SRI between 1 and 7 -->
			<UCITSMethodology>9</UCITSMethodology>  <!-- SRRI between 1 and 7 -->
			<InternalMethodology>X</InternalMethodology>  <!-- L/M/H (low/medium/high) -->
			<MethodologySpain>0</MethodologySpain>  <!-- Spanish SRI between 1 and 6 -->
			<NotForInvestorsWithLowestRiskToleranceGermany>A</NotForInvestorsWithLowestRiskToleranceGermany>  <!-- Y or Neutral -->
		</RiskTolerance>
    */
		nodeTemp = GetChildNode(nodeInstrument, "AbilityToBearLosses", cErrorMandatory, xpath2);
    if (nodeTemp !== undefined) {
      xpath3 = xpath2 + '/AbilityToBearLosses';
      instrument.PRIIPSMethodology = getNodeInteger(nodeTemp, "PRIIPSMethodology", cError, xpath3, 1, 7);
      instrument.UCITSMethodology = getNodeInteger(nodeTemp, "UCITSMethodology", cError, xpath3, 1,7);
      instrument.InternalMethodology = getNodeItem(nodeTemp, "InternalMethodology", cError, xpath3, "L,M,H");
      instrument.MethodologySpain = getNodeInteger(nodeTemp, "MethodologySpain", cError, xpath3, 1, 6);
      instrument.NotForLowestRiskInvestorsGermany = getNodeItem(nodeTemp, "NotForInvestorsWithLowestRiskToleranceGermany", cError, xpath3, "Y,Neutral");
    }

    /*
		<ClientObjectives>
			<ReturnProfile>
				<Preservation></Preservation>  <!-- Y,N,Neutral -->
				<Growth></Growth>  <!-- Y,N,Neutral -->
				<Income></Income>  <!-- Y,N,Neutral -->
				<Hedging></Hedging>  <!-- Y,N,Neutral -->
				<OptionOrLeveraged></OptionOrLeveraged>  <!-- Y,N,Neutral -->
				<Other></Other>  <!-- Y,Neutral -->
				<PensionSchemeGermany></PensionSchemeGermany>  <!-- Optional: Y,N,Neutral -->
			</ReturnProfile>
			<TimeHorizon>
				<Years>-1</Years>  <!-- Period in years -->
				<Category>X</Category>  <!-- OR: V/S/M/L -->
			</TimeHorizon>
			<MaturityDate>2000-01-01</MaturityDate>  <!-- Optional -->
			<MayBeTerminatedEarly>A</MayBeTerminatedEarly>  <!-- Optional: Y,N,Neutral -->
			<SpecificInvestmentNeed>Z</SpecificInvestmentNeed>  <!-- Y,N,G,E,I,S,O -->
		</ClientObjectives>
    */
		nodeClientObjectives = GetChildNode(nodeInstrument, "ClientObjectives", cErrorMandatory, xpath2);
    if (nodeClientObjectives !== undefined) {
      xpath3 = xpath2 + '/ClientObjectives';

		  nodeTemp = GetChildNode(nodeClientObjectives, "ReturnProfile", cErrorMandatory, xpath3);
      if (nodeTemp !== undefined) {
        xpath4 = xpath3 + '/ReturnProfile';
        instrument.Preservation = getNodeItem(nodeTemp, "Preservation", cErrorMandatory, xpath4, "Y,N,Neutral");
        instrument.Growth = getNodeItem(nodeTemp, "Growth", cErrorMandatory, xpath4, "Y,N,Neutral");
        instrument.Income = getNodeItem(nodeTemp, "Income", cErrorMandatory, xpath4, "Y,N,Neutral");
        instrument.Hedging = getNodeItem(nodeTemp, "Hedging", cErrorMandatory, xpath4, "Y,N,Neutral");
        instrument.OptionOrLeveraged = getNodeItem(nodeTemp, "OptionOrLeveraged", cErrorMandatory, xpath4, "Y,N,Neutral");
        instrument.Other = getNodeItem(nodeTemp, "Other", cErrorMandatory, xpath4, "Y,Neutral");
        instrument.PensionSchemeGermany = getNodeItem(nodeTemp, "PensionSchemeGermany", cError, xpath4, "Y,N,Neutral");
      }

		  nodeTemp = GetChildNode(nodeClientObjectives, "TimeHorizon", cErrorMandatory, xpath3);
      if (nodeTemp !== undefined) {
        xpath4 = xpath3 + '/TimeHorizon';
        instrument.timeHorizonYears = getNodeNumber(nodeTemp, "Years", cError, xpath4, 0, 100);
        instrument.timeHorizonCategory = getNodeItem(nodeTemp, "Category", cError, xpath4, "V,S,M,L,Neutral");
        // TODO: one of the two fields must be filled !
      }

      instrument.maturityDate = getNodeDate(nodeClientObjectives, "MaturityDate", cError, xpath3);
      instrument.mayBeTerminatedEarly = getNodeItem(nodeClientObjectives, "MayBeTerminatedEarly", cError, xpath3, "Y,N,Neutral");
      instrument.specificInvestmentNeed = getNodeItem(nodeClientObjectives, "SpecificInvestmentNeed", cErrorMandatory, xpath3, "Y,N,G,E,I,S,O");
    }

    /*
		<DistributionStrategy>
			<ExecutionOnly></ExecutionOnly>  <!-- R,P,B,N -->
			<ExecutionWithCheckOrNonAdvisedServices></ExecutionWithCheckOrNonAdvisedServices>  <!-- R,P,B,N -->
			<InvestmentAdvice></InvestmentAdvice>  <!-- R,P,B,N -->
			<PortfolioManagement></PortfolioManagement>  <!-- R,P,B,N -->
		</DistributionStrategy>
    */
		nodeTemp = GetChildNode(nodeInstrument, "DistributionStrategy", cErrorMandatory, xpath2);
    if (nodeTemp !== undefined) {
      xpath3 = xpath2 + '/DistributionStrategy';
      instrument.executionOnly = getNodeItem(nodeTemp, "ExecutionOnly", cErrorMandatory, xpath3, "R,P,B,N");
      instrument.executionWithCheck = getNodeItem(nodeTemp, "ExecutionWithCheckOrNonAdvisedServices", cErrorMandatory, xpath3, "R,P,B,N");
      instrument.investmentAdvice = getNodeItem(nodeTemp, "InvestmentAdvice", cErrorMandatory, xpath3, "R,P,B,N");
      instrument.portfolioManagement = getNodeItem(nodeTemp, "PortfolioManagement", cErrorMandatory, xpath3, "R,P,B,N");
    }

    /*
		<CostsAndChargesExAnte>
			<Fund>
				<EntryCost></EntryCost>  <!-- Optional -->
				<MaxEntryCostItaly></MaxEntryCostItaly>  <!-- Optional -->
				<MaxEntryCostAcquired></MaxEntryCostAcquired>  <!-- Optional -->
				<MaxExitCost></MaxExitCost>  <!-- Optional -->
				<MaxExitCostItaly></MaxExitCostItaly>  <!-- Optional -->
				<MaxExitCostAcquired></MaxExitCostAcquired>  <!-- Optional -->
				<TypicalExitCost></TypicalExitCost>  <!-- Optional -->
				<OngoingCosts></OngoingCosts>
				<ManagementFee></ManagementFee>
				<DistributionFee></DistributionFee>  <!-- Optional -->
				<TransactionCosts></TransactionCosts>
				<IncidentalCosts></IncidentalCosts>
			</Fund>
    */
		nodeBlock = GetChildNode(nodeInstrument, "CostsAndChargesExAnte", cErrorMandatory, xpath2);
    if (nodeBlock !== undefined) {
      xpath3 = xpath2 + '/CostsAndChargesExAnte';

		  nodeTemp = GetChildNode(nodeBlock, "Fund", cErrorMandatory, xpath3);
      if (nodeTemp !== undefined) {
        xpath4 = xpath3 + '/Fund';
        instrument.entryCost = getNodeNumber(nodeTemp, "EntryCost", cError, xpath4);
        instrument.maxEntryCostItaly = getNodeNumber(nodeTemp, "MaxEntryCostItaly", cError, xpath4);
        instrument.maxEntryCostAcquired = getNodeNumber(nodeTemp, "MaxEntryCostAcquired", cError, xpath4);
        instrument.maxExitCost = getNodeNumber(nodeTemp, "MaxExitCost", cError, xpath4);
        instrument.maxExitCostItaly = getNodeNumber(nodeTemp, "MaxExitCostItaly", cError, xpath4);
        instrument.maxExitCostAcquired = getNodeNumber(nodeTemp, "MaxExitCostAcquired", cError, xpath4);
        instrument.typicalExitCost = getNodeNumber(nodeTemp, "TypicalExitCost", cError, xpath4);
        instrument.ongoingCosts = getNodeNumber(nodeTemp, "OngoingCosts", cErrorMandatory, xpath4);
        instrument.managementFee = getNodeNumber(nodeTemp, "ManagementFee", cErrorMandatory, xpath4);
        instrument.distributionFee = getNodeNumber(nodeTemp, "DistributionFee", cError, xpath4);
        instrument.transactionCosts = getNodeNumber(nodeTemp, "TransactionCosts", cError, xpath4);
        instrument.incidentalCosts = getNodeNumber(nodeTemp, "IncidentalCosts", cError, xpath4);

		    nodeTemp = GetChildNode(nodeBlock, "StructuredSecurity", cErrorMandatory, xpath3);
        if (nodeTemp !== undefined)
          AddResult(cError, xpath3, 'Node <StructuredSecurity> not allowed in addition to <Fund>');
      }
    }

    /*
		<CostsAndChargesExPost>  <!-- Optional -->
			<Fund>
				<OngoingCosts></OngoingCosts>  <!-- Optional -->
				<ManagementFee></ManagementFee>  <!-- Optional -->
				<DistributionFee></DistributionFee>  <!-- Optional -->
				<TransactionCosts></TransactionCosts>  <!-- Optional -->
				<IncidentialCosts></IncidentialCosts>  <!-- Optional -->
				<CalculationPeriod>  <!-- Optional -->
					<Start></Start>  <!-- Optional -->
					<End></End>  <!-- Optional -->
				</CalculationPeriod>
			</Fund>
    */
		nodeBlock = GetChildNode(nodeInstrument, "CostsAndChargesExPost", cErrorMandatory, xpath2);
    if (nodeBlock !== undefined) {
      xpath3 = xpath2 + '/CostsAndChargesExPost';

		  nodeTemp = GetChildNode(nodeBlock, "Fund", cErrorMandatory, xpath3);
      if (nodeTemp !== undefined) {
        xpath4 = xpath3 + '/Fund';
        instrument.ongoingCostsExPost = getNodeNumber(nodeTemp, "OngoingCosts", cError, xpath4);
        instrument.managementFeeExPost = getNodeNumber(nodeTemp, "ManagementFee", cError, xpath4);
        instrument.distributionFeeExPost = getNodeNumber(nodeTemp, "DistributionFee", cError, xpath4);
        instrument.transactionCostsExPost = getNodeNumber(nodeTemp, "TransactionCosts", cError, xpath4);
        instrument.incidentalCostsExPost = getNodeNumber(nodeTemp, "IncidentalCosts", cError, xpath4);

		    nodeTemp2 = GetChildNode(nodeTemp, "CalculationPeriod", cOK, xpath4);
        if (nodeTemp2 !== undefined) {
          xpath5 = xpath4 + '/CalculationPeriod';
          instrument.calculationPeriodStart = getNodeDate(nodeTemp2, "Start", cError, xpath5);
          instrument.calculationPeriodEnd = getNodeDate(nodeTemp2, "End", cError, xpath5);
        }

		    nodeTemp = GetChildNode(nodeBlock, "StructuredSecurity", cErrorMandatory, xpath3);
        if (nodeTemp !== undefined)
          AddResult(cError, xpath3, 'Node <StructuredSecurity> not allowed in addition to <Fund>');
      }
    }

    /*
		<CountrySpecificData>
			<DE>
				<EMT_Additional>
					<TargetMarketInformation>
						<ModusApproval>X</ModusApproval>	<!-- A,B,C -->
						<SpecialRequirementsDescription></SpecialRequirementsDescription>  <!-- Optional -->
						<NatureProductCategory>Z</NatureProductCategory>  <!-- A...U -->
						<ApprovalProcess>*</ApprovalProcess>  <!-- A,B,C,D -->
					</TargetMarketInformation>
					<CostTransparency>
						<SwingPricing>Nein</SwingPricing>  <!-- J,N -->
					</CostTransparency>
				</EMT_Additional>
			</DE>
		</CountrySpecificData>
    */
		nodeCountrySpecificData = GetChildNode(nodeInstrument, "CountrySpecificData", cOK, xpath2);
    if (nodeCountrySpecificData !== undefined) {
      xpath3 = xpath2 + '/CountrySpecificData';

		  nodeDE = GetChildNode(nodeCountrySpecificData, "DE", cOK, xpath3);
      if (nodeDE !== undefined) {
        xpath3 += '/DE';

		    nodeEMT_Additional = GetChildNode(nodeDE, "EMT_Additional", cErrorMandatory, xpath3);
        if (nodeEMT_Additional !== undefined) {
          xpath3 += '/EMT_Additional';

		      nodeTemp = GetChildNode(nodeEMT_Additional, "TargetMarketInformation", cErrorMandatory, xpath3);
          if (nodeTemp !== undefined) {
            xpath4 = xpath3 + '/TargetMarketInformation';
            instrument.modusApproval = getNodeItem(nodeTemp, "ModusApproval", cErrorMandatory, xpath4, "A,B,C");
            instrument.specialRequirementsDescription = getNodeText(nodeTemp, "SpecialRequirementsDescription", cError, xpath4, "A,B,C");
            instrument.natureProductCategory = getNodeItem(nodeTemp, "NatureProductCategory", cErrorMandatory, xpath4, "A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U");
            instrument.approvalProcess = getNodeItem(nodeTemp, "ApprovalProcess", cErrorMandatory, xpath4, "A,B,C,D");
          }

		      nodeTemp = GetChildNode(nodeEMT_Additional, "CostTransparency", cErrorMandatory, xpath3);
          if (nodeTemp !== undefined) {
            xpath4 = xpath3 + '/CostTransparency';
            instrument.swingPricing = getNodeItem(nodeTemp, "SwingPricing", cErrorMandatory, xpath4, "J,N");
          }
        }
      }
    }

    //aInstrument.push(instrument);
  }
}


//---------------------------------------------------------------------------------------------------------------------

function AnalyseFundsXmlDoc()
{
  var parser = new DOMParser();
  var xmlDoc;
  var xpath;
	var xpath2;
	var xpath3;
  var rootNode;
  var nodeControlData;
	var nodeModuleUsage;
	var nodeModule;
	var moduleName;
	var validItems;
	var CountrySpecificData;
	var nodeAT;
	var nodeTemp;
	var fdpContent;
  var nodeAssetMasterData;
  var nlAsset;
  var nodeFunds;
  var nlFund;
  var nodeRegulatoryReportings;
  var nodeDirectReporting;
  var nodeIndirectReporting;
  var errorText;

	aCheckResults = new Array();
  aUsedModules = new Array();
	resultArea.innerHTML = "";
  //anErrors = new Array();
  statusText = document.getElementById("Status");
  currentModule = modRoot;
  currentUniqueID = undefined;
	uniqueDocumentID = undefined;
	relatedDocumentID = undefined;
	documentGenerated = undefined;
	dataOperation = undefined;
  docVersion = undefined;
  contentDate = undefined;
  dataSupplier = undefined;
  docLanguage = undefined;

  /*
  <FundsXML4>
    <ControlData>
      <UniqueDocumentID>SAMPLE.2017-08-12.12345</UniqueDocumentID>
      <DocumentGenerated>2017-08-12T16:36:43</DocumentGenerated>
      <ContentDate>2017-08-12</ContentDate>
      <DataSupplier>
        <SystemCountry>EU</SystemCountry>
        <Short>SDS</Short>
        <Name>Sample Data Supplier</Name>
        <Type>Generic</Type>
      </DataSupplier>
      <Language>EN</Language>
    </ControlData>
  */

  // Is source a valid xml document ?
  try {
    xmlDoc = parser.parseFromString(sourceText.value, "text/xml");
  } catch (e) {
    // if text is not well-formed, 
    AddResult(cError, xpath, 'Source is not a valid xml document');
    //statusText.innerHTML = 'Error: this is not a valid xml document';
    //alert("Not a valid xml document");
    return false;
  };
  if (xmlDoc === null) {
    AddResult(cError, xpath, 'Source is not a valid xml document');
    //statusText.innerHTML = 'Sorry, this is not a valid xml document';
    return false;
  };
  AddResult(cOK, xpath, 'Source is a valid xml document');

  // Is root node <FundsXML4> existing ?
  try {
    rootNode = xmlDoc.getElementsByTagName("FundsXML4")[0];
  } catch (e) {
    AddResult(cError, xpath, 'Root node <FundsXML4> missing');
    return false;
  };
  if (rootNode === undefined) {
    AddResult(cError, xpath, 'Root node <FundsXML4> missing');
    return false;
  };
  AddResult(cOK, xpath, 'Root node <FundsXML4> existing');

  xpath = '/FundsXML4';
  nodeControlData = GetChildNode(rootNode, "ControlData", cError, xpath);
  if (nodeControlData === undefined)
    return false;

  xpath = '/FundsXML4/ControlData';
  currentModule = modControlData;

  uniqueDocumentID = getNodeText(nodeControlData, "UniqueDocumentID", cAllMandatory, xpath, 1, 128);
  documentGenerated = getNodeDateTime(nodeControlData, "DocumentGenerated", cAllMandatory, xpath);
  dataOperation = getNodeItem(nodeControlData, "DataOperation", cAllOptional, xpath, "INITIAL,AMEND,DELETE");

	status = (dataOperation == 'DELETE') ? cError : (dataOperation == 'AMEND') ? cWarning : cOK;
  nodeTemp = GetChildNode(nodeControlData, "RelatedDocumentsIDs", status, xpath);
  if (nodeTemp !== undefined) {
		xpath2 = xpath + '/RelatedDocumentsIDs';
		relatedDocumentID = getNodeText(nodeControlData, "RelatedDocumentID", cAllMandatory, xpath2, 1, 128);
	}

  docVersion = getNodeText(nodeControlData, "Version", cAllOptional, xpath, 5, 5);
  contentDate = getNodeDate(nodeControlData, "ContentDate", cAllMandatory, xpath);
  dataSupplier = getDataSupplier(nodeControlData, cAllMandatory, xpath);
  docLanguage = getNodeText(nodeControlData, "Language", cAllOptional, xpath, 2, 5);

  //if (dataSupplier === undefined)
  //  AddResult(cError, xpath, 'Mandatory node <DataSupplier> missing');

  nodeModuleUsage = GetChildNode(nodeControlData, "ModuleUsage", cOK, xpath);
  if (nodeModuleUsage !== undefined) {
		var nlModules = nodeModuleUsage.getElementsByTagName("Module");

		for (var moduleIndex = 0; moduleIndex < nlModules.length; moduleIndex++) {
			var nodeModule = nlModules[moduleIndex];
			xpath = '/FundsXML4/ControlData/ModuleUsage/Module[' + moduleIndex + ']';
			validItems = "AssetMasterData,AssetMgmtCompDynData,CountrySpecificData_AT,CountrySpecificData_DE";
			validItems += ",CountrySpecificData_DK,CountrySpecificData_FR,CountrySpecificData_LU,CountrySpecificData_NL";
			validItems += ",FundDynamicData,FundStaticData,PortfolioData,RegulatoryReporting_EMIR,RegulatoryReporting_EMT";
			validItems += ",RegulatoryReporting_KIID,RegulatoryReporting_PRIIPS,RegulatoryReporting_SolvencyII";
			validItems += ",ShareClassData,TransactionData";
			moduleName = getNodeItem(nodeModule, "Name", cAllOptional, xpath, validItems);
			if (moduleName !== undefined)
				if (aUsedModules.indexOf(moduleName) < 0)
					aUsedModules.push(moduleName);
				else
					AddResult(cWarning, xpath, 'Module "' + moduleName + '" multiple');
		}
	}

  nodeCountrySpecificData = GetChildNode(nodeControlData, "CountrySpecificData", cOK, xpath);
  if (nodeModuleUsage !== undefined) {
		xpath += "/CountrySpecificData";
		nodeAT = GetChildNode(nodeCountrySpecificData, "AT", cOK, xpath);
		if (nodeAT !== undefined) {
			xpath += "/AT";
			validItems = "FUND,DOCUMENT,REGREP";
			fdpContent = getNodeItem(nodeAT, "FundDataPortalContent", cAllOptional, xpath, validItems);
			nodeTemp = GetChildNode(nodeAT, "FundDataPortalInfos", cOK, xpath);
			if (nodeTemp !== undefined) {
				xpath += "/FundDataPortalInfos";
				fdpInfo = getNodeItem(nodeTemp, "Info", cAllOptional, xpath, validItems);
				// attribute "type"
			}
		}
	}

  // -----------------------------------------------------------------------------------------------------------------
  // load asset master data (if existing)
  currentModule = modRoot;
  xpath = '/FundsXML4';
  nodeAssetMasterData = GetChildNode(rootNode, "AssetMasterData", cError, xpath);
  /*
  if (nodeAssetMasterData === undefined)
    return false;
  */

  xpath = '/FundsXML4/AssetMasterData';
  currentModule = modAssetMasterData;
  /*
  <AssetMasterData>
    <Asset>
      <UniqueID>UID-EQ-004</UniqueID>
      <Identifiers>
        <ISIN>CH0244767585</ISIN>
      </Identifiers>
      <Currency>CHF</Currency>
      <Country>CH</Country>
      <Name>UBS</Name>
      <AssetType>EQ</AssetType>
    </Asset>
    <Asset>
      <UniqueID>UID-FX-007</UniqueID>
      <Currency>EUR</Currency>
      <Country>EU</Country>
      <Name>Hedging FX-Forward USD/EUR</Name>
      <AssetType>FX</AssetType>
      <AssetDetails>
        <FXForward>
          <CurrencyBuy>EUR</CurrencyBuy>
          <AmountBuy>49364.36</AmountBuy>
          <CurrencySell>USD</CurrencySell>
          <AmountSell>58249.94</AmountSell>
          <MaturityDate>2018-09-30</MaturityDate>
          <Counterparty>
            <Identifiers>
              <LEI>213800COUNTERPARTY00</LEI>
            </Identifiers>
            <Name>Sample Counterparty</Name>
          </Counterparty>
        </FXForward>
      </AssetDetails>
    </Asset>
  */
  aAssetMasterData = new Array();
  nlAsset = nodeAssetMasterData.getElementsByTagName("Asset");

  for (var assetIndex = 0; assetIndex < nlAsset.length; assetIndex++) {
    var asset = new Object();
    var nodeAsset = nlAsset[assetIndex];
    var nodeAssetDetails;
    var nodeInstrument;
    var assetComplete = true;

    currentUniqueID = undefined;
    xpath = '/FundsXML4/AssetMasterData/Asset[' + assetIndex + ']';
    asset.uniqueID = getNodeText(nodeAsset, "UniqueID", cErrorMandatory, xpath, 1, 0);
    currentUniqueID = asset.uniqueID;
    asset.ccy = getNodeCurrency(nodeAsset, "Currency", cAllMandatory, xpath);
    asset.incomeCcy = getNodeCurrency(nodeAsset, "IncomeCurrency", cError, xpath);
    asset.country = getNodeText(nodeAsset, "Country", cError, xpath, 2, 2);
    asset.name = getNodeText(nodeAsset, "Name", cAllMandatory, xpath, 1, 256);
    asset.assetType = getNodeItem(nodeAsset, "AssetType", cAllMandatory, xpath, "EQ,BO,SC,WA,CE,OP,FU,FX,SW,RP,FT,CM,AC,FE,RE,RT,LO,RI");

		// moved down in order to have asset type available
    asset.identifiers = getIdentifiers(nodeAsset, "Identifiers", cError, asset.assetType, xpath);

    if (StrLen(asset.uniqueID) == 0 || StrLen(asset.ccy) != 3 || StrLen(asset.name) == 0 || StrLen(asset.assetType) != 2) {
      /*
      errorText = "AssetMasterData (node " + (assetIndex+1) + ", UID " + asset.uniqueID + ") :";
      if (StrLen(asset.uniqueID) == 0)
        errorText += "  UniqueID missing";
      if (StrLen(asset.ccy) != 3)
        errorText += "  Currency missing/invalid";
      if (StrLen(asset.name) == 0)
        errorText += "  Name missing";
      if (StrLen(asset.assetType) != 2)
        errorText += "  AssetType missing/invalid";
      anErrors.push(errorText);
      */
      assetComplete = false;
    }
    else  {
      nodeAssetDetails = GetChildNode(nodeAsset, "AssetDetails", cOK, xpath);  // AssetDetails is mandatory for this FundsXML4 document check (optional in schema)

      if (nodeAssetDetails !== undefined) {
        xpath2 = xpath + '/AssetDetails';

        if (asset.assetType == "EQ" /*Equity*/) {
          nodeInstrument = GetChildNode(nodeAssetDetails, "Equity", cErrorMandatory, xpath2);
          if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/Equity';
						// ClassOfBusiness
						asset.stockMarket = getNodeText(nodeInstrument, "StockMarket", cError, xpath2, 1, 0);
						asset.issuer = getCompany(nodeInstrument, "Issuer", cError, xpath2);
						asset.listing = getNodeItem(nodeInstrument, "Listing", cError, xpath2, "A,B,G,K,M,S,V,Y,Z");
					}
				}

        if (asset.assetType == "BO" /*Bond*/) {
          nodeInstrument = GetChildNode(nodeAssetDetails, "Bond", cErrorMandatory, xpath2);
          if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/Bond';
						asset.convertible = getNodeBoolean(nodeInstrument, "ConvertibleFlag", cErrorMandatory, xpath2);
						asset.issuer = getCompany(nodeInstrument, "Issuer", cError, xpath2);
						asset.stockMarket = getNodeText(nodeInstrument, "StockMarket", cError, xpath2, 1, 0);
						asset.listing = getNodeItem(nodeInstrument, "Listing", cError, xpath2, "A,B,G,K,M,S,V,Y,Z");
						asset.listingUnit = getNodeItem(nodeInstrument, "ListingUnit", cError, xpath2, "N,P");
						asset.issueDate = getNodeDate(nodeInstrument, "IssueDate", cError, xpath2);
						asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cError, xpath2);
						asset.couponDate = getNodeDate(nodeInstrument, "CouponDate", cError, xpath2);
						asset.interestRate = getNodeNumber(nodeInstrument, "InterestRate", cError, xpath2);
						//TODO: ConvertibleBond

						if (asset.issueDate !== undefined && asset.issueDate > contentDate)
							AddResult(cWarning, xpath2, 'IssueDate ' + asset.issueDate + ' should be before ContentDate ' + contentDate);

						if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
							AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
					}
				}

        if (asset.assetType == "SC" /*ShareClass*/) {
          nodeInstrument = GetChildNode(nodeAssetDetails, "ShareClass", cErrorMandatory, xpath2);
          if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/ShareClass';
						asset.issuer = getCompany(nodeInstrument, "Issuer", cError, xpath2);
						asset.stockMarket = getNodeText(nodeInstrument, "StockMarket", cError, xpath2, 1, 0);
						asset.listing = getNodeItem(nodeInstrument, "Listing", cError, xpath2, "A,B,G,K,M,S,V,Y,Z");
						asset.listingUnit = getNodeItem(nodeInstrument, "ListingUnit", cError, xpath2, "N,U");
						asset.issueDate = getNodeDate(nodeInstrument, "IssueDate", cError, xpath2);
						asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cError, xpath2);
						asset.withholdingTaxRate = getNodeNumber(nodeInstrument, "WithholdingTaxRate", cError, xpath2);

						nodeInstrumentType = GetChildNode(nodeAssetDetails, "ShareClassType", cOK, xpath2);
						if (nodeInstrumentType !== undefined) {
							xpath3 = xpath2 + '/ShareClassType';
							asset.typeCode = getNodeText(nodeInstrumentType, "Code", cErrorMandatory, xpath3, 1, 32);
							asset.typeEarningUse = getNodeText(nodeInstrumentType, "EarningUse", cError, xpath3, 1, 32);
							asset.typeName = getNodeText(nodeInstrumentType, "Name", cError, xpath3, 1, 32);
							asset.typeDescription = getNodeText(nodeInstrumentType, "Description", cError, xpath3, 1, 32);
						}

						asset.exchangeTradedFund = getNodeBoolean(nodeInstrument, "ExchangeTradedFundFlag", cError, xpath2);

						if (asset.issueDate !== undefined && asset.issueDate > contentDate)
							AddResult(cWarning, xpath2, 'IssueDate ' + asset.issueDate + ' should be before ContentDate ' + contentDate);

						if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
							AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
					}
				}

				if (asset.assetType == "WA" /*Warrant*/) {
					nodeInstrument = GetChildNode(nodeAssetDetails, "Warrant", cErrorMandatory, xpath2);
					if (nodeInstrument !== undefined) {
						xpath2 = xpath2 + '/Warrant';
						asset.issuer = getCompany(nodeInstrument, "Issuer", cError, xpath2);
						asset.listing = getNodeItem(nodeInstrument, "Listing", cError, xpath2, "A,B,G,K,M,S,V,Y,Z");
						asset.issueDate = getNodeDate(nodeInstrument, "IssueDate", cError, xpath2);
						asset.basePrice = getNodeNumber(nodeInstrument, "BasePrice", cError, xpath2);
						asset.executionType = getNodeItem(nodeInstrument, "ExecutionType", cError, xpath2, "Issuer,Bearer,Both");
						asset.executionStyle = getNodeItem(nodeInstrument, "ExecutionStyle", cError, xpath2, "Europe,American,Asian,Bermuda,Other");
						asset.contractSize = getNodeNumber(nodeInstrument, "ContractSize", cErrorMandatory, xpath2);
						asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cErrorMandatory, xpath2);
						asset.callPut = getNodeItem(nodeInstrument, "CallPutIndicator", cErrorMandatory, xpath2, "CALL,PUT");
						asset.strikePrice = getCcyAmount(nodeInstrument, "StrikePrice", asset.ccy, cErrorMandatory, xpath2);
						asset.counterparty = getCompany(nodeInstrument, "Counterparty", cError, xpath2);

						if (asset.issueDate !== undefined && asset.issueDate > contentDate)
							AddResult(cWarning, xpath2, 'IssueDate ' + asset.issueDate + ' should be before ContentDate ' + contentDate);

						if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
							AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
					}
				}

				if (asset.assetType == "CE" /*Certificate*/) {
					nodeInstrument = GetChildNode(nodeAssetDetails, "Certificate", cErrorMandatory, xpath2);
					if (nodeInstrument !== undefined) {
						xpath2 = xpath2 + '/Certificate';
						asset.type = getNodeItem(nodeInstrument, "Type", cErrorMandatory, xpath2, "Commodity,Currency,Future,Index,Interest Rate,Security,Other");
						asset.stockMarket = getNodeText(nodeInstrument, "StockMarket", cError, xpath2, 1, 0);
						asset.issuer = getCompany(nodeInstrument, "Issuer", cError, xpath2);
						asset.issueDate = getNodeDate(nodeInstrument, "IssueDate", cError, xpath2);
						asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cError, xpath2);

						if (asset.issueDate !== undefined && asset.issueDate > contentDate)
							AddResult(cWarning, xpath2, 'IssueDate ' + asset.issueDate + ' should be before ContentDate ' + contentDate);

						if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
							AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
					}
				}

				if (asset.assetType == "OP" /*Option*/) {
					nodeInstrument = GetChildNode(nodeAssetDetails, "Option", cErrorMandatory, xpath2);
					if (nodeInstrument !== undefined) {
						xpath2 = xpath2 + '/Option';
						asset.type = getNodeItem(nodeInstrument, "Type", cErrorMandatory, xpath2, "BFO,BO,CFO,EFO,CO,IFO,IO,IRFO,IRO,OTCIB,SO,OTHER");
						asset.stockMarket = getNodeText(nodeInstrument, "StockMarket", cError, xpath2, 1, 0);
						asset.issuer = getCompany(nodeInstrument, "Issuer", cError, xpath2);
						asset.listing = getNodeItem(nodeInstrument, "Listing", cError, xpath2, "A,B,G,K,M,S,V,Y,Z");
						asset.basePrice = getNodeNumber(nodeInstrument, "BasePrice", cError, xpath2);
						asset.executionType = getNodeItem(nodeInstrument, "ExecutionType", cError, xpath2, "Issuer,Bearer,Both");
						asset.executionStyle = getNodeItem(nodeInstrument, "ExecutionStyle", cError, xpath2, "Europe,American,Asian,Bermuda,Other");
						asset.contractSize = getNodeNumber(nodeInstrument, "ContractSize", cErrorMandatory, xpath2);
						asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cErrorMandatory, xpath2);
						asset.callPut = getNodeItem(nodeInstrument, "CallPutIndicator", cErrorMandatory, xpath2, "CALL,PUT");
						asset.strikePrice = getCcyAmount(nodeInstrument, "StrikePrice", asset.ccy, cErrorMandatory, xpath2);
						asset.counterparty = getCompany(nodeInstrument, "Counterparty", cError, xpath2);
						// Underlyings

						if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
							AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
					}
				}

				if (asset.assetType == "FU" /*Future*/) {
					nodeInstrument = GetChildNode(nodeAssetDetails, "Future", cErrorMandatory, xpath2);
					if (nodeInstrument !== undefined) {
						xpath2 = xpath2 + '/Future';
						asset.type = getNodeItem(nodeInstrument, "Type", cErrorMandatory, xpath2, "BF,CF,EF,FRA,IF,IRF,MMF,OTHER");
						asset.stockMarket = getNodeText(nodeInstrument, "StockMarket", cError, xpath2, 1, 0);
						asset.listing = getNodeItem(nodeInstrument, "Listing", cError, xpath2, "A,B,G,K,M,S,V,Y,Z");
						asset.basePrice = getNodeNumber(nodeInstrument, "BasePrice", cError, xpath2);
						asset.contractSize = getNodeNumber(nodeInstrument, "ContractSize", cErrorMandatory, xpath2, 1);
						asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cErrorMandatory, xpath2);
						asset.counterparty = getCompany(nodeInstrument, "Counterparty", cError, xpath2);
						// Tick: TickSize + TickValue(Amounts)
						// Underlyings

						if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
							AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
					}
				}

				if (asset.assetType == "FX") {
				  nodeInstrument = GetChildNode(nodeAssetDetails, "FXForward", cErrorMandatory, xpath2);
				  if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/FXForward';
            asset.buyCcy = getNodeCurrency(nodeInstrument, "CurrencyBuy", cErrorMandatory, xpath2);
            asset.buyAmount = getNodeNumber(nodeInstrument, "AmountBuy", cErrorMandatory, xpath2, 1);
            asset.sellCcy = getNodeCurrency(nodeInstrument, "CurrencySell", cErrorMandatory, xpath2);
            asset.sellAmount = getNodeNumber(nodeInstrument, "AmountSell", cErrorMandatory, xpath2, 1);
            asset.agreedFxRate = getNodeNumber(nodeInstrument, "agreedFxRate", cError, xpath2);
            asset.startDate = getNodeDate(nodeInstrument, "StartDate", cError, xpath2);
            asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cErrorMandatory, xpath2);
            asset.counterparty = getCompany(nodeInstrument, "Counterparty", cErrorMandatory, xpath2);
            asset.deliverable = getNodeBoolean(nodeInstrument, "Deliverable", cError, xpath2);

            if (asset.buyCcy != undefined && asset.buyAmount != undefined && asset.sellCcy != undefined && asset.sellAmount != undefined) {
	            // buy/sell ccy/amount available
	            if (asset.buyCcy == asset.sellCcy) {
		            AddResult(cError, xpath2, 'CurrencyBuy equals CurrencySell (' + asset.buyCcy + ')');
		            status = cError;
	            }
	            else {
								status = cOK;
								var fxRate = getFxRate(asset.buyCcy, asset.sellCcy);
								if (fxRate !== undefined) {
									var estimatedSellAmount = asset.buyAmount / fxRate;
									var percDiff = ((asset.sellAmount - estimatedSellAmount) / estimatedSellAmount) * 100;
									var calcFxRate = asset.buyAmount / asset.sellAmount;
									if (Math.abs(percDiff) >= fxRatePercentageError || asset.buyAmount == asset.sellAmount) {
									  status = cError;
										AddResult(status, xpath2, 'Wrong FXForward details: ' + asset.sellAmount + ' ' + asset.sellCcy + ' --> ' + asset.buyAmount + ' ' + asset.buyCcy + ' till ' + asset.maturityDate + ' (fx-rate is '+ setDigits(calcFxRate,7) + ', but ' + setDigits(fxRate,7) + ' expected)');
									}
									else
										if (Math.abs(percDiff) >= fxRatePercentageWarning) {
											status = cWarning;
											AddResult(status, xpath2, 'Strange FXForward details: ' + asset.sellAmount + ' ' + asset.sellCcy + ' --> ' + asset.buyAmount + ' ' + asset.buyCcy + ' till ' + asset.maturityDate + ' (fx-rate is '+ setDigits(calcFxRate,7) + ', but ' + setDigits(fxRate,7) + ' expected)');
										}
								}
								if (status == cOK)
									AddResult(cOK, xpath2, 'FXForward details: ' + asset.sellAmount + ' ' + asset.sellCcy + ' --> ' + asset.buyAmount + ' ' + asset.buyCcy + ' till ' + asset.maturityDate);
	            }

	            if (asset.startDate !== undefined && asset.startDate > contentDate)
		            AddResult(cWarning, xpath2, 'StartDate ' + asset.startDate + ' should be before ContentDate ' + contentDate);

	            if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
		            AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
            }
          }
        }

        if (asset.assetType == "SW" /*Swap*/) {
          nodeInstrument = GetChildNode(nodeAssetDetails, "Swap", cErrorMandatory, xpath2);
          if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/Swap';
            asset.type = getNodeItem(nodeInstrument, "Type", cErrorMandatory, xpath2, "Currencyswap,Crosscurrencyswap,Creditdefaultswap,Indexswap,Totalreturnswap,Assetswap,Commodityswap,Interestrateswap,Other");
            asset.startDate = getNodeDate(nodeInstrument, "StartDate", cError, xpath2);
            asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cErrorMandatory, xpath2);
            asset.settlementDate = getNodeDate(nodeInstrument, "SettlementDate", cError, xpath2);
						asset.counterparty = getCompany(nodeInstrument, "Counterparty", cErrorMandatory, xpath2);
						// Legs

						if (asset.startDate !== undefined && asset.startDate > contentDate)
							AddResult(cWarning, xpath2, 'StartDate ' + asset.startDate + ' should be before ContentDate ' + contentDate);

						if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
							AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
					}
				}

        if (asset.assetType == "RP" /*Repo*/) {
          nodeInstrument = GetChildNode(nodeAssetDetails, "Repo", cErrorMandatory, xpath2);
          if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/Repo';
            asset.type = getNodeItem(nodeInstrument, "RepoType", cErrorMandatory, xpath2, "BSB,SBB");
            asset.issueDate = getNodeDate(nodeInstrument, "IssueDate", cErrorMandatory, xpath2);
						asset.baseValue = getNodeNumber(nodeInstrument, "BaseValueQuotationCurrency", cErrorMandatory, xpath2);
						asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cErrorMandatory, xpath2);
						asset.counterparty = getCompany(nodeInstrument, "Counterparty", cErrorMandatory, xpath2);
						asset.stockMarket = getNodeText(nodeInstrument, "StockMarket", cError, xpath2, 1, 0);
						asset.underlyingType = getNodeItem(nodeInstrument, "UnderlyingType", cErrorMandatory, xpath2, "Bond,Equity,GDR/ADR,Future,CTD,Frau,IRF,Index,Commodity,Fund Certificate, Index Certificate,Rights,US-Pools,Undecided");
						//TODO: InitialMargin (mandatory)
						asset.marginCallType = getNodeItem(nodeInstrument, "MarginCallType", cErrorMandatory, xpath2, "None,Contract,Pool");
						asset.pledgeType = getNodeItem(nodeInstrument, "PledgeType", cErrorMandatory, xpath2, "None,Pool");

						if (asset.issueDate !== undefined && asset.issueDate > contentDate)
							AddResult(cWarning, xpath2, 'IssueDate ' + asset.issueDate + ' should be before ContentDate ' + contentDate);

						if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
							AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
					}
				}

        if (asset.assetType == "FT" /*FixedTimeDeposit*/) {
          nodeInstrument = GetChildNode(nodeAssetDetails, "FixedTimeDeposit", cErrorMandatory, xpath2);
          if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/FixedTimeDeposit';
            asset.startDate = getNodeDate(nodeInstrument, "StartDate", cError, xpath2);
						asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cErrorMandatory, xpath2);
						asset.methodForCalculationOfInterest = getNodeText(nodeInstrument, "MethodForCalculationOfInterest", cError, xpath2, 0, 0);
						asset.interestRate = getNodeNumber(nodeInstrument, "InterestRate", cError, xpath2);
						asset.interestRateDebit = getNodeNumber(nodeInstrument, "InterestRateDebit", cError, xpath2);
						asset.interestRateCredit = getNodeNumber(nodeInstrument, "InterestRateCredit", cError, xpath2);
						asset.creditDebit = getNodeItem(nodeInstrument, "IndicatorCreditDebit", cError, xpath2, "Credit,Debit");
						asset.counterparty = getCompany(nodeInstrument, "Counterparty", cErrorMandatory, xpath2);

						if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
							AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
					}
				}

        if (asset.assetType == "CM" /*CallMoney*/) {
          nodeInstrument = GetChildNode(nodeAssetDetails, "CallMoney", cErrorMandatory, xpath2);
          if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/CallMoney';
            asset.startDate = getNodeDate(nodeInstrument, "StartDate", cError, xpath2);
						asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cErrorMandatory, xpath2);
						asset.methodForCalculationOfInterest = getNodeText(nodeInstrument, "MethodForCalculationOfInterest", cError, xpath2, 0, 0);
						asset.interestRate = getNodeNumber(nodeInstrument, "InterestRate", cError, xpath2);
						asset.interestRateDebit = getNodeNumber(nodeInstrument, "InterestRateDebit", cError, xpath2);
						asset.interestRateCredit = getNodeNumber(nodeInstrument, "InterestRateCredit", cError, xpath2);
						asset.creditDebit = getNodeItem(nodeInstrument, "IndicatorCreditDebit", cError, xpath2, "Credit,Debit");
						asset.counterparty = getCompany(nodeInstrument, "Counterparty", cErrorMandatory, xpath2);
						asset.collateralFlag = getNodeBoolean(nodeInstrument, "CollateralFlag", cError, xpath2);
						asset.collateralDirection = getNodeItem(nodeInstrument, "CollateralDirection", cError, xpath2, "PAID,RECEIVED");

						if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
							AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
					}
				}

        if (asset.assetType == "AC" /*Account*/) {
          nodeInstrument = GetChildNode(nodeAssetDetails, "Account", cErrorMandatory, xpath2);
          if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/Account';
						asset.creditDebit = getNodeItem(nodeInstrument, "IndicatorCreditDebit", cError, xpath2, "Credit,Debit");
						asset.accountNumber = getNodeInteger(nodeInstrument, "AccountNumber", cError, xpath2);
						asset.interestRateDebit = getNodeNumber(nodeInstrument, "InterestRateDebit", cError, xpath2);
						asset.interestRateCredit = getNodeNumber(nodeInstrument, "InterestRateCredit", cError, xpath2);
						asset.counterparty = getCompany(nodeInstrument, "Counterparty", cErrorMandatory, xpath2);
					}
				}

        if (asset.assetType == "FE" /*Fee*/) {
          nodeInstrument = GetChildNode(nodeAssetDetails, "Fee", cErrorMandatory, xpath2);
          if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/Fee';
						asset.type = getNodeText(nodeInstrument, "Type", cError, xpath2, 0, 0);
						asset.counterparty = getCompany(nodeInstrument, "Counterparty", cErrorMandatory, xpath2);
					}
				}

        if (asset.assetType == "RE" /*RealEstate*/) {
          nodeInstrument = GetChildNode(nodeAssetDetails, "RealEstate", cErrorMandatory, xpath2);
          if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/RealEstate';
						//InvestmentCosts
						//FirstRateAccrual (date)
						//DateOfPropertyTransaction
						//ConstructionYear
						//...
					}
				}

        if (asset.assetType == "RT" /*Real Estate Investment Trust*/) {
	        nodeInstrument = GetChildNode(nodeAssetDetails, "REIT", cErrorMandatory, xpath2);
	        if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/REIT';
						asset.issuer = getCompany(nodeInstrument, "Issuer", cError, xpath2);
						asset.listing = getNodeItem(nodeInstrument, "Listing", cError, xpath2, "A,B,G,K,M,S,V,Y,Z");
					}
				}

        if (asset.assetType == "LO" /*Loan*/) {
	        nodeInstrument = GetChildNode(nodeAssetDetails, "Loan", cErrorMandatory, xpath2);
	        if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/Loan';
						asset.fundRole = getNodeItem(nodeInstrument, "FundRole", cErrorMandatory, xpath2, "LENDER,BORROWER");
						asset.counterparty = getCompany(nodeInstrument, "Counterparty", cErrorMandatory, xpath2);
            asset.startDate = getNodeDate(nodeInstrument, "StartDate", cError, xpath2);
						asset.maturityDate = getNodeDate(nodeInstrument, "MaturityDate", cErrorMandatory, xpath2);
						//...

						if (asset.maturityDate !== undefined && asset.maturityDate < contentDate)
							AddResult(cWarning, xpath2, 'MaturityDate ' + asset.maturityDate + ' should be behind ContentDate ' + contentDate);
					}
				}

        if (asset.assetType == "RI" /*Right*/) {
          nodeInstrument = GetChildNode(nodeAssetDetails, "Right", cErrorMandatory, xpath2);
          if (nodeInstrument !== undefined) {
            xpath2 = xpath2 + '/Right';
						asset.type = getNodeText(nodeInstrument, "Type", cError, xpath2, 0, 0);
						asset.issuer = getCompany(nodeInstrument, "Issuer", cError, xpath2);
					}
				}
			}

			//TODO: CountrySpecificData

			asset.securitized = getNodeBoolean(nodeAsset, "Securitized", cError, xpath);

			//TODO: Ratings

			asset.realEstateCompany = getCompany(nodeAsset, "RealEstateCompany", cError, xpath);

			//TODO: Classifications

			//TODO: CustomAttributes

			//if (assetComplete)
	    aAssetMasterData.push(asset);
	  }
  }

  /*
  <Funds>
	<Fund>
	  <Identifiers>
		<LEI>2138000SAMPLE00LEI00</LEI>
	  </Identifiers>
      <Names>
        <OfficialName>FundsXML Sample Fund</OfficialName>
      </Names>
      <Currency>EUR</Currency>
      <SingleFundFlag>true</SingleFundFlag>
      <FundDynamicData>
        <TotalAssetValues>
          <TotalAssetValue>
            <NavDate>2017-08-12</NavDate>
            <TotalAssetNature>OFFICIAL</TotalAssetNature>
            <TotalNetAssetValue>
              <Amount ccy="EUR">901067.30</Amount>
            </TotalNetAssetValue>
          </TotalAssetValue>
        </TotalAssetValues>
        <Portfolios>
  */

  currentUniqueID = undefined;

  // Initialize funds array
  aFunds = new Array();

  // Get <Funds> node (is mandatory for this check)
  //nodeFunds = rootNode.getElementsByTagName("Funds")[0];
  nodeFunds = GetChildNode(rootNode, "Funds", cErrorMandatory, xpath);

  if (nodeFunds === undefined) {
    //AddResult(cError, xpath, 'Node <Funds> not found (below root node <FundsXML4>)');
    return false;
  };

  // Get list of <Fund> nodes
  xpath = '/FundsXML4/Funds';
  nlFund = nodeFunds.getElementsByTagName("Fund");

  if (nlFund.length == 0) {
    AddResult(cError, xpath, 'Node <Fund> missing');
    //statusText.innerHTML = escapeHtml('Node <Funds> not found (below root node <FundsXML4>)');
    return false;
  };

  //------------------------------------------------------------------------------------------------------------------------
  // MAIN FUND LOOP
  //
  currentModule = modFunds;

  for (var fundIndex = 0; fundIndex < nlFund.length; fundIndex++) {
    var fund = new Object();
    var nodeFund = nlFund[fundIndex];
    xpath = '/FundsXML4/Funds/Fund[' + fundIndex + ']';

    fund.identifiers = getIdentifiers(nodeFund, "Identifiers", cErrorMandatory, "FUND", xpath);
		//AddResult(cOK, xpath + '/Identifiers', '<LEI> = "' + fund.identifiers.LEI + '"');
    fund.names = getNames(nodeFund, cErrorMandatory, xpath);
		//AddResult(cOK, xpath + '/Names', '<OfficialName> = "' + fund.names.officialName + '"');
    fund.ccy = getNodeCurrency(nodeFund, "Currency", cAllMandatory, xpath);
    fund.singleFund = getNodeBoolean(nodeFund, "SingleFundFlag", cAllMandatory, xpath);
    fund.dataSupplier = getDataSupplier(nodeFund, cError, xpath);

		var nodeFundStaticData = GetChildNode(nodeFund, "FundStaticData", cOK, xpath);
		if (nodeFundStaticData !== undefined) {
			xpath2 = xpath + '/FundStaticData';
      currentModule = modFundStaticData;

			fund.domicilyCountry = getNodeText(nodeFundStaticData, "DomicilyCountry", cError, xpath2, 2, 2);
			fund.listedLegalStructure = getNodeText(nodeFundStaticData, "ListedLegalStructure", cError, xpath2, 0, 100);  // list of defined items
			fund.unlistedLegalStructure = getNodeText(nodeFundStaticData, "UnlistedLegalStructure", cError, xpath2, 0, 200);
			fund.inceptionDate = getNodeDate(nodeFundStaticData, "InceptionDate", cError, xpath2);
      fund.startOfFiscalYear = getFiscalYear(nodeFundStaticData, "StartOfFiscalYear", cError, xpath2);
      fund.endOfFiscalYear = getFiscalYear(nodeFundStaticData, "EndOfFiscalYear", cError, xpath2);
			fund.openClosed = getNodeItem(nodeFundStaticData, "OpenClosedEnded", cError, xpath2, 'OPEN,CLOSED');
			fund.closedType = getNodeItem(nodeFundStaticData, "ClosedType", cError, xpath2, 'HARD,SOFT');
			fund.maturityDate = getNodeDate(nodeFundStaticData, "MaturityDate", cError, xpath2);
			fund.liquidationDate = getNodeDate(nodeFundStaticData, "LiquidationDate", cError, xpath2);
			fund.liquidationReason = getNodeItem(nodeFundStaticData, "LiquidationReason", cError, xpath2, 'CLIENT EXIT,LOW VOLUME,MERGER,OTHER');
			fund.administrator = getCompany(nodeFundStaticData, "Administrator", cError, xpath2);
			fund.auditor = getCompany(nodeFundStaticData, "Auditor", cError, xpath2);
			fund.custodian = getCompany(nodeFundStaticData, "Custodian", cError, xpath2);
			fund.investmentCompany = getCompany(nodeFundStaticData, "InvestmentCompany", cError, xpath2);
			// FundsTexts
			// SelfManagedSICAVFlag
			// CustomAttributes
			// Classifications
			// Companies
		}

    aFunds.push(fund);

    currentModule = modFunds;
    // Get <FundDynamicData> node
		var nodeFundDynamicData = GetChildNode(nodeFund, "FundDynamicData", cWarning, xpath);

    if (nodeFundDynamicData !== undefined) {
			xpath2 = xpath + '/FundDynamicData';
      currentModule = modFundDynamicData;

      getTotalAssetValues(nodeFundDynamicData, contentDate, fundIndex, cAllMandatory, xpath2);
      //aFunds[fundIndex].fundVolume = getTotalNetAssetValue(nodeFundDynamicData, contentDate, fund.ccy);

      if (isPositiveNumber(aFunds[fundIndex].fundVolume)) {
        getPortfolios(nodeFundDynamicData, contentDate, fundIndex, cAllMandatory, xpath2);
      }
      else {
        errorText = "Fund node " + (fundIndex+1) + " (" + fund.name + "): no matching TotalNetAssetValue found";
        //anErrors.push(errorText);
      }
    }

    currentModule = modFunds;
    currentUniqueID = undefined;

    if (fund.singleFund == true) {
		  var nodeSingleFund = GetChildNode(nodeFund, "SingleFund", cWarning, xpath);

		  if (nodeSingleFund !== undefined) {
			  xpath2 = xpath + '/SingleFund';
        currentModule = modFundStaticData;

		    var nodeSingleFundStaticData = GetChildNode(nodeSingleFund, "SingleFundStaticData", cOK, xpath2);
		    if (nodeSingleFundStaticData !== undefined) {
			    xpath3 = xpath2 + '/SingleFundStaticData';
          currentModule = modFundStaticData;

			    aFunds[fundIndex].advisor = getCompany(nodeSingleFundStaticData, "Advisor", cError, xpath2);
          // Managers
          // Policies
          // StockExchanges
          aFunds[fundIndex].exchangeTradedFlag = getNodeBoolean(nodeSingleFundStaticData, "ExchangeTradedFlag", cError, xpath2);
          aFunds[fundIndex].fundOfFundFlag = getNodeBoolean(nodeSingleFundStaticData, "FundOfFundFlag", cError, xpath2);
          aFunds[fundIndex].socialResponsibleFlag = getNodeBoolean(nodeSingleFundStaticData, "SocialResponsibleFlag", cError, xpath2);
			    aFunds[fundIndex].managementType = getNodeItem(nodeSingleFundStaticData, "ManagementType", cError, xpath2, 'ACTIVE,PASSIVE');
          aFunds[fundIndex].pricePublishedFlag = getNodeBoolean(nodeSingleFundStaticData, "PricePublishedFlag", cError, xpath2);
			    aFunds[fundIndex].salesCategory = getNodeItem(nodeSingleFundStaticData, "SalesCategory", cError, xpath2, 'PUBLIC,RETAIL,RETAIL-HNW,SPECIAL');
          // InvestmentHorizon
          // IsFeederFor
          // IsMasterFor
		    }

	      aFunds[fundIndex].shareClasses = getShareClasses(nodeSingleFund, fundIndex, cErrorMandatory /*cError,cWarning,cOK*/, xpath2);

      }
    }

		nodeCountrySpecificData = GetChildNode(nodeFund, "CountrySpecificData", cOK, xpath);
		if (nodeModuleUsage !== undefined) {
			xpath += "/CountrySpecificData";
			nodeAT = GetChildNode(nodeCountrySpecificData, "AT", cOK, xpath);
			if (nodeAT !== undefined) {
				xpath2 = xpath + "/AT";
				nodeOeNB = GetChildNode(nodeAT, "OeNB", cOK, xpath2);
				if (nodeOeNB !== undefined) {
					var oenbData = new Object();
					xpath2 += "/OeNB";
					oenbData.subscription = getCcyAmount(nodeOeNB, "Subscription", 'EUR', cAllOptional, xpath2);
					oenbData.redemption = getCcyAmount(nodeOeNB, "Redemption", 'EUR', cAllOptional, xpath2);
					oenbData.distribution = getCcyAmount(nodeOeNB, "Distribution", 'EUR', cAllOptional, xpath2);
					oenbData.totalNetAssetPrevMonth = getCcyAmount(nodeOeNB, "TotalNetAssetPreviousMonth", 'EUR', cAllOptional, xpath2);
					oenbData.reportType = getNodeItem(nodeOeNB, "Meldungstyp", cAllMandatory, xpath2, 'OFI');
					//
					aFunds[fundIndex].oenbData = oenbData;
				}
			}
		}
  } // main fund loop

  statusText.innerHTML = "Funds found: " + aFunds.length;

  // -----------------------------------------------------------------------------------------------------------------
  // analyse RegulatoryReportings (if existing)
  currentModule = modRegulatoryReporting;
  xpath = '/FundsXML4';

	nodeRegulatoryReportings = GetChildNode(rootNode, "RegulatoryReportings", cOK, xpath);
	if (nodeRegulatoryReportings !== undefined) {
    xpath += '/RegulatoryReportings';

    nodeDirectReporting = GetChildNode(nodeRegulatoryReportings, "DirectReporting", cOK, xpath);
	  if (nodeDirectReporting !== undefined) {
      xpath2 = xpath + '/DirectReporting';
      /*
      nodeTemp = GetChildNode(nodeDirectReporting, "EMIR", cOK, xpath2);
	    if (nodeTemp !== undefined)
        AnalyseRegRepEMIR(nodeTemp, xpath2 + '/EMIR');

      nodeTemp = GetChildNode(nodeDirectReporting, "KIIDs", cOK, xpath2);
	    if (nodeTemp !== undefined)
        AnalyseRegRepKIIDs(nodeTemp, xpath2 + '/KIIDs');
      */
      nodeTemp = GetChildNode(nodeDirectReporting, "EMT", cOK, xpath2);
	    if (nodeTemp !== undefined)
        AnalyseRegRepEMT(nodeTemp, contentDate, xpath2 + '/EMT');
    }

    nodeIndirectReporting = GetChildNode(nodeRegulatoryReportings, "IndirectReporting", cOK, xpath);
	  if (nodeIndirectReporting !== undefined) {
      xpath2 = xpath + '/IndirectReporting';
      /*
      nodeTemp = GetChildNode(nodeIndirectReporting, "TripartiteTemplateSolvencyII", cOK, xpath2);
	    if (nodeTemp !== undefined)
        AnalyseRegRepTPT(nodeTemp, xpath2 + '/TripartiteTemplateSolvencyII');

      nodeTemp = GetChildNode(nodeIndirectReporting, "PRIIPS", cOK, xpath2);
	    if (nodeTemp !== undefined)
        AnalyseRegRepPRIIPS(nodeTemp, xpath2 + '/PRIIPS');
      */
    }
  }

  /*
  if (nlFund.length > 0) {
    var fundIndex = 0;

    // Sort array with descending absolute values of amount
    aFunds[fundIndex].ccySums.sort(function(a, b) {
      return Math.abs(b.amount) - Math.abs(a.amount);
    });

    aFunds[fundIndex].ccyHedgedSums.sort(function(a, b) {
      return Math.abs(b.amount) - Math.abs(a.amount);
    });

    //drawFundCharts(fundIndex, canvas);
  }

  //ShowResult();
  */

  // update grids with check results
	updateSummaryStatus();
  gridOptionsSummary.api.setRowData(gridDataSummary);
  //gridOptionsCheckResults.api.setRowData(gridDataCheckResults);
	filterResults('', '');

  var y = getTopPos(buttonAnalyseFundsXmlDoc);
  window.scrollTo(0, y - 8);  // -150
}


function exportCheckResultsToCSV()
{
  var params = {
	  skipHeader: false,
	  skipFooters: true,
	  skipGroups: true,
	  columnSeparator: ';',
	  fileName: "CheckResults.csv"
  };

  gridOptionsCheckResults.api.exportDataAsCsv(params);
}


function RefreshPage()
{
  window.scrollTo(0, 0);
  location.reload();
}

</script>

<h1>Format and Content Check of FundsXML4-Documents</h1>

<main role="main">
  <form name="Formular" action="javascript:AnalyseFundsXmlDoc();" width="100%">
  <table border="0" width="100%">
		<tr>
			<td class="myheader" colspan="8">
				FundsXML V4.x document to be analysed:
        <input type="file" id="file-input" />
			</td>
		</tr>
		<tr>
			<td class="source" colspan="8" width1="100%">
				<textarea cols="130" rows="42" id="SourceText"></textarea>
			</td>
		</tr>
		<tr>
			<td colspan="8">
				Load sample FundsXML4 document:
				<button type="button" class="sample" id="LoadSample1" onclick="javascript:LoadSampleDoc('FundsXML4_Sample_Holdings1.xml');">Holdings</button>
				<button type="button" class="sample" id="LoadSample2" onclick="javascript:LoadSampleDoc('FundsXML4_Sample_Document.xml');">Schema Sample</button>
				<button type="button" class="sample" id="LoadSample3" onclick="javascript:LoadSampleDoc('FundsXML4_Bad_Sample.xml');">Bad Sample</button>
				<button type="button" class="clear" id="ClearInputArea" onclick="javascript:sourceText.innerHTML='';">Clear Input Area</button>
			</td>
		</tr>
		<tr>
			<td colspan="8">
				<!--button id="Generate-Document" type="submit">Generate FundsXML Document</button-->
				<button type="button" id="AnalyseFundsXmlDocButton" onclick="javascript:AnalyseFundsXmlDoc();">Analyse FundsXML4 Document</button>
			</td>
		</tr>

		<tr>
			<td>Status:</td><td colspan="7" id="Status" width1="99%" align="left">Ready</td>
		</tr>

		<tr>
			<td colspan="8">&nbsp;</td>
		</tr>
		<tr>
			<td colspan="8"><b>SUMMARY:</b></td>
		</tr>
		<tr>
			<td colspan="8">
				<div id="SummaryGrid" style="height:276px; width:100%; width1:850px;" class="ag-theme-balham"></div>
			</td>
		</tr>

		<script type="text/javascript" charset="utf-8">
		var eGridDiv = document.querySelector('#SummaryGrid');
		new agGrid.Grid(eGridDiv, gridOptionsSummary);
		</script>

		<tr>
			<td colspan="8">&nbsp;</td>
		</tr>
		<tr>
			<td colspan="8"><b>CHECK RESULTS IN DETAIL:</b>&nbsp;&nbsp;&nbsp;&nbsp;(click above for related details)</td>
		</tr>
		<tr>
			<td colspan="8">
				<div id="CheckResultsGrid" style="height: 708px; width:100%; width1:850px;" class="ag-theme-balham"></div>
			</td>
		</tr>

		<script type="text/javascript" charset="utf-8">
		// lookup the container we want the Grid to use
		var eGridDiv = document.querySelector('#CheckResultsGrid');

		// create the grid passing in the div to use together with the columns & data we want to use
		new agGrid.Grid(eGridDiv, gridOptionsCheckResults);

		</script>

		<tr>
			<td colspan="8">
				<button type="button" class="sample" id="exportResultsToCSV" onclick="javascript:exportCheckResultsToCSV();">CSV-Export</button>
			</td>
		</tr>

		<tr>
			<td colspan="8"><br>Text protocol:</td>
		</tr>
		<tr>
			<td colspan="8">
				<textarea cols="130" rows="40" class="result" id="ResultArea"></textarea>
			</td>
		</tr>
		<tr>
			<td colspan="8">
				<button type="button" id="Refresh-Page" onclick="javascript:RefreshPage();">Analyse New FundsXML V4.x Document</button>
			</td>
			<!--td class="author" colspan="2">Written by Peter Raffelsberger</td-->
		</tr>
		<tr class="about">
			<td class="about" colspan="8">
				Version 1.0 as of November 10th, 2018<br>
				<br>
				Currently the following sections are checked:<br>
				- ControlData<br>
				- Funds (including Identifiers and FundStaticData)<br>
				- FundDynamicData (TotalAssetValues, Positions and Transactions)<br>
				- SingleFund (parts of SingleFundStaticData, parts of ShareClasses)<br>
				- AssetMasterData (mandatory nodes for all asset types)<br>
        - RegulatoryReporting (EMT)<br>
				- CountrySpecificData (parts of AT)<br>
				<br>
				Not supported right now:<br>
				- Earnings, PositionsDecomposed, BreakDowns, RiskCodes<br>
				- Segments, Umbrella Structures<br>
				- Portfolio data for segments and share classes<br>
				- Documents<br>
				- RegulatoryReporting (excluding EMT)<br>
				- CountrySpecificData (parts)<br>
				- Large documents (due to browser memory limits)<br>
				<br>
				This tool is written completely in JavaScript, so the analyzed FundsXML data is processed locally in your browser environment.<br>
				Internet access is needed for loading the AG-Grid library only. This html document can be stored and used locally on your pc or intranet if you like.<br>
				<br>
				Written by Peter Raffelsberger
      </td>
    </tr>
  </table>
  </form>
</main>

<script type="text/javascript">

sourceText = document.getElementById('SourceText');
sourceText.innerHTML = '';
resultArea = document.getElementById('ResultArea');
buttonAnalyseFundsXmlDoc = document.getElementById("AnalyseFundsXmlDocButton");

window.scrollTo(0, 0);

//initializeFxRates();
//initializeSecurities();
//initializePortfolio();

function displayContents(contents) {
  //var element = document.getElementById('file-content');
  sourceText.textContent = contents;
}

function readSingleFile(e) {
  var file = e.target.files[0];
  if (!file) {
    return;
  }
  var reader = new FileReader();
  reader.onload = function(e) {
    var contents = e.target.result;
    displayContents(contents);
  };
  reader.readAsText(file);
}

//<input type="file" id="file-input" />
document.getElementById('file-input').addEventListener('change', readSingleFile, false);

</script>

</body>
</html>