@ind-rcg/plugins-printengine 246.1010.0

package/dist/dev/src/contractToIntermediateJSONClass.js

@@ -0,0 +1,1659 @@
+/*
+ * FILE_HEADER
+ */
+'use strict';
+const parser = require('xml-js');
+const _ = require('lodash');
+const Localization = require('./localizationClass');
+const MacroHandler = require('./macroHandlerClass');
+const Format = require('./formatClass');
+const LogClass = require('./logClass');
+const TableCellIdentifier = require('./tableCellIdentifier');
+
+const EACH_NODE = "each";
+const TABLE_NODE = "table";
+const TBODY_NODE = "tbody";
+const THEAD_NODE = "thead";
+const HEADER_NODE = "header";
+const FOOTER_NODE = "footer";
+const PRINT_LAYOUT_NODE = "PrintLayout";
+const REPORT_LAYOUT_NODE = "ReportLayout";
+const DECLARATIONS_NODE = "Declarations";
+const DOCUMENT_PROPERTIES_NODE = "DocumentProperties";
+const PROPERTY_NODE = "Property";
+const H1 = "h1";
+const H2 = "h2";
+const PARAGRAPH = "p";
+const IMAGE = "img";
+const TR_NODE = "tr";
+const TH_NODE = "th";
+const TD_NODE = "td";
+const SUM_NODE = "sum";
+
+const FILTERS_NODE = "filters";
+const FILTER_NODE = "filter";
+const ORDERCRITERIA_NODE = "orderCriteria";
+const ORDERCRITERION_NODE = "orderCriterion";
+const CORRELATION_NODE = "correlation";
+
+const COMPAREMODE_DEFAULT = "STRING";
+const COMPAREMODE_NUMBER = "NUMBER";
+
+const DIV_NODE = "div";
+const DIV_VISIBILITY_NODE = "visibility";
+const DIV_VISIBILITY_BINDING_NODE = "visibilityBinding";
+const DIV_VISIBILITY_CONDITION_NODE = "visibilityCondition";
+const SIGNATURE_SIZE_LIMIT = 200 * 1024;
+
+const ELEMENT_TYPE = {
+    "TEXT": "text",
+    "ELEMENT": "element",
+    "COMMENT": "comment"
+};
+
+class ContractToIntermediateJSON {
+    constructor(log) {
+        if(!(log instanceof LogClass)) {
+            throw new Error("Invalid constructor parameters");
+        }
+        this.__log = log;
+        // addParent: true,
+        this.__xmlParserLibraryOptions = {
+            spaces: 2,
+            compact: false
+        };
+
+        this.__printLayoutName = null;
+        this.__declarationsNode = null;
+        this.__localization = null;
+        this.__toggles = null;
+        this.__macroHandler = new MacroHandler(log);
+        this.__integerStringRegExp = /^\d+$/g;
+
+        this.__decimalSeparator = ".";
+        this.__thousandSeparator = ",";
+        this.__format = null;
+        this.__clearAllCaches();
+    }
+
+    __clearAllCaches(){
+        this.__tableIndex = {};
+        this.__sumTdThList = [];
+        this.__eachCache = {};
+        this.__divCache = [];
+    }
+
+    __checkDataForDeclaredItems(params, declarationNode){
+        let errorMessage = "";
+        let bos = params.getBOs();
+        let images = params.getImages();
+
+        let dataMissing = function dataMissing(itemType, itemName) {
+            let dataMissingMsg = `Missing declared ${itemType} "${itemName}" in print data.`;
+            if(errorMessage.length === 0) {
+                errorMessage = errorMessage + dataMissingMsg;
+            } else {
+                errorMessage = errorMessage + "\n" + dataMissingMsg;
+            }
+        };
+
+        if(!_.isNil(declarationNode) && !_.isNil(declarationNode.elements)) {
+            _.forEach(declarationNode.elements, (dataDeclaration) => {
+                if(!_.isNil(dataDeclaration.attributes)){
+                    let itemName = dataDeclaration.attributes.name;
+                    if(!_.isNil(dataDeclaration.attributes.type)) {
+                        if (dataDeclaration.attributes.type === "Image") {
+                            if(!_.isNil(itemName) && _.isNil(images[itemName])){
+                                dataMissing("Image", itemName);
+                            }
+                        } else if (dataDeclaration.attributes.type === "Signature") {
+                            if(!_.isNil(itemName) && _.isNil(images[itemName])){
+                                dataMissing("Signature", itemName);
+                            }
+                        } else {
+                            if(!_.isNil(itemName) && _.isNil(bos[itemName])){
+                                dataMissing("BO", itemName);
+                            }
+                        }
+                    }
+                }
+            });
+
+            if(errorMessage.length > 0){
+                throw new Error(errorMessage);
+            }
+        }
+    }
+    __checkInput(contract, params) {
+        if(_.isNil(params) || !_.isObject(params) || _.isArray(params)) {
+            throw new Error("Invalid value for parameter 'params'.");
+        }
+        if(!_.isString(contract)) {
+            throw new Error("Invalid value for parameter 'contract'.");
+        }
+    }
+
+    toJson(contract, params) {
+        this.__checkInput(contract, params);
+        this.__clearAllCaches();
+        this.__toggles = params.getToggles();
+        this.__format = new Format();
+        this.__localization = new Localization(params.getLocalization());
+
+        this.__decimalSeparator = this.__localization.separatorDecimal;
+        this.__thousandSeparator = this.__localization.separatorThousand;
+
+        let contractJson = this.__parse(contract);
+
+        this.__declarationsNode = this.__getDeclarationsNode(contractJson);
+        this.__checkDataForDeclaredItems(params, this.__declarationsNode);
+
+        this.__walkParseTree(contractJson, {}, "", params);
+
+        let printLayoutNode = this.__findPrintLayoutNode(contractJson);
+        let reportLayout = _.find(printLayoutNode.elements, {name:REPORT_LAYOUT_NODE});
+
+        if(_.isNil(reportLayout)) {
+            throw new Error("Missing ReportLayout node in PrintLayout.");
+        }            
+        
+        this.__processDivs(params);
+        this.__postProcessReportLayout(reportLayout);
+        this.__processSumRecords();      
+        
+        this.__addWatermark(reportLayout, params);
+        this.__configureAutomaticPageBreak(reportLayout, params);
+
+        let documentPropertiesRaw = _.find(printLayoutNode.elements, {name:DOCUMENT_PROPERTIES_NODE});
+        let documentProperties = this.__reformatDocumentProperties(documentPropertiesRaw);    
+
+        return {"reportLayout": reportLayout, "documentProperties": documentProperties};
+    }
+
+    __processDivs(params) {
+        if (!_.isNil(this.__divCache) && _.isArray(this.__divCache)) {
+
+            for (let index = 0; index < this.__divCache.length; index++) {
+                const divData = this.__divCache[index];
+
+                let result = this.__checkForDivToBeVisible(divData.divNode, params);
+                if (result) {
+                    // rescue div children and put them in parent elements
+                    let nodes = _.filter(divData.divNode.elements, node => node.type === ELEMENT_TYPE.ELEMENT && node.name !== DIV_VISIBILITY_NODE);
+                    if (!_.isNil(nodes) && _.isArray(nodes)) {
+                        // remember div id for future styling / layouting ...
+                        _.forEach(nodes, node => {
+                            this.__ensureAttributes(node);
+                            node.attributes.div = divData.id;
+                        });
+                        let divIndex = _.findIndex(divData.parentNode.elements, node => _.isEqual(node, divData.divNode));
+                        divData.parentNode.elements.splice(divIndex, 0, ..._.cloneDeep(nodes));
+                    }
+                }
+                // remove div from parent
+                _.remove(divData.parentNode.elements, node => _.isEqual(node, divData.divNode));                                
+            }
+
+        }
+    }
+
+    __postProcessReportLayout(reportLayoutNode) {
+        // get header node
+        let headerNode = _.find(reportLayoutNode.elements, {name: HEADER_NODE});
+        if (!_.isNil(headerNode)) {
+            // => check header node and remove empty tables
+            this.__removeEmptyTables(headerNode);            
+        }
+        // get footer node
+        let footerNode = _.find(reportLayoutNode.elements, {name: FOOTER_NODE});
+        if (!_.isNil(footerNode)) {
+            // => check footer node and remove empty tables
+            this.__removeEmptyTables(footerNode);
+        }      
+        // => check reportlayout node and remove empty tables & divs
+        this.__removeEmptyTables(reportLayoutNode);
+    }
+
+    __removeEmptyTables(containerNode) {
+        if (_.isNil(containerNode) || (!_.isNil(containerNode) && !_.isUndefined(containerNode.elements) && containerNode.elements.length === 0)) {
+            return;
+        }
+        let tablesToRemove = [];
+        _.forEach(containerNode.elements, node => {
+            if (node.type === ELEMENT_TYPE.ELEMENT && node.name === TABLE_NODE && node.toBeRemoved) {
+                tablesToRemove.push(node);
+            }
+        });
+        if (tablesToRemove.length > 0) {
+            _.forEach(tablesToRemove, tableNode => {
+                _.remove(containerNode.elements, node => _.isEqual(node, tableNode));
+            });
+        }
+    }
+
+    __addWatermark(reportLayout, params){
+        if(_.isNil(reportLayout)){
+            return;
+        }
+        this.__ensureAttributes(reportLayout);
+        let watermarkInMetadata = params.getMetadata()[params.getMetadataKeys().WATERMARK];
+        if(_.isString(watermarkInMetadata) &&  _.trim(watermarkInMetadata) !== "") {
+            reportLayout.attributes.watermark = watermarkInMetadata;
+        } else if (!_.isNil(watermarkInMetadata) && !_.isString(watermarkInMetadata)) {
+            this.__log.error("Invalid value for watermark.");
+        }
+
+    }
+    
+    __configureAutomaticPageBreak(reportLayout, params){
+        if(_.isNil(reportLayout)){
+            return;
+        }
+        this.__ensureAttributes(reportLayout);   
+        let automaticPageBreak = false; // default    
+        let automaticPageBreakInMetadata = params.getMetadata()[params.getMetadataKeys().AUTOMATIC_PAGEBREAK];
+        if(!_.isNil(automaticPageBreakInMetadata) && _.isBoolean(automaticPageBreakInMetadata)) {
+            automaticPageBreak = automaticPageBreakInMetadata;         
+        } 
+        reportLayout.attributes.automaticPageBreak = automaticPageBreak;
+    }
+
+    __reformatDocumentProperties(documentPropertiesRaw){
+        let result = {};
+        if(!_.isNil(documentPropertiesRaw)){
+            // this means the contract has document properties set
+            _.forEach(documentPropertiesRaw.elements, ele => {
+
+                if(ele.type === ELEMENT_TYPE.ELEMENT){
+                    let sanitizedKey = ele.attributes.key.replace(/\s/g, "");
+                    result[sanitizedKey]= ele.attributes.value;
+                }
+            });
+        }
+        return result;
+    }
+
+    __findPrintLayoutNode(contractJson) {
+        let printLayoutNode = _.find(contractJson.elements, {name:PRINT_LAYOUT_NODE});
+        if(_.isNil(printLayoutNode)) {
+            throw new Error("Missing PrintLayout node.");
+        }
+        return printLayoutNode;
+    }
+
+    __getDeclarationsNode(contractJson) {
+        let printLayoutNode = this.__findPrintLayoutNode(contractJson);
+        let declarationsNode = _.find(printLayoutNode.elements, {name: DECLARATIONS_NODE});
+        if(_.isNil(declarationsNode)) {
+            declarationsNode = {};
+        }
+        return declarationsNode;
+    }
+    __newXMLconvertibleJsonNode(type, children, otherAttributes) {
+        let newNode = {
+            "type": type
+        };
+        if(!_.isNil(children)) {
+            newNode.elements =  _.castArray(children);
+        }
+        _.assign(newNode, otherAttributes);
+        return newNode;
+    }
+
+    __walkParseTree(contractJson, parentElement, parentName, params) {
+        // processing ...
+        this.__processCurrentElement(contractJson, parentElement, parentName, params);
+        // recursion ...
+        if(!_.isNil(contractJson.elements)) {
+            _.remove(contractJson.elements, (ele)=> {
+                if (ele.type === ELEMENT_TYPE.COMMENT) {
+                    return true;
+                } else {
+                    return false;
+                }
+            });
+            _.forEach(contractJson.elements, (ele) => {
+                this.__walkParseTree(ele, contractJson, contractJson.name, params);
+            });
+        }
+        // post-processing ...
+        this.__postProcessCurrentElement(contractJson);
+    }
+
+    __postProcessCurrentElement(currentJsonElement) {
+        if (!_.isNil(currentJsonElement)) {
+            if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT) {
+                if (currentJsonElement.name === TR_NODE) {
+
+                    // perform colSpan handling ...
+                    this.__applyColSpanHandling(currentJsonElement);
+
+                } else if (currentJsonElement.name === TABLE_NODE) {
+
+                    // perform rowSpan handling ...
+                    this.__applyRowSpanHandling(currentJsonElement);
+                    // normalize table ...
+                    this.__normalizeTable(currentJsonElement);
+                    // check for empty table ...
+                    this.__checkForEmptyTable(currentJsonElement);
+
+                } 
+            }
+        }
+    }
+
+    __checkForDivToBeVisible(divNode, params) {
+        let result = true;
+        if (!_.isNil(divNode) && _.isArray(divNode.elements)) { 
+
+            // set result to 'true' for easier evaluation ...        
+            let divVisibilityNode = _.find(divNode.elements, {name: DIV_VISIBILITY_NODE});
+            if (!_.isNil(divVisibilityNode) && _.isArray(divVisibilityNode.elements)) {
+
+                // check for visibilityBinding elements ...
+                let divVisibilityBindingNodes = _.filter(divVisibilityNode.elements, {name: DIV_VISIBILITY_BINDING_NODE});
+                if (!_.isNil(divVisibilityBindingNodes) && _.isArray(divVisibilityBindingNodes) && divVisibilityBindingNodes.length > 0) {
+                    for (let i = 0; i < divVisibilityBindingNodes.length; i++) {
+                        // process visibilityBinding ...
+                        let divVisibilityBindingNode = divVisibilityBindingNodes[i];
+                        result = this.__evaluateVisibilityBinding(divVisibilityBindingNode, params);
+                        // exit if visibility criteria cannot be met ...
+                        if (!result) {
+                            break;
+                        }
+                    }
+                }
+                
+                if (result) {
+                    // check for visibilityCondition elements ...
+                    let divVisibilityConditionNodes = _.filter(divVisibilityNode.elements, {name: DIV_VISIBILITY_CONDITION_NODE});
+                    if (!_.isNil(divVisibilityConditionNodes) && _.isArray(divVisibilityConditionNodes) && divVisibilityConditionNodes.length > 0) {
+                        for (let i = 0; i < divVisibilityConditionNodes.length; i++) {
+                            // process visibilityCondition ...
+                            let divVisibilityConditionNode = divVisibilityConditionNodes[i];
+                            result = this.__evaluateVisibilityCondition(divVisibilityConditionNode);
+                            // exit if visibility criteria cannot be met ...
+                            if (!result) {
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                // => remove visibility node ...
+                _.remove(divNode.elements, node => (node.type === ELEMENT_TYPE.ELEMENT && node.name === DIV_VISIBILITY_NODE));
+            } 
+            
+        }
+        return result;
+    }
+
+    __evaluateVisibilityBinding(visiblityBindingNode, params) {
+        let result = true;
+
+        // <visiblityBinding binding="{{Declarations::header.itemCount}}" value="0" operator="GT" compareMode="NUMBER" />
+        if (!_.isNil(visiblityBindingNode)) {
+
+            let expression = this.__getVisibilityExpression(visiblityBindingNode, params);
+            if (!_.isNil(expression) && _.isFunction(expression)) {
+                result = expression();
+            } 
+        }
+
+        return result;
+    }
+
+    __getVisibilityExpression(visiblityBindingOrCondition, params) {
+        let expression = null;
+
+        // extract attributes
+        let binding = null;
+        let eachName = null;
+        let compareMode = COMPAREMODE_DEFAULT;
+        let operator = visiblityBindingOrCondition.attributes.operator;
+        let value = visiblityBindingOrCondition.attributes.value;
+        let comparisonValue = null;   
+
+        if (visiblityBindingOrCondition.type === ELEMENT_TYPE.ELEMENT && visiblityBindingOrCondition.name === DIV_VISIBILITY_BINDING_NODE) {
+            // => handle visibilityBinding
+            binding = visiblityBindingOrCondition.attributes.binding;
+            // get compareMode if available
+            if (_.has(visiblityBindingOrCondition.attributes, "compareMode")) {
+                compareMode = visiblityBindingOrCondition.attributes.compareMode;
+            }
+            // resolve binding
+            comparisonValue = this.__resolveScalarBinding(visiblityBindingOrCondition, binding, params);
+            if (_.isNil(comparisonValue)) {
+                // unknown binding => log error
+                this.__log.error("Unsupported binding '", binding, "' at <" + visiblityBindingOrCondition.name + "> element");
+            }
+
+        } else if (visiblityBindingOrCondition.type === ELEMENT_TYPE.ELEMENT && visiblityBindingOrCondition.name === DIV_VISIBILITY_CONDITION_NODE) {
+            // => handle visibilityCondition
+            eachName =  visiblityBindingOrCondition.attributes.eachName;
+            // set compareMode to "NUMBER"
+            compareMode = COMPAREMODE_NUMBER;
+            // resolve eachName
+            if (_.has(this.__eachCache, eachName) && _.isArray(this.__eachCache[eachName])) {
+                comparisonValue = this.__eachCache[eachName].length;   
+            }        
+            if (_.isNil(comparisonValue)) {
+                // unknown eachName => log error
+                this.__log.error("Unsupported eachName '", eachName, "' at <" + visiblityBindingOrCondition.name + "> element");
+            }
+        }
+
+        // normalize compareMode & operator
+        compareMode = _.toUpper(compareMode);
+        operator = _.toUpper(operator);
+
+        if (!_.isNil(comparisonValue) && !_.isNil(operator) && !_.isNil(value) && !_.isNil(compareMode)) {
+
+            let converter = this.__resolveConverter(compareMode);
+            if (!_.isNil(converter) && _.isFunction(converter)) {
+
+                // convert comparison value once
+                let x = converter(comparisonValue);
+                // convert value once
+                let y = converter(value);
+
+                let comparator = this.__resolveComparator(operator);
+                if (!_.isNil(comparator) && _.isFunction(comparator)) {
+
+                    // build filter expression performing comparison
+                    expression = ( () => {
+                        return comparator(x, y);
+                    });
+
+                } else {
+                    // unknown operator => log error
+                    this.__log.error("Unsupported operator '", operator, "' at <" + visiblityBindingOrCondition.name + "> element");
+                }
+            } else {
+                // unknown compareMode => log error
+                this.__log.error("Unsupported compareMode '", compareMode, "' at <" + visiblityBindingOrCondition.name + "> element");
+            }
+        } else {
+            // missing/invalid mandatory attribute => log error
+            this.__log.error("Missing/invalid mandatory attribute at <" + visiblityBindingOrCondition.name + "> element");
+        }
+
+        return expression;
+    }
+
+    __evaluateVisibilityCondition(visiblityConditionNode) {
+        let result = true;
+
+        // <visiblityCondition eachName="each1" value="0" operator="GT" />
+        if (!_.isNil(visiblityConditionNode)) {
+            let expression = this.__getVisibilityExpression(visiblityConditionNode, null);
+            if (!_.isNil(expression) && _.isFunction(expression)) {
+                result = expression();
+            }     
+        }
+
+        return result;
+    }
+
+    __checkForEmptyTable(tableNode) {
+        if (!_.isNil(tableNode)) {
+            // check thead
+            let thead = _.find(tableNode.elements, {name:THEAD_NODE});
+            if (_.isNil(thead) || _.isUndefined(thead.elements) || thead.elements.length === 0) {
+                // check tbody
+                let tbody = _.find(tableNode.elements, {name:TBODY_NODE});
+                if (_.isNil(tbody) || (!_.isNil(tbody) && !_.isUndefined(tbody.elements) && tbody.elements.length === 0)) {
+                    // table is empty => to be removed
+                    tableNode.toBeRemoved = true;
+                }
+            }           
+        }
+    }
+
+    __applyColSpanHandling(tableRowNode) {
+        let newElements = [];
+        _.forEachRight(tableRowNode.elements, tdth => {
+            if (!_.isNil(tdth.attributes)) {
+                let colSpan = tdth.attributes.colSpan;
+                if (!_.isNil(colSpan)) {
+                    colSpan = _.toInteger(colSpan);
+                    if (!_.isNaN(colSpan) && colSpan > 1) {
+                        let elementsToAdd = colSpan - 1;
+                        let elementName = tdth.name;
+
+                        let newAttributes = {
+                            "name": elementName,
+                            "doNotReplace": true
+                        };
+                        for (let i = 0; i < elementsToAdd; i++) {
+                            let newElement = this.__newXMLconvertibleJsonNode(ELEMENT_TYPE.ELEMENT, null, newAttributes);
+                            newElements.push(newElement);
+                        }
+                    }
+                }
+            }
+            newElements.push(tdth);
+        });
+        // replace elements if applicable
+        let elementCount = 0;
+        if (!_.isNil(tableRowNode.elements)) {
+            elementCount = tableRowNode.elements.length;
+        }
+        if (newElements.length !== elementCount) {
+            tableRowNode.elements = _.reverse(newElements);
+        }
+    }
+
+    __applyRowSpanHandling(tableNode) {
+        if (!_.isNil(tableNode)) {
+            // fix thead
+            this.__applyRowSpanHandlingToContainer(tableNode, THEAD_NODE);
+
+            // fix tbody
+            this.__applyRowSpanHandlingToContainer(tableNode, TBODY_NODE);
+        }
+    }
+
+    __applyRowSpanHandlingToContainer(tableNode, trContainerNodeName) {
+
+        if (!_.isNil(tableNode) && !_.isNil(trContainerNodeName)) {
+            // check tbody / thead
+            let trContainerNode = _.find(tableNode.elements, {name:trContainerNodeName});
+            if (!_.isNil(trContainerNode) && !_.isNil(trContainerNode.elements)) {
+                for (let i = 0; i < trContainerNode.elements.length; i++) {
+                    // check tr
+                    let tr = trContainerNode.elements[i];
+                    if (!_.isNil(tr) && !_.isNil(tr.elements)) {
+                        for (let j = 0; j < tr.elements.length; j++) {
+                            // check td / th
+                            let tdth = tr.elements[j];
+                            if (!_.isNil(tdth)) {
+                                if (!_.isNil(tdth.attributes)) {
+                                    let rowSpan = tdth.attributes.rowSpan;
+                                    if (!_.isNil(rowSpan)) {
+                                        rowSpan = _.toInteger(rowSpan);
+                                        if (!_.isNaN(rowSpan) && rowSpan > 1) {
+                                            let rowsToUpdate  = rowSpan - 1;
+                                            let elementsToAdd = 1; // rowSpan element
+                                            let elementName = tdth.name;
+                                            let colSpan = tdth.attributes.colSpan;
+                                            if (!_.isNil(colSpan)) {
+                                                colSpan = _.toInteger(colSpan);
+                                                if (!_.isNaN(colSpan) && colSpan > 1) {
+                                                    elementsToAdd = elementsToAdd + (colSpan - 1); // colSpan elements
+                                                }
+                                            }
+                                            // update "spanned" rows
+                                            for (let k = 0; k < rowsToUpdate; k++) {
+                                                let rowIndex = i + k + 1;
+                                                if (rowIndex < trContainerNode.elements.length) {
+                                                    let tr2 = trContainerNode.elements[rowIndex];
+
+                                                    if (_.isNil(tr2.elements)) {
+                                                        _.assign(tr2, {"elements": []});
+                                                    }
+
+                                                    let tr2Index = j;
+                                                    if (tr2Index > tr2.elements.length) {
+                                                        tr2Index = 0;
+                                                    }
+
+                                                    // insert elements ...
+                                                    for (let l = 0; l < elementsToAdd; l++) {
+                                                        let newElement = this.__newXMLconvertibleJsonNode(ELEMENT_TYPE.ELEMENT, null, {"name": elementName, "doNotReplace": true});
+                                                        tr2.elements.splice(tr2Index, 0, newElement);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    __normalizeTable(tableNode) {
+        if (!_.isNil(tableNode)) {
+            // get minimum thead width
+            let minTableHeadWidth = this.__getTableContainerWidth(tableNode, THEAD_NODE);
+
+            // get minimum tbody width
+            let minTableBodyWidth = this.__getTableContainerWidth(tableNode, TBODY_NODE);
+
+            // determine minimum width for table
+            let minTableWidth = _.min([minTableHeadWidth, minTableBodyWidth]);
+
+            // repair thead
+            this.__normalizeTableWidth(tableNode, THEAD_NODE, minTableWidth);
+
+            // repair tbody
+            this.__normalizeTableWidth(tableNode, TBODY_NODE, minTableWidth);
+        }
+    }
+
+    __getTableContainerWidth(tableNode, trContainerNodeName) {
+        let minWidth = Number.MAX_SAFE_INTEGER;
+        if (!_.isNil(tableNode) && !_.isNil(trContainerNodeName)) {
+            let trContainerNode = _.find(tableNode.elements, {name:trContainerNodeName});
+            if (!_.isNil(trContainerNode)) {
+                _.forEach(trContainerNode.elements, tr => {
+                    if (!_.isNil(tr) && tr.name === TR_NODE && !_.isNil(tr.elements)) {
+                        let thCount = tr.elements.length;
+                        if (thCount < minWidth) {
+                            minWidth = thCount;
+                        }
+                    }
+                });
+            }
+        }
+        return minWidth;
+    }
+
+    __normalizeTableWidth(tableNode, trContainerNodeName, tableWidth) {
+        if (!_.isNil(tableNode) && !_.isNil(trContainerNodeName)) {
+            let trContainerNode = _.find(tableNode.elements, {name:trContainerNodeName});
+            if (!_.isNil(trContainerNode)) {
+                let normalized = false;
+                _.forEach(trContainerNode.elements, tr => {
+                    if (!_.isNil(tr) && tr.name === TR_NODE) {
+                        let trWidth = 0;
+                        if (!_.isNil(tr.elements)) {
+                            trWidth = tr.elements.length;
+                        }
+                        if (trWidth > tableWidth) {
+                            // remove elements ...
+                            tr.elements.splice(tableWidth, trWidth - tableWidth);
+                            normalized = true;
+                        }
+                    }
+                });
+                if (normalized) {
+                    let tableName = tableNode.attributes.name;
+                    let errorMessage = "<" + trContainerNodeName + "> element of <table> '" + tableName + "' has been normalized due to improper formatting";
+                    this.__log.error(errorMessage);
+                }
+            }
+        }
+    }
+
+    __processSumRecords() {
+        let idxSum;
+        for (idxSum=0; idxSum < this.__sumTdThList.length; idxSum++) {
+            let tdthNode = this.__sumTdThList[idxSum];
+            let sumNode =  _.find(tdthNode.elements, {name:SUM_NODE});
+            let tableName = sumNode.attributes.table;
+            let tablePos = parseFloat(sumNode.attributes.col, 10);
+            let sumFormat = sumNode.attributes.numberFormat;
+            let tableNode = this.__tableIndex[tableName];
+            let sum = 0;
+
+            if (!_.isNil(tableNode)) {
+                let tBodyNode = _.find(tableNode.elements, {name:TBODY_NODE});
+                if (!_.isNil(tBodyNode) && !_.isNil(tBodyNode.elements)) {
+                    _.forEach(tBodyNode.elements, (trNode) => {
+                        let tdNode = trNode.elements[tablePos];
+                        if(!_.isNil(tdNode)) {
+                            let bSum = false;
+                            let text = "";
+                            let nonRoundedValue = null;
+                            if (!_.isNil(tdNode.attributes)) {
+                                nonRoundedValue = tdNode.attributes.nonRoundedValue;
+                            }
+                            _.forEach(tdNode.elements, childElement => {
+                                if ((childElement.type === "text") && !_.isNil(childElement.isSum) && childElement.isSum) {
+                                    bSum = true;
+                                } else if (childElement.type === "text") {
+                                    text = childElement.text;
+                                } else if (childElement.type === "element" && childElement.name === SUM_NODE) {
+                                    bSum = true;
+                                }
+                            });
+                            if (!bSum) {
+                                if (!_.isNil(nonRoundedValue)) {
+                                    // nonRoundedValue only exists if a format was applied to the cell
+                                    sum += nonRoundedValue;
+                                } else {
+                                    let value = parseFloat(text, 10);
+                                    if (!isNaN(value)) {
+                                        sum += value;
+                                    }
+                                }
+
+                            }
+                        }
+                    });
+                } else {
+                    sum = 0;
+                }
+            } else {
+                sum = 0;
+            }
+
+            let txtSum;
+
+            if (!_.isNil(sumFormat)) {
+                txtSum = this.__format.formatDecimalV2(sum, sumFormat, this.__decimalSeparator, this.__thousandSeparator);
+            } else {
+                txtSum = "" + sum;
+            }
+
+            let bText = false;
+
+            _.forEach(tdthNode.elements, childElement => {
+                if(childElement.type === "text") {
+                    childElement.text = txtSum + childElement.text;
+                    childElement.isSum = true;
+                    bText = true;
+                }
+            });
+
+            if (!bText) {
+                if (txtSum.length > 0) {
+                    tdthNode.elements.push(this.__newXMLconvertibleJsonNode(ELEMENT_TYPE.TEXT, null, {"text": txtSum, "doNotReplace": true, "isSum": true}));
+                }
+            }
+
+            this.__deleteInvalidNodes(tdthNode, [SUM_NODE], null);
+        }
+    }
+
+    __processH1Node(currentJsonElement/*, params*/) {
+        this.__makeTextOnlyNode(currentJsonElement);
+    }
+
+    __processH2Node(currentJsonElement/*, params*/) {
+        this.__makeTextOnlyNode(currentJsonElement);
+    }
+
+    __processParagraphNode(currentJsonElement/*, params*/) {
+        this.__makeTextOnlyNode(currentJsonElement);
+    }
+
+    __processPropertyNode(currentJsonElement, params){
+        let resolvedMacro =  this.__resolveScalarBinding(currentJsonElement, currentJsonElement.attributes.value, params);
+        if(!_.isNil(resolvedMacro)) {
+            if(_.isObject(resolvedMacro)) {
+                resolvedMacro = JSON.stringify(resolvedMacro);
+            }
+            if(!_.isString(resolvedMacro)){
+                resolvedMacro = ""+resolvedMacro;
+            }
+            currentJsonElement.attributes.value = resolvedMacro;
+        }
+    }
+
+    __processPrintLayoutNode(currentJsonElement/*, parentName, params*/){
+        this.__printLayoutName = currentJsonElement.attributes.name;
+    }
+
+    __processCurrentElement(currentJsonElement, parentElement, parentName, params) {
+        if (currentJsonElement.doNotReplace) {
+            return;
+        }
+        if(currentJsonElement.type === ELEMENT_TYPE.TEXT) {
+            this.__replaceMacrosInTextNodes(parentElement, currentJsonElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === TBODY_NODE) {
+            this.__replaceEachTagsInTables(currentJsonElement, parentElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === HEADER_NODE){
+            this.__processHeaderNode(currentJsonElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === FOOTER_NODE){
+            this.__processFooterNode(currentJsonElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === REPORT_LAYOUT_NODE){
+            this.__processReportLayoutNode(currentJsonElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === TABLE_NODE){
+            this.__processTableNode(currentJsonElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === THEAD_NODE){
+            this.__processTheadNode(currentJsonElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === H1) {
+            this.__processH1Node(currentJsonElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === H2) {
+            this.__processH2Node(currentJsonElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === PARAGRAPH) {
+            this.__processParagraphNode(currentJsonElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === IMAGE) {
+            this.__processImageNode(currentJsonElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === PROPERTY_NODE) {
+            this.__processPropertyNode(currentJsonElement, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === TR_NODE){
+            this.__processTrNode(currentJsonElement, parentName, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === TD_NODE){
+            this.__processTdThNode(currentJsonElement, parentName, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === TH_NODE){
+            this.__processTdThNode(currentJsonElement, parentName, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === PRINT_LAYOUT_NODE){
+            this.__processPrintLayoutNode(currentJsonElement, parentName, params);
+        } else if (currentJsonElement.type === ELEMENT_TYPE.ELEMENT && currentJsonElement.name === DIV_NODE){
+            this.__processDivNode(currentJsonElement, parentElement);
+        }
+    }
+
+    __processDivNode(divNode, parentNode) {
+        // cache divNode and parentNode for later ...
+        this.__divCache.push({
+            "id"        : "div" + (this.__divCache.length + 1),
+            "divNode"   : divNode,      // div to evaluate
+            "parentNode": parentNode    // parent to resolve
+        });        
+    }
+
+    __parse(contract){
+        let contractJson = parser.xml2js(contract,this.__xmlParserLibraryOptions);
+        return contractJson;
+    }
+
+    __isLo(object){
+        return _.isArray(object);
+    }
+
+    __makeTextOnlyNode(currentJsonElement) {
+        _.remove(currentJsonElement.elements, (ele)=> { return ele.type !== ELEMENT_TYPE.TEXT;});
+        if(currentJsonElement.elements.length === 0) {
+            currentJsonElement.elements.push({type:ELEMENT_TYPE.TEXT, text: ""});
+        }
+    }
+
+    __deleteInvalidNodes(currentJsonElement, deleteNames, preserveNames) {
+        //Remove invalid nodes by positive or negative lists.
+        let bDelete = !_.isNil(deleteNames) && _.isArray(deleteNames) && (deleteNames.length > 0);
+        let bPreserve = !_.isNil(preserveNames) && _.isArray(preserveNames) && (preserveNames.length > 0);
+
+        //It makes no sense to fill both lists or no list but we cannot provide a true/true or a false/false
+        //scenario via Unit Tests. So we keep both paths split to fulfill the branch coverage.
+        if (bDelete) {
+            _.remove(currentJsonElement.elements, (ele)=> {
+                let names = 0;
+                for (names=0; names<deleteNames.length; names++) {
+                    if (ele.name === deleteNames[names]) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+        }
+        if (bPreserve) {
+            _.remove(currentJsonElement.elements, (ele)=> {
+                let names = 0;
+                for (names=0; names<preserveNames.length; names++) {
+                    if (ele.name === preserveNames[names]) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        }
+    }
+
+    __processTheadNode(currentJsonElement/*, parentName, params*/){
+        this.__deleteInvalidNodes(currentJsonElement, [EACH_NODE], null);
+    }
+
+    __processTableNode(currentJsonElement/*, parentName, params*/){
+        this.__deleteInvalidNodes(currentJsonElement, null, [THEAD_NODE, TBODY_NODE]);
+        if (_.isNil(this.__tableIndex[currentJsonElement.attributes.name])) {
+            this.__tableIndex[currentJsonElement.attributes.name] = currentJsonElement;
+        }
+    }
+
+    __processTrNode(currentJsonElement, parentName/*, params*/){
+        if (parentName === THEAD_NODE) {
+            this.__deleteInvalidNodes(currentJsonElement, null, [TH_NODE]);
+        } else if (parentName === TBODY_NODE) {
+            this.__deleteInvalidNodes(currentJsonElement, null, [TD_NODE]);
+        }
+    }
+
+    __processTdThNode(currentJsonElement, /*, parentName, params*/){
+        let sumNode = _.find(currentJsonElement.elements, {name:SUM_NODE});
+
+        if (!_.isNil(sumNode)) {
+            this.__sumTdThList.push(currentJsonElement);
+        }
+    }
+
+    __processReportLayoutNode(currentJsonElement/*, parentName, params*/) {
+        this.__deleteInvalidNodes(currentJsonElement, [EACH_NODE], null);
+    }
+
+    __processHeaderNode(currentJsonElement/*, parentName, params*/) {
+        this.__deleteInvalidNodes(currentJsonElement, [EACH_NODE], null);
+    }
+
+    __processFooterNode(currentJsonElement/*, parentName, params*/) {
+        this.__deleteInvalidNodes(currentJsonElement, [EACH_NODE], null);
+    }
+
+    __createTableDataCache(tableRow, params) {
+        let tdCacheList = [];
+
+        _.forEach(tableRow.elements, subtag => {
+            let tdCacheElement = {};
+            tdCacheElement.elements = [];
+
+            if (subtag.name === "td") {
+                if (!_.isNil(subtag.elements)) {
+                    let allTextNodeTexts = [];
+                    _.forEach(subtag.elements, tdSubtag => {
+                        if (tdSubtag.type === ELEMENT_TYPE.TEXT) {
+                            this.__replaceMacrosInTextNodes(subtag, tdSubtag, params);
+                            allTextNodeTexts.push(_.trim(tdSubtag.text));
+                        } else if (tdSubtag.type === ELEMENT_TYPE.ELEMENT && (tdSubtag.name === IMAGE)) {
+                            this.__processImageNode(tdSubtag, params);
+                            tdSubtag.doNotReplace = true;
+                            tdCacheElement.elements.push(tdSubtag);
+                        }
+                    });
+
+                    tdCacheElement.text = allTextNodeTexts.join(' ');
+                    tdCacheElement.macroList = [];
+
+                    let macroRegex = this.__macroHandler.getMacroRegex();
+                    let macroMatches = tdCacheElement.text.match(macroRegex);
+
+                    _.forEach(macroMatches, match => {
+                        let macroElement = {"match": match, "result": this.__macroHandler.parseMacro(match)};
+                        tdCacheElement.macroList.push(macroElement);
+                    });
+
+
+                } else {
+                    tdCacheElement.text = "";
+                }
+
+                tdCacheElement.attributes = subtag.attributes;
+                tdCacheList.push(tdCacheElement);
+            }
+        });
+
+        return tdCacheList;
+    }
+
+    __createTableTrForOneListItem(tdCacheList, listItem, trAttributes, isChildItem, eachName, listItemIndex, correlatedListItemIndex) {
+        let tdNodes = [];
+        let newText = null;
+        let newAttributes = null;
+
+        // id handling...
+        let cellId = null;
+        let columnIndex = -1;
+
+        _.forEach(tdCacheList, cacheElement => {
+            newText = cacheElement.text;
+            newAttributes = _.clone(cacheElement.attributes);
+
+            if (cacheElement.text.length > 0) {
+                _.forEach(cacheElement.macroList, macroElement => {
+                    let macroResult = macroElement.result;
+
+                    if (!_.isNil(macroResult) && !_.isNil(macroResult.path)) {
+                        let listItemValue = listItem[macroResult.path];
+
+                        if(typeof listItemValue !== "undefined") {
+                            if (!_.isNil(macroResult.numberFormat)) {
+                                if(_.isNil(newAttributes)) {newAttributes = {};}
+                                listItemValue = this.__resolveNumberBinding(listItemValue, macroResult,newAttributes);
+                                if(isChildItem){
+                                    // setting the nonRoundedValue to 0.0 makes sure that correlation items are ignored in the sum tag
+                                    newAttributes.nonRoundedValue = 0.0;
+                                }
+                            } if(!_.isNil(macroResult.dateTimeFormat)) {
+                                listItemValue = this.__resolveDateBinding(listItemValue, macroResult);
+                            } else {
+                                listItemValue = this.__replaceTogglesIfApplicable(listItemValue, macroResult, this.__localization);
+                            }
+
+                            if(_.isString(listItemValue)){
+                                listItemValue = listItemValue.replace(/\$/g, "$$$$");
+                            }
+
+                            newText = newText.replace(macroElement.match, listItemValue);
+                        }
+                    }
+                });
+            }
+
+            let newTextNode = [];
+            if(newText.length > 0){
+                newTextNode.push(this.__newXMLconvertibleJsonNode(ELEMENT_TYPE.TEXT, null, {"text": newText, "doNotReplace": true}));
+            }
+
+            // only apply id to cells with text OR child elements ...
+            if (newTextNode.length > 0 || cacheElement.elements.length > 0) {
+                columnIndex += 1;
+                cellId = this.__getCellId(eachName, listItemIndex, correlatedListItemIndex, columnIndex);
+                if (!_.isNil(cellId)) {
+                    if (_.isNil(newAttributes)) { newAttributes = {}; }
+                    newAttributes.id = cellId;
+                }
+            }
+
+            let newTdNode = this.__newXMLconvertibleJsonNode(ELEMENT_TYPE.ELEMENT, newTextNode,
+                {"name": "td", "attributes": newAttributes, "doNotReplace": true});
+
+            _.forEach(cacheElement.elements, element => {
+                newTdNode.elements.push(element);
+            });
+
+            tdNodes.push(newTdNode);
+        });
+
+        let newTrNode = this.__newXMLconvertibleJsonNode(ELEMENT_TYPE.ELEMENT, tdNodes,
+            {"name": "tr", "attributes": trAttributes, "doNotReplace": true});
+        return newTrNode;
+    }
+
+    __createTableRowData(tableRow, tdCacheList, trNodes, listObject, correlationInfo, eachName) {
+
+        if (!_.isNil(tableRow) && !_.isNil(tdCacheList) && !_.isNil(trNodes) && !_.isNil(listObject) && !_.isNil(eachName)) {
+
+            let hasCorrelationInfo = !_.isNil(correlationInfo);
+            let listItemIndex = -1;
+            let correlatedListItemIndex = -1;
+
+            _.forEach(listObject, listItem => {
+
+                if (hasCorrelationInfo) {
+                    listItemIndex += 1;
+                    correlatedListItemIndex = -1;
+                }
+
+                let newTrNode = this.__createTableTrForOneListItem(tdCacheList, listItem, tableRow.attributes, false, eachName, listItemIndex, correlatedListItemIndex);
+                trNodes.push(newTrNode);
+
+                if (!_.isNil(correlationInfo) && !_.isNil(listItem[correlationInfo.key])) {
+                    // TODO: this implementation is slow and can be done faster.
+                    let correlatedItemsForCurrentLI = _.filter(correlationInfo.listObjectForCorrelation, (elem) => {
+                        return elem[correlationInfo.correlationKey] === listItem[correlationInfo.key];
+                    });
+
+                    // (re)set correlatedListItemIndex...
+                    correlatedListItemIndex = -1;
+
+                    _.forEach(correlatedItemsForCurrentLI, corrLi => {
+
+                        // set correlatedListItemIndex...
+                        correlatedListItemIndex += 1;
+
+                        let newCorrelationTrNode = this.__createTableTrForOneListItem(correlationInfo.tdCacheForCorrelation, corrLi, {}, true, eachName, listItemIndex, correlatedListItemIndex);
+                        trNodes.push(newCorrelationTrNode);
+                    });
+                }
+            });
+        }
+
+        return trNodes;
+    }
+
+    __buildCorrelationInfo(correlationNode, params){
+        let correlationInfo = null;
+        if(!_.isNil(correlationNode)){
+            correlationInfo = {};
+            correlationInfo.correlationTableRow = _.find(correlationNode.elements, {name:TR_NODE}); // eachNode.elements[0];
+            correlationInfo.tdCacheForCorrelation = this.__createTableDataCache(correlationInfo.correlationTableRow, params);
+            correlationInfo.listObjectForCorrelation =  this.__resolveScalarBinding(correlationNode,
+                correlationNode.attributes.value, params);
+            // => get and apply filters
+            correlationInfo.listObjectForCorrelation = this.__evaluateAndApplyFilters(correlationNode,
+                correlationInfo.listObjectForCorrelation);
+            // => get and apply orderCriteria
+            correlationInfo.listObjectForCorrelation = this.__evaluateAndApplyOrderCriteria(correlationNode,
+                correlationInfo.listObjectForCorrelation);
+            correlationInfo.key = correlationNode.attributes.key;
+            correlationInfo.correlationKey = correlationNode.attributes.correlationKey;
+        }
+        return correlationInfo;
+    }
+
+    __resolveEachTag(eachNode, tableNode, params) {
+        let trNodes = [];
+
+        if(!_.isNil(eachNode) && (eachNode.name === EACH_NODE)){
+            let eachName = null;
+            let listObject = null;
+
+            if (!_.isNil(eachNode.attributes)) {
+                eachName = eachNode.attributes.name;
+                listObject = this.__resolveScalarBinding(eachNode, eachNode.attributes.value, params);
+                if(!this.__isLo(listObject)){
+                    listObject = null;
+                }
+            }
+
+            if (_.isNil(listObject)) {
+                if(!_.isNil(eachNode.attributes)) {
+                    trNodes.push(this.__newXMLconvertibleJsonNode(ELEMENT_TYPE.TEXT, null, {"text": eachNode.attributes.value,
+                        "doNotReplace": true}));
+                }
+            }
+
+            this.__deleteInvalidNodes(eachNode, null, [TR_NODE, FILTERS_NODE, ORDERCRITERIA_NODE, CORRELATION_NODE]);
+
+            if (!_.isNil(eachNode.elements) && (eachNode.elements.length > 0)) {
+
+                // => get and apply filters
+                listObject = this.__evaluateAndApplyFilters(eachNode, listObject);
+                // => get and apply orderCriteria
+                listObject = this.__evaluateAndApplyOrderCriteria(eachNode, listObject);
+
+                // cache each data ...
+                this.__eachCache[eachName] = listObject;
+
+                // the correlation node is needed for printing the correlated items
+                const correlationNode = _.find(eachNode.elements,  {name:CORRELATION_NODE});
+                let correlationInfo = this.__buildCorrelationInfo(correlationNode, params);
+                if (!_.isNil(correlationInfo)) {
+                    // each node with correlation => enable dynamicPageBreak for table
+                    tableNode.attributes.dynamicPageBreak = "true"; // as string to keep pdfconverter working ...
+                }
+
+                // => process table row (with filtered / sorted list object)
+                let tableRow = _.find(eachNode.elements, {name:TR_NODE});
+                if (!_.isNil(tableRow)) {
+
+                    this.__deleteInvalidNodes(tableRow, null, [TD_NODE]);
+
+                    if (!_.isNil(tableRow.elements) && (tableRow.elements.length > 0)) {
+                        let tdCacheList = this.__createTableDataCache(tableRow, params);
+                        trNodes = this.__createTableRowData(tableRow, tdCacheList, trNodes, listObject, correlationInfo, eachName);
+                    }
+                } else {
+                    // no table row => log error
+                    this.__log.error("<each> element must contain a <tr> (table row) element");
+                }
+            }
+        }
+
+        return trNodes;
+    }
+
+    __evaluateAndApplyFilters(iterableNode, listObject) {
+        //   <filters>
+        //     <filter fieldName="quantity" value="0" operator="GT" compareMode="NUMBER" />
+        //     <filter fieldName="movementDirection" value="In" operator="NE" />
+        //   </filters>
+
+        let filtersNode = _.find(iterableNode.elements, {name:FILTERS_NODE});
+        if (!_.isNil(filtersNode)) {
+
+
+            this.__deleteInvalidNodes(filtersNode, null, [FILTER_NODE]);
+
+            if (!_.isNil(filtersNode.elements) && (filtersNode.elements.length > 0)) {
+                _.forEach(filtersNode.elements, element => {
+
+                    let filterExpression = this.__getAdvancedFilterExpression(element);
+                    if (!_.isNil(filterExpression) && _.isFunction(filterExpression)) {
+                        listObject = _.filter(listObject, filterExpression);
+                    }
+
+                });
+            } else {
+                // no filter elements => log error
+                this.__log.error("<each>.<filters> element must contain at least one <filter> element");
+            }
+        }
+        return listObject;
+    }
+
+    __getAdvancedFilterExpression(filterNode) {
+        let filterExpression = null;
+
+        // extract attributes
+        let fieldName = filterNode.attributes.fieldName;
+        let operator = filterNode.attributes.operator;
+        let value = filterNode.attributes.value;
+
+        let compareMode = filterNode.attributes.compareMode;
+        if (_.isNil(compareMode)) {
+            compareMode = COMPAREMODE_DEFAULT;
+        }
+        // normalize compareMode
+        compareMode = _.toUpper(compareMode);
+
+        if (!_.isNil(fieldName) && !_.isNil(operator) && !_.isNil(value) && !_.isNil(compareMode)) {
+
+            let converter = this.__resolveConverter(compareMode);
+            if (!_.isNil(converter) && _.isFunction(converter)) {
+
+                // convert value just once
+                let y = converter(value);
+
+                // normalize operator
+                operator = _.toUpper(operator);
+
+                let comparator = this.__resolveComparator(operator);
+                if (!_.isNil(comparator) && _.isFunction(comparator)) {
+
+                    // build filter expression
+                    filterExpression = (object => {
+                        // convert listobject value
+                        let x = converter(object[fieldName]);
+                        // perform comparison
+                        return comparator(x, y);
+                    });
+
+                } else {
+                    // unknown operator => log error
+                    this.__log.error("Unsupported operator '", operator, "' at <each>.<filters>.<filter> element");
+                }
+
+            } else {
+                // unknown compareMode => log error
+                this.__log.error("Unsupported compareMode '", compareMode, "' at <each>.<filters>.<filter> element");
+            }
+
+        } else {
+            // missing mandatory attribute => log error
+            this.__log.error("Missing mandatory attribute at <each>.<filters>.<filter> element");
+        }
+
+        return filterExpression;
+    }
+
+    __resolveComparator(comparator) {
+        const COMPARATORS = {
+            "EQ" : function (x, y) { return (x === y); },
+            "NE" : function (x, y) { return (x !== y); },
+            "GT" : function (x, y) { return (x > y); },
+            "GE" : function (x, y) { return (x >= y); },
+            "LT" : function (x, y) { return (x < y); },
+            "LE" : function (x, y) { return (x <= y); }
+        };
+
+        return COMPARATORS[comparator];
+    }
+
+    __resolveConverter(compareMode) {
+        const CONVERTERS = {
+            //"NONE"    : function (x) { return x; },
+            "STRING"  : function (x) {
+                if (!_.isString(x)) {
+                    return _.toString(x);
+                } else {
+                    return x;
+                }
+            },
+            "NUMBER"  : function (x) {
+                if (!_.isNumber(x)) {
+                    return _.toNumber(x);
+                } else {
+                    return x;
+                }
+            }
+        };
+
+        return CONVERTERS[compareMode];
+    }
+
+    __evaluateAndApplyOrderCriteria(iterableNode, listObject) {
+        //   <orderCriteria>
+        //     <orderCriterion fieldName="eAN" direction="ASC" compareMode="NUMBER" />
+        //   </orderCriteria>
+        let orderCriteriaNode = _.find(iterableNode.elements, {name:ORDERCRITERIA_NODE});
+        if (!_.isNil(orderCriteriaNode)) {
+
+            this.__deleteInvalidNodes(orderCriteriaNode, null, [ORDERCRITERION_NODE]);
+
+            if (!_.isNil(orderCriteriaNode.elements) && (orderCriteriaNode.elements.length > 0)) {
+
+                let selectors = [];
+                let directions = [];
+
+                _.forEach(orderCriteriaNode.elements, element => {
+
+                    // extract attributes
+                    let fieldName = element.attributes.fieldName;
+                    let direction = element.attributes.direction;
+
+                    let compareMode = element.attributes.compareMode;
+                    if (_.isNil(compareMode)) {
+                        compareMode = COMPAREMODE_DEFAULT;
+                    }
+                    // normalize compareMode
+                    compareMode = _.toUpper(compareMode);
+
+                    if (!_.isNil(fieldName) && !_.isNil(direction) && !_.isNil(compareMode)) {
+
+                        // get converter
+                        let converter = this.__resolveConverter(compareMode);
+                        if (!_.isNil(converter) && _.isFunction(converter)) {
+
+                            // build & store selector
+                            let selector = (object => {
+                                return converter(object[fieldName]);
+                            });
+                            selectors.push(selector);
+
+                            // store direction
+                            directions.push(_.toLower(direction));
+
+                        } else {
+                            // unknown compareMode => log error
+                            this.__log.error("Unsupported compareMode '",  compareMode , "' at <each>.<orderCriteria>.<orderCriterion> element");
+                        }
+
+                    } else {
+                        // missing mandatory attribute => log error
+                        this.__log.error("Missing mandatory attribute at <each>.<orderCriteria>.<orderCriterion> element");
+                    }
+                });
+
+                if (selectors.length > 0 && directions.length > 0 && selectors.length === directions.length) {
+                    // sort using selectors & directions
+                    listObject = _.orderBy(listObject, selectors, directions);
+                } else {
+                    // no order criterion fields / directions => log error
+                    this.__log.error("<each>.<orderCriteria> element does not contain any applicable <orderCriterion> elements - sorting skipped");
+                }
+
+            } else {
+                // no order criterion elements => log error
+                this.__log.error("<each>.<orderCriteria> element must contain at least one <orderCriterion> element");
+            }
+        }
+        return listObject;
+    }
+
+    __replaceEachTagsInTables(tbodyNode, tableNode, params) {
+        let eachNode = _.find(tbodyNode.elements, {name:EACH_NODE});
+
+        if (!_.isNil(eachNode)){
+            let newTableRows = [];
+
+            _.forEach(tbodyNode.elements, (rowNode) => {
+                if (rowNode.name === EACH_NODE) {
+                    newTableRows = _.concat(newTableRows, this.__resolveEachTag(rowNode, tableNode, params));
+                } else {
+                    newTableRows.push(rowNode);
+                }
+            });
+
+            tbodyNode.elements = newTableRows;
+        }
+    }
+
+    __isBoDeclared(boName){
+        let isDeclared = false;
+
+        _.forEach(this.__declarationsNode.elements, declaration =>{
+            if(declaration.name === "DataDeclaration") {
+                if(declaration.attributes.name === boName){
+                    isDeclared = true;
+                }
+            }
+        });
+
+        return isDeclared;
+    }
+
+    __replaceTogglesIfApplicable(resolvedMacro, macroResult, localization){
+        let result = resolvedMacro;
+        if (!_.isNil(macroResult.toggleId)) {
+            try {
+                if (!_.isNil(macroResult.toggleField)) {
+                    result = this.__toggles.getToggleText(macroResult.toggleId, resolvedMacro, macroResult.toggleField);
+                } else {
+                    result = this.__toggles.getToggleText(macroResult.toggleId, resolvedMacro);
+                }
+            } catch(ex){
+                if(ex.message.indexOf("Invalid toggle value") > -1){
+
+                    result = localization.resolve("Framework.PrintV2_ToggleValueNotFound", "Toggle value not found");
+                    result = result + ": " + resolvedMacro;
+                } else if (ex.message.indexOf("Invalid toggle field") > -1) {
+                    result = localization.resolve("Framework.PrintV2_ToggleFieldNotFound", "Toggle field not found");
+                    result = result + ": " + macroResult.toggleField;
+                } else {
+                    result = localization.resolve("Framework.PrintV2_ToggleNotFound", "Toggle not found");
+                    result = result + ": " + macroResult.toggleId;
+                }
+
+            }
+        }
+        return result;
+    }
+
+    __ensureAttributes(currentNode) {
+        if(_.isNil(currentNode.attributes)){
+            currentNode.attributes = {};
+        }
+    }
+
+    __resolveNumberBinding(resolvedMacro, macroResult, attributeNode){
+        if(resolvedMacro !== "null" && !_.isNil(resolvedMacro)){
+            attributeNode.nonRoundedValue = resolvedMacro;
+            return this.__format.formatDecimalV2(resolvedMacro, macroResult.numberFormat,
+                this.__decimalSeparator, this.__thousandSeparator);
+        } else {
+            return " ";
+        }
+
+    }
+
+    __resolveDateBinding(resolvedMacro, macroResult){
+        if(resolvedMacro !== "null" && !_.isNil(resolvedMacro)) {
+            let actualDateTimeFormat = macroResult.dateTimeFormat;
+            switch (actualDateTimeFormat){
+            case "shortDate": actualDateTimeFormat = this.__localization.shortDateFormat;
+                break;
+            case "date": actualDateTimeFormat = this.__localization.dateFormat;
+                break;
+            case "dateTime": actualDateTimeFormat = this.__localization.dateTimeFormat;
+                break;
+            case "time": actualDateTimeFormat = this.__localization.timeFormat;
+                break;
+            default: break;
+            }
+            return this.__format.formatDate(resolvedMacro, actualDateTimeFormat);
+        } else {
+            return " ";
+        }
+    }
+
+    __resolveScalarBinding(currentNode, bindingText, params) {
+        let bos = params.getBOs();
+        let localization = this.__localization;
+        let resolvedMacro = null;
+        let macroResult = this.__macroHandler.parseMacro(bindingText);
+
+        if (!_.isNil(macroResult) && !_.isNil(macroResult.scope) && !_.isNil(macroResult.path)) {
+            let scope = macroResult.scope;
+            let bindingPath = macroResult.path;
+
+            if (scope === "Globals") {
+                let defaultLabel = macroResult.defaultLabel;
+                resolvedMacro = localization.resolve(bindingPath, defaultLabel);
+            }
+            else if (scope === "Labels") {
+                let defaultLabel = macroResult.defaultLabel;
+
+                if(bindingPath.indexOf(".") === -1) {
+                    // support for shortcut
+                    let lastUnderscoreIndex = this.__printLayoutName.lastIndexOf("_");
+                    let printLayoutNameWithoutSpecificVersion = this.__printLayoutName;
+                    if(lastUnderscoreIndex > -1) {
+                        printLayoutNameWithoutSpecificVersion =
+                            this.__printLayoutName.substr(0, lastUnderscoreIndex);
+                    }
+                    bindingPath = "PrintLayouts." + printLayoutNameWithoutSpecificVersion  + "." + bindingPath;
+                }
+
+                resolvedMacro = localization.resolve(bindingPath, defaultLabel);
+            } else if (scope === "Declarations") {
+                let boEndIndex = bindingPath.indexOf(".");
+                let boName;
+
+                if(boEndIndex === -1){
+                    // this means it is a top level binding like Declarations::data
+                    boName = bindingPath;
+                    boEndIndex = bindingPath.length;
+                }else {
+                    boName = bindingPath.substring(0, boEndIndex);
+                }
+
+                let isBoDeclared = this.__isBoDeclared(boName);
+
+                if(isBoDeclared){
+                    let deeperBindingPath = bindingPath.substring(boEndIndex + 1, bindingPath.length);
+                    let actualBo = _.get(bos, boName);
+
+                    if(deeperBindingPath.length > 0){
+                        resolvedMacro = _.get(actualBo, deeperBindingPath);
+                    } else {
+                        // this means it is a top level binding like Declarations::data
+                        resolvedMacro = actualBo;
+                    }
+
+                    if (!_.isNil(macroResult.numberFormat)) {
+                        this.__ensureAttributes(currentNode);
+                        resolvedMacro = this.__resolveNumberBinding(resolvedMacro, macroResult,currentNode.attributes);
+                    } if(!_.isNil(macroResult.dateTimeFormat)) {
+                        resolvedMacro = this.__resolveDateBinding(resolvedMacro, macroResult);
+                    } else {
+                        resolvedMacro = this.__replaceTogglesIfApplicable(resolvedMacro, macroResult, localization);
+                    }
+
+
+                } else {
+                    this.__log.error("Usage of undeclared BO:", boName);
+                }
+            }
+        }
+
+        return resolvedMacro;
+    }
+
+    __replaceMacrosInTextNodes(parentJsonElement, currentJsonElement, params){
+        let xmlNodeText = currentJsonElement.text;
+        let macroRegex = this.__macroHandler.getMacroRegex();
+        let arrayMatches = xmlNodeText.match(macroRegex);
+
+        if(!_.isNil(arrayMatches) && arrayMatches.length > 0) {
+            _.forEach(arrayMatches, currentMatch => {
+                let resolvedMacro = this.__resolveScalarBinding(parentJsonElement, currentMatch, params);
+                if (!_.isNil(resolvedMacro)){
+                    if(_.isString(resolvedMacro)){
+                        resolvedMacro = resolvedMacro.replace(/\$/g, "$$$$");
+                    }
+                    xmlNodeText = xmlNodeText.replace(currentMatch, resolvedMacro);
+                    currentJsonElement.text = xmlNodeText;
+                }
+            });
+        }
+    }
+
+    __isImageDeclared(imageName){
+        let isDeclared = false;
+
+        _.forEach(this.__declarationsNode.elements, declaration => {
+            if(declaration.name === "DataDeclaration") {
+                if ((declaration.attributes.name === imageName) && (declaration.attributes.type === "Image" || declaration.attributes.type === "Signature")) {
+                    isDeclared = true;
+                }
+            }
+        });
+
+        return isDeclared;
+    }
+
+    __sanitizeImageAttributes(currentJsonElement/*, params*/) {
+        let width = currentJsonElement.attributes.width;
+        let height = currentJsonElement.attributes.height;
+        let fit = currentJsonElement.attributes.fit;
+        this.__integerStringRegExp.lastIndex = 0; // reset last index
+        if(!this.__integerStringRegExp.test(height)){
+            delete currentJsonElement.attributes.height;
+        }
+        this.__integerStringRegExp.lastIndex = 0; // reset last index
+        if(!this.__integerStringRegExp.test(width)){
+            delete currentJsonElement.attributes.width;
+        }
+
+        let fitRegExp = /^\d+,\d+$/g;
+        if(!fitRegExp.test(fit)){
+            delete currentJsonElement.attributes.fit;
+        }
+        if(!_.isNil(width) || !_.isNil(height)){
+            delete currentJsonElement.attributes.fit;
+        }
+    }
+
+    __processImageNode(currentJsonElement, params){
+        this.__replaceMacrosInImageNodes(currentJsonElement, params);
+        this.__sanitizeImageAttributes(currentJsonElement, params);
+    }
+
+    __replaceMacrosInImageNodes(currentJsonElement, params){
+        let images = params.getImages();
+        let bindingText = currentJsonElement.attributes.src;
+        let macroResult = this.__macroHandler.parseMacro(bindingText);
+
+        if (!_.isNil(macroResult) && !_.isNil(macroResult.scope) && !_.isNil(macroResult.path)) {
+            let scope = macroResult.scope;
+            let imageName = macroResult.path;
+            if (scope === "Declarations") {
+                if (this.__isImageDeclared(imageName)) {
+                    let imageObject = images[imageName];
+                    if(_.isNil(imageObject.src) && imageObject.type === "Signature") {
+                        currentJsonElement.name = "p";
+                    } else if (!_.isNil(imageObject) && !_.isNil(imageObject.src)
+                        && !_.isNil(imageObject.mimeType)  && (!_.isNil(imageObject.imageId) || imageObject.type === "Signature")) {
+                        let dataUrlStart = "data:" + imageObject.mimeType +";base64,";
+                        let dataUrl = imageObject.src;
+
+                        if (!_.startsWith(dataUrl, dataUrlStart)) {
+                            dataUrl = dataUrlStart + dataUrl;
+                        }
+
+                        // => use imageName as id
+                        currentJsonElement.attributes.id = imageName;
+                        currentJsonElement.attributes.mimeType = imageObject.mimeType;
+
+                        currentJsonElement.attributes.src = dataUrl;
+                        if (imageObject.type === "Signature") {
+                            // https://stackoverflow.com/questions/5515869/string-length-in-bytes-in-javascript
+                            const m = encodeURIComponent(dataUrl).match(/%[89ABab]/g);
+                            const sizeInBytes =  dataUrl.length + (m ? m.length : 0);
+                            if (sizeInBytes > SIGNATURE_SIZE_LIMIT) {
+                                this.__log.error("Usage of signature larger than 200kb:", imageName);
+                                this.__assignFallbackImage(currentJsonElement);        
+                            }
+                        }
+                    } else {
+                        this.__log.error("Usage of undefined image:", imageName);
+                        this.__assignFallbackImage(currentJsonElement);
+                    }
+                } else {
+                    this.__log.error("Usage of undeclared image:", imageName);
+                    this.__assignFallbackImage(currentJsonElement);
+                }
+            } else {
+                this.__log.error("Invalid binding value:'"+ bindingText + "' found in image.");
+                this.__assignFallbackImage(currentJsonElement);
+            }
+        } else {
+            this.__log.error("Invalid value:'"+ bindingText + "' found in image.");
+            this.__assignFallbackImage(currentJsonElement);
+        }
+    }
+
+    __assignFallbackImage(currentJsonElement) {
+        const errorFallbackImage = "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4NCjwhLS0gR2VuZXJhdG9yOiBBZG9iZSBJbGx1c3RyYXRvciAyMi4wLjEsIFNWRyBFeHBvcnQgUGx1Zy1JbiAuIFNWRyBWZXJzaW9uOiA2LjAwIEJ1aWxkIDApICAtLT4NCjxzdmcgdmVyc2lvbj0iMS4xIiBpZD0iTGF5ZXJfMSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayIgeD0iMHB4IiB5PSIwcHgiDQoJIHZpZXdCb3g9IjAgMCAzOCAzOCIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMzggMzg7IiB4bWw6c3BhY2U9InByZXNlcnZlIj4NCjxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+DQoJLnN0MHtmaWxsOiNGM0Y2Rjg7fQ0KCS5zdDF7ZmlsbDojQjRDN0Q0O30NCjwvc3R5bGU+DQo8Y2lyY2xlIGNsYXNzPSJzdDAiIGN4PSIxOSIgY3k9IjE5IiByPSIxOSIvPg0KPGNpcmNsZSBjbGFzcz0ic3QxIiBjeD0iMjkuMSIgY3k9IjExLjQiIHI9IjIuMyIvPg0KPGc+DQoJPGc+DQoJCTxwYXRoIGNsYXNzPSJzdDEiIGQ9Ik0yMC43LDIyLjZsLTQtNC44bDAuNS0xLjdsLTIuMy00Yy0wLjEtMC4yLTAuMy0wLjItMC40LDBMNS4yLDI2LjljLTAuMSwwLjIsMCwwLjQsMC4yLDAuNGgxNUwxNywyMi41DQoJCQlMMjAuNywyMi42eiBNMzIuOCwyN2wtNy43LTljLTAuMS0wLjItMC40LTAuMy0wLjYtMC4xbC0yLjgsMmwxLjksNS41TDIwLDI0LjVsMS4yLDIuOGgxMS40QzMyLjksMjcuMywzMi45LDI3LjIsMzIuOCwyN3oiLz4NCgk8L2c+DQo8L2c+DQo8L3N2Zz4NCg==";
+        if (!_.isNil(currentJsonElement) && !_.isUndefined(currentJsonElement.attributes)) {
+            currentJsonElement.attributes.id = "$$$fallbackImage$$$";
+            currentJsonElement.attributes.mimeType = "image/svg+xml";
+            currentJsonElement.attributes.src = errorFallbackImage;
+        } 
+    }
+
+    __getCellId(eachName, listItemIndex, correlatedListItemIndex, columnIndex){
+        let tcid = TableCellIdentifier.create(eachName, listItemIndex, correlatedListItemIndex, columnIndex);
+        return tcid.toString();
+    }
+
+}
+
+module.exports = ContractToIntermediateJSON;