@ind-rcg/plugins-printengine 246.1010.0

package/dist/dev/src/pdfConverterClass.js

@@ -0,0 +1,1123 @@
+/*
+ * FILE_HEADER
+ */
+'use strict';
+
+const _ = require('lodash');
+const PdfPrinter = require('pdfmake');
+const Format = require('./formatClass');
+const TableCellIdentifier = require('./tableCellIdentifier');
+
+// required for webpack include (browser impl), used in conjunction with BrowserFonts definition
+const BrowserFontsVfs = require('pdfmake/build/vfs_fonts.js');
+
+// => use 'Roboto' font (pdfMake default) due to licensing (Apache 2.0)
+// https://fonts.google.com/specimen/Roboto || https://en.wikipedia.org/wiki/Roboto
+const ServerFonts = {
+    Roboto: {
+        normal: './fonts/Roboto-Regular.ttf',
+        bold: './fonts/Roboto-Medium.ttf',
+        italics: './fonts/Roboto-Italic.ttf',
+        bolditalics: './fonts/Roboto-MediumItalic.ttf'
+    }
+};
+
+const BrowserFonts = {
+    Roboto: {
+        normal: 'Roboto-Regular.ttf',
+        bold: 'Roboto-Medium.ttf',
+        italics: 'Roboto-Italic.ttf',
+        bolditalics: 'Roboto-MediumItalic.ttf'
+    }
+};
+
+const TableLayouts = {
+    lightHorizontalLinesMainItemsOnly: {
+        hLineWidth: function (i, node) {
+            // no frame for the table
+            if (i === 0 || i === node.table.body.length) {
+                return 0;
+            }
+            // bold seperator between header and body
+            if (i === node.table.headerRows) {
+                return 2;
+            }
+            // get first cell id for row ...
+            let row = node.table.body[i];
+            if (!_.isNil(row)) {
+                let cellId = null;
+                _.forEach(row, cell =>{
+                    if(_.has(cell, 'id')) {
+                        cellId = cell.id;
+                        return false;
+                    }
+                });
+                // seperator for between main rows (+ their child rows)
+                let tcid = TableCellIdentifier.fromString(cellId);
+                if (!_.isNil(tcid)) {
+                    if (tcid.isKnown() && tcid.belongsToMainRow()) {
+                        // seperator between main rows
+                        return 1;
+                    } else if (!tcid.isKnown()) {
+                        // seperator for 'unknown row'
+                        return 1;
+                    }
+                }
+            }
+            // no seperator for all other cases, e.g. child rows
+            return 0;
+        },
+        vLineWidth: function () {
+            return 0;
+        },
+        hLineColor: function (i, node) {
+            return i === node.table.headerRows ? 'black' : 'gray';
+        }
+    }
+};
+
+const STYLE_HEADING1 = "heading1";
+const STYLE_HEADING2 = "heading2";
+const STYLE_PARAGRAPH = "paragraph";
+
+const EXPORT_TYPE = {
+    "BASE_64" : "BASE_64",
+    "DATA_URL" : "DATA_URL",
+    "BLOB" : "BLOB"
+};
+Object.freeze(EXPORT_TYPE);
+
+class PdfConverter {
+    constructor() {
+        this.__pdfMake = null;
+        if(typeof pdfMake !== "undefined")
+        {
+            this.__pdfMake = pdfMake;
+        }
+
+        this.__format = new Format();
+    }
+
+    __applyPageBreakData(pdfDefinition) {
+        if (!_.isUndefined(pdfDefinition.dynamicPageBreak) && pdfDefinition.dynamicPageBreak && 
+            !_.isUndefined(pdfDefinition.dynamicPageBreakData) && _.isArray(pdfDefinition.dynamicPageBreakData) && pdfDefinition.dynamicPageBreakData.length > 0) {
+            // let table = pdfDefinition.content[0].table;
+            let dynamicPageBreakData = pdfDefinition.dynamicPageBreakData;
+            
+            // handle tables in body
+            let tables = _.filter(pdfDefinition.content, {style: 'tableBody'});
+            this.__applyPageBreakDataToTables(tables, dynamicPageBreakData);
+        }
+    }    
+
+    __applyPageBreakDataToTables(tables, dynamicPageBreakData) {
+
+        if (!_.isNil(tables) && _.isArray(tables) && tables.length > 0 && !_.isNil(dynamicPageBreakData)) {
+            for (let i = 0; i < tables.length; i++) {
+                // get table
+                let table = tables[i].table;
+                if (!_.isNil(table) && !_.isUndefined(table.dynamicPageBreak) && table.dynamicPageBreak) {
+                    // loop rows
+                    let row = null;
+                    let cell = null;
+                    let breakRow = false;
+                    for (let j = 0; j < table.body.length; j++) {            
+                        row = table.body[j];
+                        breakRow = false;
+                        // loop columns
+                        for (let k = 0; k < row.length; k++) {
+                            cell = row[k];
+                            // apply manual pageBreaks instead of dynamic ones
+                            if (!breakRow && _.has(cell, 'id')) {
+                                breakRow = _.includes(dynamicPageBreakData, cell.id);
+                                if (breakRow) {
+                                    cell.pageBreak = 'before';
+                                }                    
+                            } else if (breakRow && _.has(cell, 'id')) {
+                                cell.pageBreak = 'before';
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+    
+    __initializePdfDefinition() {
+        this.__definition = {
+            "content": [],
+            pageSize: 'A4',
+            pageMargins: [ 40, 60, 40, 60 ],
+            defaultStyle: {
+                font: 'Roboto', //'Helvetica'
+            },
+            styles: {
+                tableBody: {
+                    fontSize: 10,
+                    margin: [0, 5, 0, 15]
+                },
+                tableHeader: {
+                    fontSize: 10,
+                    bold: true
+                },
+                heading1: {
+                    fontSize: 18,
+                    bold: true,
+                    margin: [0, 0, 0, 10]
+                },
+                heading2: {
+                    fontSize: 14,
+                    bold: true,
+                    margin: [0, 10, 0, 5]
+                },
+                paragraph: {
+                    fontSize: 10,
+                    bold: false,
+                    italics: false
+                }
+            }
+        };
+        this.__automaticPageBreak = false;
+    }
+
+    __getThOrTdContent(thTdNode, settings) {
+        let result = {};
+        let text = "";
+
+        if(!_.isNil(thTdNode.elements)){
+            _.forEach(thTdNode.elements, childElement => {
+                if(childElement.type === "text") {
+                    text = text + childElement.text;
+                } else if (childElement.type === "element" && childElement.name === "pageNumber" && !_.isNil(settings.currentPage)) {
+                    text = text + settings.currentPage;
+                } else if (childElement.type === "element" && childElement.name === "img") {
+                    result.image = this.__getImageDefinition(childElement, false);
+                }
+            });
+        }
+        result.text = text;
+
+        return result;
+    }
+
+    __getHeadingDefinition(headingNode, headingStyle) {
+        return this.__createHeadingOrParagraphText(headingNode, headingNode.elements[0].text, headingStyle);
+    }
+
+    __getParagraphDefinition(paragraphNode, paragraphStyle) {
+        return this.__createHeadingOrParagraphText(paragraphNode, paragraphNode.elements[0].text, paragraphStyle);
+    }
+
+    __getImageDefinition(imageNode, useAlignment) {
+        let img = {};
+
+        if (!_.isNil(imageNode)){
+            let atr = imageNode.attributes;
+            let imageId = atr.id;
+            let mimeType = atr.mimeType;
+
+            if (!_.isNil(imageId) && this.__isImageCached(imageId)) {
+                // => png / jpeg image already in cache => simply (re)use it ...
+                img = {image: imageId};
+
+            } else {
+
+                if (mimeType === "image/svg+xml") {
+                    // => svg image handling (vector graphics)
+                    let src = atr.src.split(",");
+                    let data = src[1];
+                    let txt;
+
+                    if ((typeof window === 'object') && (typeof window.atob === 'function')) {
+                        // we do expect an utf8 string
+                        txt = decodeURIComponent(encodeURIComponent(window.atob(data)));
+                    } else {
+                        let buf = Buffer.from(data, 'base64');
+                        txt = buf.toString('utf8');
+                    }
+                    img = {svg: txt};
+
+                } else {
+                    // => png / jpeg image handling (raster graphics)
+                    // add image to cache
+                    this.__addImageToCache(imageId, atr.src);
+                    img = {image: imageId};          
+
+                }
+            }            
+
+            if (!_.isNil(atr.width)) {
+                img.width = parseInt(atr.width, 10);
+            }
+            if (!_.isNil(atr.height)) {
+                img.height = parseInt(atr.height, 10);
+            }
+            if (!_.isNil(atr.fit)) {
+                let fit = atr.fit.split(',');
+                let w = parseInt(fit[0], 10);
+                let h = parseInt(fit[1], 10);
+                img.fit = [w,h];
+            }
+
+            if (!_.isNil(atr.alignment) && (true === useAlignment)) {
+                let alignmentAttribute = this.__checkEnumAttribute(imageNode, 'alignment', ["left", "center", "right"], null);
+
+                if (!_.isNil(alignmentAttribute)) {
+                    img.alignment = alignmentAttribute;
+                }
+            }
+        }
+
+        return img;
+    }
+
+    __addImageToCache(imageId, imageData) {
+        // init image cache if required
+        if (!_.has(this.__definition, 'images')) {  
+            _.assign(this.__definition, {
+                images: {}
+            });
+        }
+
+        // add image to cache
+        if (!_.has(this.__definition.images, imageId)) {
+            this.__definition.images[imageId] = imageData;
+        }
+    }
+
+    __isImageCached(imageId) {
+        return (_.has(this.__definition, 'images') && _.has(this.__definition.images, imageId));
+    }
+
+    __checkSpansAndColumns(pdfTableDefinition) {
+        let rows = 0;
+        let columns = 0;
+
+        let rowCount = pdfTableDefinition.table.body.length;
+        let columnCount = pdfTableDefinition.table.widths.length;
+
+        for (rows=0; rows<rowCount; rows++) {
+            let row = pdfTableDefinition.table.body[rows];
+
+            if (row.length > columnCount) {
+                row.length = columnCount;
+            } else if (row.length < columnCount) {
+                do {
+                    row.push("");
+                } while(row.length < columnCount);
+            }
+
+            let maxRowSpan = rowCount-rows;
+
+            for (columns=0; columns<columnCount; columns++) {
+                let column = row[columns];
+                let maxColSpan = columnCount-columns;
+
+                if (!_.isString(column)) {
+                    if (!_.isNil(column["colSpan"])) {
+                        if (column.colSpan > maxColSpan) {
+                            column.colSpan = maxColSpan;
+                        }
+                        if (column.colSpan < 2) {
+                            delete column.colSpan;
+                        }
+                        if ((Object.keys(column).length === 1) && !_.isNil(column["text"])) {
+                            row[columns] = column.text;
+                        }
+                    }
+                    if (!_.isNil(column["rowSpan"])) {
+                        if (column.rowSpan > maxRowSpan) {
+                            column.rowSpan = maxRowSpan;
+                        }
+                        if (column.rowSpan < 2) {
+                            delete column.rowSpan;
+                        }
+                        if ((Object.keys(column).length === 1) && !_.isNil(column["text"])) {
+                            row[columns] = column.text;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    __checkIntegerAttribute(element, attributeName, allowedStrings, onlyPositiveNumbers, defaultValue) {
+        let bElement = !_.isNil(element) && _.isObject(element.attributes);
+        let bAttribute = bElement && _.isString(attributeName) && (attributeName !== "") && !_.isNil(element.attributes[attributeName]);
+        let bAllowedStrings = !_.isNil(allowedStrings) && _.isArray(allowedStrings) && (allowedStrings.length > 0);
+        let bPositiveNumbers = !_.isNil(onlyPositiveNumbers) && _.isBoolean(onlyPositiveNumbers) && (onlyPositiveNumbers === true);
+
+        if (bAttribute) {
+            let attribute = element.attributes[attributeName];
+            let i = 0;
+
+            if (bAllowedStrings && _.isString(attribute)){
+                for (i=0; i<allowedStrings.length; i++) {
+                    if (attribute === allowedStrings[i]) {
+                        return attribute;
+                    }
+                }
+            }
+
+            let parsed = parseInt(attribute, 10);
+
+            if(!isNaN(parsed)) {
+                if (bPositiveNumbers && (parsed < 0))
+                {
+                    return defaultValue;
+                } else {
+                    return parsed;
+                }
+            } else {
+                return defaultValue;
+            }
+        } else {
+            return defaultValue;
+        }
+    }
+
+    __checkBooleanAttribute(element, attributeName,defaultValue) {
+        let bElement = !_.isNil(element) && _.isObject(element.attributes);
+        let bAttribute = bElement && _.isString(attributeName) && (attributeName !== "") && !_.isNil(element.attributes[attributeName]);
+
+        if(bAttribute) {
+            let attributeValue = element.attributes[attributeName];
+            if (attributeValue === "true") {
+                return true;
+            } else if (attributeValue === "false") {
+                return false;
+            } else {
+                return defaultValue;
+            }
+        } else {
+            return defaultValue;
+        }
+    }
+
+    __checkEnumAttribute(element, attributeName,allowedEnumValues ,defaultValue) {
+        let bElement = !_.isNil(element) && _.isObject(element.attributes);
+        let bAttribute = bElement && _.isString(attributeName) && (attributeName !== "") && !_.isNil(element.attributes[attributeName]);
+
+        if(bAttribute) {
+            let attributeValue = element.attributes[attributeName];
+            if(allowedEnumValues.includes(attributeValue)){
+                return attributeValue;
+            } else {
+                return defaultValue;
+            }
+        } else {
+            return defaultValue;
+        }
+    }
+
+    __checkStringAttribute(element, attributeName, defaultValue) {
+        let bElement = !_.isNil(element) && _.isObject(element.attributes);
+        let bAttribute = bElement && _.isString(attributeName) && (attributeName !== "") && !_.isNil(element.attributes[attributeName]);
+
+        if(bAttribute) {
+            let attributeValue = element.attributes[attributeName];
+            if(_.isString(attributeValue)){
+                return attributeValue;
+            } else {
+                return defaultValue;
+            }
+        } else {
+            return defaultValue;
+        }
+    }
+
+    __applyNumberFormatAttribute(element, value) {
+        let bElement = !_.isNil(element) && _.isObject(element.attributes);
+        let bAttribute = bElement && !_.isNil(element.attributes.numberFormat) && !_.isNil(element.attributes.decimalSeparator) && !_.isNil(element.attributes.thousandSeparator);
+
+        if (bAttribute) {
+            return this.__format.formatDecimalV2(value, element.attributes.numberFormat, element.attributes.decimalSeparator, element.attributes.thousandSeparator);
+        } else {
+            return value;
+        }
+    }
+
+    __createHeadingOrParagraphText(currentNode, text, style) {
+        let result = { "text": text };
+
+        let boldAttribute = this.__checkBooleanAttribute(currentNode, 'bold', null);
+        let italicsAttribute = this.__checkBooleanAttribute(currentNode, 'italics', null);
+        let alignmentAttribute = this.__checkEnumAttribute(currentNode, 'alignment', ["left", "center", "right"], null);
+
+        if (_.isNil(boldAttribute) && _.isNil(italicsAttribute) && _.isNil(alignmentAttribute)) {
+            result.style = style;
+        } else {
+            let styleJson = this.__definition.styles[style];
+
+            if (!_.isNil(styleJson.fontSize)) {
+                result.fontSize = styleJson.fontSize;
+            }
+
+            if (!_.isNil(styleJson.bold)) {
+                result.bold = styleJson.bold;
+            }
+
+            if (!_.isNil(styleJson.italics)) {
+                result.italics = styleJson.italics;
+            }
+
+            if (!_.isNil(styleJson.margin)) {
+                result.margin = styleJson.margin;
+            }
+
+            if (!_.isNil(boldAttribute)) {
+                result.bold = boldAttribute;
+            }
+
+            if (!_.isNil(italicsAttribute)) {
+                result.italics = italicsAttribute;
+            }
+
+            if (!_.isNil(alignmentAttribute)) {
+                result.alignment = alignmentAttribute;
+            }
+        }
+
+        return result;
+    }
+
+    __createTableColumn(content, style, colSpan, rowSpan, alignment, bold, italics, cellId) {
+        let bTextOnly = _.isNil(content.image) && _.isNil(style) && _.isNil(colSpan) && _.isNil(rowSpan)
+            && _.isNil(alignment) && _.isNil(bold) && _.isNil(italics) && _.isNil(cellId);
+
+        if (bTextOnly) {
+            return content.text;
+        }
+
+        let column = {};
+
+        //Image wins over text if both are defined.
+        if (!_.isNil(content.image)) {
+            column = content.image;
+        } else {
+            column.text = content.text;
+        }
+
+        if (!_.isNil(style)) {
+            column.style = style;
+        }
+        if (!_.isNil(colSpan)) {
+            column.colSpan = colSpan;
+        }
+        if (!_.isNil(rowSpan)) {
+            column.rowSpan = rowSpan;
+        }
+        if (!_.isNil(alignment)) {
+            column.alignment = alignment;
+        }
+        if (!_.isNil(bold)) {
+            column.bold = bold;
+        }
+        if (!_.isNil(italics)) {
+            column.italics = italics;
+        }
+        if (!_.isNil(cellId)) {
+            column.id = cellId;
+        }
+
+        return column;
+    }
+
+    __getTableCellAttributes(thOrTdNode){
+        let colSpanAttributeValue = this.__checkIntegerAttribute(thOrTdNode, 'colSpan', [], true, null);
+        let rowSpanAttributeValue = this.__checkIntegerAttribute(thOrTdNode, 'rowSpan', [], true, null);
+        let boldAttribute = this.__checkBooleanAttribute(thOrTdNode, 'bold', null);
+        let italicsAttribute = this.__checkBooleanAttribute(thOrTdNode, 'italics', null);
+        let alignmentAttribute = this.__checkEnumAttribute(thOrTdNode, 'alignment', ["left", "center", "right"], null);
+        let cellId = this.__checkStringAttribute(thOrTdNode, 'id', null);
+
+        return  [colSpanAttributeValue, rowSpanAttributeValue, alignmentAttribute, boldAttribute, italicsAttribute, cellId];
+    }
+
+    __evaluateTableDefinitionRowBreak(tableNode, dynamicPageBreak) {
+        let dontBreakRows = this.__checkBooleanAttribute(tableNode, "dontBreakRows", true);
+        // deactivate automatic row breaks for tables requiring dynamic page breaks
+        if (dynamicPageBreak) {
+            dontBreakRows = false;
+        }
+        return dontBreakRows;
+    }
+
+    __evaluateTableDefinitionDynamicPageBreak(tableNode) {
+        let automaticPageBreak = this.__automaticPageBreak; // => coming from PrintV2 action configuration
+        let dynamicPageBreak = (automaticPageBreak && this.__checkBooleanAttribute(tableNode, "dynamicPageBreak", false));
+        if (dynamicPageBreak) {
+            this.__configurePdfDefinitionForDynamicPageBreak();
+        }
+        return dynamicPageBreak;
+    }
+
+    __configurePdfDefinitionForDynamicPageBreak() {
+        if (!_.has(this.__definition, 'pageBreakBefore')) {
+            _.assign(this.__definition, {
+                pageBreakBefore: this.__calculatePageBreakBefore.bind(this)
+            });
+            this.__definition.dynamicPageBreak = true;
+        }
+    }
+
+    __getTableDefinition(tableNode, settings) {
+        if(_.isNil(settings)) {settings = {};}
+
+        let dynamicPageBreak = this.__evaluateTableDefinitionDynamicPageBreak(tableNode);
+        let dontBreakRows = this.__evaluateTableDefinitionRowBreak(tableNode, dynamicPageBreak);
+        let pdfTableDefinition = {
+            style: "tableBody",
+            table: {
+                dontBreakRows: dontBreakRows,
+                headerRows: 0,
+                body: [],
+                widths: []
+            }
+        };
+        if (dynamicPageBreak) {
+            pdfTableDefinition.table.dynamicPageBreak = true;
+        }
+
+        if(!_.isNil(settings.layout)) {
+            pdfTableDefinition.layout = settings.layout;
+        }
+        if(!_.isNil(tableNode.attributes) && !_.isNil(tableNode.attributes.tableLayout)){
+            pdfTableDefinition.layout = tableNode.attributes.tableLayout;
+        }
+
+        let bNoWidths = false;
+        let theadNode = _.find(tableNode.elements, {name: 'thead'});
+        let tbodyNode = _.find(tableNode.elements, {name: 'tbody'});
+
+        if(!_.isNil(theadNode)) {
+            _.forEach(theadNode.elements, headerTrNode=> {
+                let row = [];
+                _.forEach(headerTrNode.elements, value => {
+                    let attributeValues = this.__getTableCellAttributes(value);
+
+                    if (pdfTableDefinition.table.headerRows === 0) {
+                        let widthAttributeValue = this.__checkIntegerAttribute(value, 'width', ['*', 'auto'], true, 'auto');
+                        pdfTableDefinition.table.widths.push(widthAttributeValue);
+                    }
+                    let content  = this.__getThOrTdContent(value, settings);
+                    row.push(this.__createTableColumn(content, 'tableHeader', ...attributeValues));
+                });
+
+                pdfTableDefinition.table.body.push(row);
+                pdfTableDefinition.table.headerRows += 1;
+            });
+        } else if(!_.isNil(tbodyNode)) {
+            bNoWidths = true;
+        } else {
+            pdfTableDefinition.table.widths = ['auto'];
+            pdfTableDefinition.table.body = [['']];
+
+            return pdfTableDefinition;
+        }
+
+        if(!_.isNil(tbodyNode)) {
+            _.forEach(tbodyNode.elements, tbodyTrNode=> {
+                let row = [];
+                _.forEach(tbodyTrNode.elements, value => {
+                    let attributeValues = this.__getTableCellAttributes(value);
+
+                    if ((bNoWidths === true)) {
+                        let widthAttributeValue = this.__checkIntegerAttribute(value, 'width', ['*', 'auto'], true, 'auto');
+                        pdfTableDefinition.table.widths.push(widthAttributeValue);
+                    }
+                    let content  = this.__getThOrTdContent(value, settings);
+                    content.text = this.__applyNumberFormatAttribute(value, content.text);
+
+                    row.push(this.__createTableColumn(content, null, ...attributeValues));
+                });
+
+                bNoWidths = false;
+                pdfTableDefinition.table.body.push(row);
+            });
+        }
+
+        this.__checkSpansAndColumns(pdfTableDefinition);
+    
+        return pdfTableDefinition;
+    }
+
+    __addBody(definition, json) {
+
+        _.forEach(json.elements, contractElement => {
+            if(contractElement.name === 'table') {
+                let tableDefintion = this.__getTableDefinition(contractElement);
+                definition.content.push(tableDefintion);
+            } else if (contractElement.name === 'h1') {
+                let h1Defintion = this.__getHeadingDefinition(contractElement, STYLE_HEADING1);
+                definition.content.push(h1Defintion);
+            } else if (contractElement.name === 'h2') {
+                let h2Defintion = this.__getHeadingDefinition(contractElement, STYLE_HEADING2);
+                definition.content.push(h2Defintion);
+            } else if (contractElement.name === 'p') {
+                let paragraphDefintion = this.__getParagraphDefinition(contractElement, STYLE_PARAGRAPH);
+                definition.content.push(paragraphDefintion);
+            } else if (contractElement.name === 'img' || contractElement.name === 'signature') {
+                let imageDefintion = this.__getImageDefinition(contractElement, true);
+                definition.content.push(imageDefintion);
+            }
+        });
+
+    }
+
+    __addHeader(definition, json) {
+        let headerNode = _.find(json.elements, {name:"header"});
+
+        if(!_.isNil(headerNode)) {
+            let imageNode = _.find(headerNode.elements, {name:"img"});
+            let tableNode = _.find(headerNode.elements, {name:"table"});
+
+            //The coverage report only works correctly when isWriteDataEnabled() returns true in the Unit Tests.
+            definition.header = (currentPage/*, pageCount, pageSize*/) => {
+                let imageDefinition = (!_.isNil(imageNode)) ? this.__getImageDefinition(imageNode, true) : null;
+                let tableDefinition = (!_.isNil(tableNode)) ? this.__getTableDefinition(tableNode, {"layout": "noBorders", "currentPage": currentPage}) : null;
+
+                if (!_.isNil(imageDefinition) && !_.isNil(tableDefinition)) {
+                    return [imageDefinition, tableDefinition];
+                } else if (!_.isNil(tableDefinition)) {
+                    return tableDefinition;
+                } else if (!_.isNil(imageDefinition)) {
+                    return imageDefinition;
+                } else {
+                    return null;
+                }
+            };
+        }
+    }
+
+    __addFooter(definition, json) {
+        let footerNode = _.find(json.elements, {name:"footer"});
+        if(!_.isNil(footerNode)) {
+            let tableNode = _.find(footerNode.elements, {name:"table"});
+            let bTableNode = !_.isNil(tableNode);
+
+            //The coverage report only works correctly when isWriteDataEnabled() returns true in the Unit Tests.
+            definition.footer = (currentPage/*, pageCount, pageSize*/) => {
+                let tableDefinition = bTableNode ? this.__getTableDefinition(tableNode,  {"layout": "noBorders", "currentPage":currentPage}) : null;
+                return tableDefinition;
+            };
+        }
+    }
+
+    __addDocumentMetadata(definition, documentProperties){
+        definition.info = {};
+        definition.info.creator = "Consumer Goods Cloud";
+        definition.info.producer = "Consumer Goods Cloud";
+        _.forEach(documentProperties, (value, key) => {
+            definition.info[key] = value;
+        });
+    }
+
+    __configureAutomaticPageBreak(reportLayout) {
+        if(!_.isNil(reportLayout.attributes) && !_.isNil(reportLayout.attributes.automaticPageBreak)){
+            this.__automaticPageBreak = reportLayout.attributes.automaticPageBreak;
+        }
+    }
+
+    __addPageDimensionsOrientationMarginsWatermark(definition, reportLayout){
+        if(!_.isNil(reportLayout.attributes) && !_.isNil(reportLayout.attributes.pageSize)){
+            definition.pageSize = reportLayout.attributes.pageSize;
+        }
+        if(!_.isNil(reportLayout.attributes) && !_.isNil(reportLayout.attributes.watermark)){
+            definition.watermark =  {text: reportLayout.attributes.watermark, opacity:0.1, fontSize: 120};
+        }
+        if(!_.isNil(reportLayout.attributes) && !_.isNil(reportLayout.attributes.pageMargins)){
+            definition.pageMargins = JSON.parse(reportLayout.attributes.pageMargins);
+        }
+    }
+
+    __isLastMainRowOnPage(followingNodesOnPage) {
+        let result = false;
+
+        if (!_.isNil(followingNodesOnPage) && _.isArray(followingNodesOnPage)) {
+            result = (followingNodesOnPage.length === 0) || !(_.some(followingNodesOnPage, y => {
+                let tcid = TableCellIdentifier.fromString(y.id);
+                return (tcid.isKnown() && tcid.isFirstMainRowCell());
+            }));
+        }
+
+        return result;
+    }
+
+    __isFirstNodeOnNextPageFirstMainRowCell(nodesOnNextPage) {
+        let result = false;
+
+        if (!_.isNil(nodesOnNextPage) && _.isArray(nodesOnNextPage) && nodesOnNextPage.length > 0) {
+            let firstNodeOnNextPage = _.first(nodesOnNextPage);
+            let tcid = TableCellIdentifier.fromString(firstNodeOnNextPage.id);
+            result = (tcid.isKnown() && tcid.isFirstMainRowCell());
+        }
+
+        return result;
+    }
+
+    __calculatePageBreakForParentChildRows(currentNode, followingNodesOnPage, nodesOnNextPage, previousNodesOnPage, tcidCurrentNode) {
+        let doPageBreak = false;
+
+        // dynamic pageBreak logic for parent-child rows
+        if (!_.isNil(previousNodesOnPage) && _.isArray(previousNodesOnPage) && previousNodesOnPage.length > 0) {
+            let previousNode = _.last(previousNodesOnPage);
+            let tcidPreviousNode = TableCellIdentifier.fromString(previousNode.id);
+
+            // => check if we are the first cell of a main row ...
+            if (tcidCurrentNode.isFirstMainRowCell()) {
+
+                if (!_.isNil(followingNodesOnPage) && _.isArray(followingNodesOnPage)) {
+
+                    let isCurrentNodeLastHeadOnPageX = this.__isLastMainRowOnPage(followingNodesOnPage);
+                    let isFirstNodeOnNextPageFirstMainRowCellX = this.__isFirstNodeOnNextPageFirstMainRowCell(nodesOnNextPage);
+                    let isPageBreakRelevant = (tcidPreviousNode.isKnown() && (tcidPreviousNode.isFirstMainRowCell() || tcidPreviousNode.isSubsequentMainRowCell() || tcidPreviousNode.isFirstCorrelatedRowCell() || tcidPreviousNode.isSubsequentCorrelatedRowCell()));
+
+                    doPageBreak = (isCurrentNodeLastHeadOnPageX && !isFirstNodeOnNextPageFirstMainRowCellX && isPageBreakRelevant);
+                }
+
+            } else if (tcidCurrentNode.isSubsequentMainRowCell()) {
+
+                doPageBreak = (!tcidPreviousNode.isFirstMainRowCell() && !tcidPreviousNode.isSubsequentMainRowCell() || !(tcidCurrentNode.sharesMainRow(tcidPreviousNode)));
+            }
+        }
+
+        return doPageBreak;
+    }
+
+
+    __calculatePageBreakForBrokenRows(currentNode, followingNodesOnPage, nodesOnNextPage, previousNodesOnPage, tcidCurrentNode) {
+        let doPageBreak = false;
+
+        // => check if we are the first cell of a row ...
+        if (tcidCurrentNode.isFirstMainRowCell() || tcidCurrentNode.isFirstCorrelatedRowCell()) {
+            // check for 'broken' row ...
+            // => check if i am the last row
+            let isLastRowOnPageX = (_.every(followingNodesOnPage, node => {
+                let tcidNode = TableCellIdentifier.fromString(node.id);
+                return !tcidNode.isKnown() || (tcidNode.isKnown() && tcidCurrentNode.sharesCorrelatedRow(tcidNode));
+            }));
+
+            if (isLastRowOnPageX) {
+                // check if any cell of the current row extends over more than one page => pageBreak!
+                // => check current cell (first cell of row)
+                doPageBreak = (!_.isNil(currentNode.pageNumbers) && _.isArray(currentNode.pageNumbers) && currentNode.pageNumbers.length > 1);
+                if (!doPageBreak) {
+                    // => check following cells on current page and cells on next page for page overlaps (other cells of row)
+                    doPageBreak = (_.some(followingNodesOnPage, node => {
+                        let tcidNode = TableCellIdentifier.fromString(node.id);
+                        if (tcidNode.isKnown() && tcidCurrentNode.sharesCorrelatedRow(tcidNode)) {
+                            return !_.isEqual(currentNode.pageNumbers, node.pageNumbers);
+                        }
+                        return false;
+                    }) || (_.some(nodesOnNextPage, node => {
+                        let tcidNode = TableCellIdentifier.fromString(node.id);
+                        if (tcidNode.isKnown() && tcidCurrentNode.sharesCorrelatedRow(tcidNode)) {
+                            return !_.isEqual(currentNode.pageNumbers, node.pageNumbers);
+                        }
+                        return false;
+                    })));
+                }
+            }
+        } else if (tcidCurrentNode.isSubsequentMainRowCell() || tcidCurrentNode.isSubsequentCorrelatedRowCell()) {
+            // => check other row cells ...
+            if (!_.isNil(previousNodesOnPage) && _.isArray(previousNodesOnPage) && previousNodesOnPage.length > 0) {
+                // check if last previous node is NOT precursor cell of current one => pageBreak!
+                let previousNode = _.last(previousNodesOnPage);
+                let tcidPreviousNode = TableCellIdentifier.fromString(previousNode.id);
+                doPageBreak = !tcidCurrentNode.isPreviousCell(tcidPreviousNode);
+            }
+        }
+
+        return doPageBreak;
+    }
+
+    __calculatePageBreakBefore(currentNode, followingNodesOnPage, nodesOnNextPage, previousNodesOnPage) {
+        let doPageBreak = false;
+      
+        // looking for potential pageBreaks only makes sense if there are elements to be placed there (=> might require adaption for subtotals)
+        if (!_.isNil(nodesOnNextPage) && _.isArray(nodesOnNextPage) && nodesOnNextPage.length > 0) {
+
+            // get table cell identifier
+            let tcidCurrentNode = TableCellIdentifier.fromString(currentNode.id);
+            if (!_.isNil(tcidCurrentNode) && tcidCurrentNode.isKnown()) {
+
+                // check for dynamic pageBreak of parent-child rows
+                doPageBreak = this.__calculatePageBreakForParentChildRows(currentNode, followingNodesOnPage, nodesOnNextPage, previousNodesOnPage, tcidCurrentNode);                          
+                if (!doPageBreak) {                                  
+                    // check for dynamic pageBreak of 'broken' row
+                    doPageBreak = this.__calculatePageBreakForBrokenRows(currentNode, followingNodesOnPage, nodesOnNextPage, previousNodesOnPage, tcidCurrentNode);                 
+                }
+                
+                if (doPageBreak && !_.isUndefined(this.__definition.dynamicPageBreak) && this.__definition.dynamicPageBreak) {                
+                    if (tcidCurrentNode.isFirstMainRowCell() || tcidCurrentNode.isFirstCorrelatedRowCell()) {
+                        // cache dynamic pageBreak to turn them into manual ones during the second run ...
+                        this.__definition.dynamicPageBreakData.push(tcidCurrentNode.toString());                   
+                    } else {
+                        doPageBreak = false;
+                    }
+                }
+
+            }
+        }       
+
+        return doPageBreak;
+    }
+
+    __createPdfDocument(pdfDefinition, pdfCreationFunction) {
+        // clone pdf definition if applicable ...
+        let pdfDefinitionCopy = null;
+        if (!_.isNil(pdfDefinition) && !_.isUndefined(pdfDefinition.dynamicPageBreak) && pdfDefinition.dynamicPageBreak &&
+            !_.isNil(pdfCreationFunction) && _.isFunction(pdfCreationFunction)) {
+            // init empty dynamicPageBreakData ...
+            _.assign(pdfDefinition, {
+                dynamicPageBreakData: []
+            });
+
+            pdfDefinitionCopy = _.cloneDeep(pdfDefinition);
+            // skip header / footer for initial layouting and move them to final layouting
+            if (!_.isUndefined(pdfDefinition.header)) {
+                let headerFunction = pdfDefinition.header;
+                _.assign(pdfDefinitionCopy, {
+                    'header': headerFunction
+                });
+                _.unset(pdfDefinition, 'header');
+            }
+            if (!_.isUndefined(pdfDefinition.footer)) {
+                let footerFunction = pdfDefinition.footer;
+                _.assign(pdfDefinitionCopy, {
+                    'footer': footerFunction
+                });
+                _.unset(pdfDefinition, 'footer');
+            }
+            // remove dynamic pageBreak logic
+            _.unset(pdfDefinitionCopy, 'pageBreakBefore');
+        }
+
+        // set pdf definition to be layouted ...
+        this.__definition = pdfDefinition;
+
+        // exec pdfCreation function ...
+        pdfCreationFunction.apply(this, [pdfDefinition]);
+
+        return pdfDefinitionCopy;
+    }
+
+    __createFinalPdfDocument(pdfDefinition, pdfDefinitionCopy, pdfCreationFunction) {
+        // perform pageBreak magic ...
+        if (!_.isNil(pdfDefinition) && !_.isUndefined(pdfDefinition.dynamicPageBreak) && pdfDefinition.dynamicPageBreak &&
+            !_.isUndefined(pdfDefinition.dynamicPageBreakData) && _.isArray(pdfDefinition.dynamicPageBreakData) &&
+            !_.isNil(pdfDefinitionCopy) && !_.isUndefined(pdfDefinitionCopy.dynamicPageBreak) && pdfDefinitionCopy.dynamicPageBreak &&
+            !_.isNil(pdfCreationFunction) && _.isFunction(pdfCreationFunction)) {
+
+            // transfer dynamicPageBreakData from pdf definition to its copy
+            pdfDefinitionCopy.dynamicPageBreakData =  pdfDefinition.dynamicPageBreakData;
+
+            this.__applyPageBreakData(pdfDefinitionCopy);
+
+            // set pdf definition to be layouted ...
+            this.__definition = pdfDefinitionCopy;
+
+            // exec pdfCreation function ...
+            pdfCreationFunction.apply(this, [pdfDefinitionCopy]);
+        }
+    }
+
+    toPdfDefinition(json/*, format*/) {
+        this.__initializePdfDefinition();
+        this.__addDocumentMetadata(this.__definition, json.documentProperties);
+        let reportLayout = json.reportLayout;
+        this.__configureAutomaticPageBreak(reportLayout);
+        this.__addPageDimensionsOrientationMarginsWatermark(this.__definition, reportLayout);
+        this.__addHeader(this.__definition, reportLayout);
+        this.__addBody(this.__definition, reportLayout);
+        this.__addFooter(this.__definition,reportLayout);
+        return this.__definition;
+    }
+
+    writeToStream(pdfDefinition, stream) {
+        // setup pdf creator ...
+        let printer = new PdfPrinter(ServerFonts);
+        let pdfDoc = null; 
+        let pdfCreatorFunction = (definition) => {
+            printer = new PdfPrinter(ServerFonts);
+            pdfDoc = printer.createPdfKitDocument(definition, {
+                tableLayouts: TableLayouts
+            });
+        };
+
+        // create pdf and prepare for recreation if applicable ...
+        let pdfDefinitionCopy = this.__createPdfDocument(pdfDefinition, pdfCreatorFunction);
+
+        // recreate pdf if applicable ...
+        this.__createFinalPdfDocument(pdfDefinition, pdfDefinitionCopy, pdfCreatorFunction);
+
+        pdfDoc.pipe(stream);
+        pdfDoc.end();
+
+        return (pdfDefinitionCopy || pdfDefinition);
+    }
+
+    async __createPdfDocumentAsync(pdfDefinition) {
+        return new Promise((resolve, reject) => {
+            try {
+            
+                // clone pdf definition if applicable ...
+                let pdfDefinitionCopy = null;
+                if (!_.isNil(pdfDefinition) && !_.isUndefined(pdfDefinition.dynamicPageBreak) && pdfDefinition.dynamicPageBreak) {
+                    // init empty dynamicPageBreakData ...
+                    _.assign(pdfDefinition, {
+                        dynamicPageBreakData: []
+                    });
+
+                    pdfDefinitionCopy = _.cloneDeep(pdfDefinition);
+                    // skip header / footer for initial layouting and move them to final layouting
+                    if (!_.isUndefined(pdfDefinition.header)) {
+                        let headerFunction = pdfDefinition.header;
+                        _.assign(pdfDefinitionCopy, {
+                            'header': headerFunction
+                        });
+                        _.unset(pdfDefinition, 'header');
+                    }
+                    if (!_.isUndefined(pdfDefinition.footer)) {
+                        let footerFunction = pdfDefinition.footer;
+                        _.assign(pdfDefinitionCopy, {
+                            'footer': footerFunction
+                        });
+                        _.unset(pdfDefinition, 'footer');
+                    }
+                    // remove dynamic pageBreak logic
+                    _.unset(pdfDefinitionCopy, 'pageBreakBefore');
+                }
+
+                // set pdf definition to be layouted ...
+                this.__definition = pdfDefinition;   
+                
+                resolve(pdfDefinitionCopy);
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    async __createFinalPdfDocumentAsync(pdfDefinition, pdfDefinitionCopy) {
+        return new Promise((resolve, reject) => {
+            try {
+                // perform pageBreak magic ...
+                if (!_.isNil(pdfDefinition) && !_.isUndefined(pdfDefinition.dynamicPageBreak) && pdfDefinition.dynamicPageBreak &&
+                    !_.isUndefined(pdfDefinition.dynamicPageBreakData) && _.isArray(pdfDefinition.dynamicPageBreakData) &&
+                    !_.isNil(pdfDefinitionCopy) && !_.isUndefined(pdfDefinitionCopy.dynamicPageBreak) && pdfDefinitionCopy.dynamicPageBreak) {
+
+                    // transfer dynamicPageBreakData from pdf definition to its copy
+                    pdfDefinitionCopy.dynamicPageBreakData =  pdfDefinition.dynamicPageBreakData;
+
+                    this.__applyPageBreakData(pdfDefinitionCopy);
+
+                    // set pdf definition to be layouted ...
+                    this.__definition = pdfDefinitionCopy;          
+                }
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });     
+    }
+
+    async __getPdfDataAsync(type, pdfDefinition, previousResult = null) {
+        return new Promise((resolve, reject) => {
+            try {
+                if (_.isNil(pdfDefinition) && !_.isNil(previousResult)) {
+                    resolve(previousResult);
+                } else {
+                    let pdfDocGenerator = this.__pdfMake.createPdf(pdfDefinition, TableLayouts, BrowserFonts, BrowserFontsVfs.pdfMake.vfs);
+
+                    switch (type) {
+                    case EXPORT_TYPE.BASE_64:
+                        pdfDocGenerator.getBase64((data) => {
+                            resolve(data);
+                        });
+                        break;
+
+                    case EXPORT_TYPE.BLOB:
+                        pdfDocGenerator.getBlob((blob) => {
+                            resolve(blob);
+                        });
+                        break;
+
+                    case EXPORT_TYPE.DATA_URL:
+                        pdfDocGenerator.getDataUrl((dataUrl) => {
+                            resolve(dataUrl);
+                        });
+                        break;
+
+                    default:                        
+                        throw new Error('Unknown export type: ' + type );                       
+                    }
+                }
+
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    async toBase64(pdfDefinition) {
+        // hint: works only in browser avoid calling it in node.js
+        let pdfDefinitionCopy = null;
+        let firstResult = null;   
+        
+        return this.__createPdfDocumentAsync(pdfDefinition).then((pdfDef) => {
+            pdfDefinitionCopy = pdfDef;
+            return this.__getPdfDataAsync(EXPORT_TYPE.BASE_64, pdfDefinition);
+        }).then((pdfData) => {
+            firstResult = pdfData;
+            return this.__createFinalPdfDocumentAsync(pdfDefinition, pdfDefinitionCopy);
+        }).then(() => {
+            return this.__getPdfDataAsync(EXPORT_TYPE.BASE_64, pdfDefinitionCopy, firstResult); 
+        });
+        
+    }
+
+    async toBlob(pdfDefinition) {
+        // hint: works only in browser avoid calling it in node.js
+        let pdfDefinitionCopy = null;
+        let firstResult = null;   
+        
+        return this.__createPdfDocumentAsync(pdfDefinition).then((pdfDef) => {
+            pdfDefinitionCopy = pdfDef;
+            return this.__getPdfDataAsync(EXPORT_TYPE.BLOB, pdfDefinition);
+        }).then((pdfData) => {
+            firstResult = pdfData;
+            return this.__createFinalPdfDocumentAsync(pdfDefinition, pdfDefinitionCopy);
+        }).then(() => {
+            return this.__getPdfDataAsync(EXPORT_TYPE.BLOB, pdfDefinitionCopy, firstResult); 
+        });
+    }
+    
+    async toDataUrl(pdfDefinition) {
+        // hint: works only in browser avoid calling it in node.js
+        let pdfDefinitionCopy = null;
+        let firstResult = null;   
+        
+        return this.__createPdfDocumentAsync(pdfDefinition).then((pdfDef) => {
+            pdfDefinitionCopy = pdfDef;
+            return this.__getPdfDataAsync(EXPORT_TYPE.DATA_URL, pdfDefinition);
+        }).then((pdfData) => {
+            firstResult = pdfData;
+            return this.__createFinalPdfDocumentAsync(pdfDefinition, pdfDefinitionCopy);
+        }).then(() => {
+            return this.__getPdfDataAsync(EXPORT_TYPE.DATA_URL, pdfDefinitionCopy, firstResult); 
+        });
+      
+    }
+
+    static isValidFormat(format) {
+        let supportedFormats = ['A3', 'A4', 'A5', 'Legal', 'Letter', 'Tabloid'];
+        return supportedFormats.includes(format);
+    }
+
+}
+
+
+module.exports = PdfConverter;