@ind-rcg/plugins-printengine 250.1004.0 → 254.1005.0

package/dist/dev/src/index.js

@@ -52,18 +52,29 @@ function __validateCommonParameters(contract, params, format){
     }
 }
 
-function __innerPrintLogic(printType, contract, params, _stream, format) {
+function __innerPrintLogic(printType, contract, params, _stream, format, config) {
     let json = contractParser.toJson(contract, params);
     let pdfDefinition = pdfConverter.toPdfDefinition(json, format, testReportName);
-
     switch (printType) {
     case PRINT_TYPE.STREAM:
         pdfConverter.writeToStream(pdfDefinition, _stream);
         break;
 
     case PRINT_TYPE.BLOB:
-        return pdfConverter.toBlob(pdfDefinition);
-        
+        return new Promise((resolve, reject) => {
+            pdfConverter.toBlob(pdfDefinition).then((blobData)=>{
+                if(config && config.metaData === true){
+                    resolve({
+                        data: blobData,
+                        pdfJson: json
+                    });
+                } else {
+                    resolve(blobData);
+                }
+            }, (err)=>{
+                reject(err);
+            });
+        });
     case PRINT_TYPE.DATA_URL:
         return pdfConverter.toDataUrl(pdfDefinition);        
 
@@ -73,25 +84,25 @@ function __innerPrintLogic(printType, contract, params, _stream, format) {
     }
 }
 
-function printToStream(contract, params, _stream, format = "A4") {
+function printToStream(contract, params, _stream, format = "A4", config = {}) {
     // Validate parameters
     if(!(_stream instanceof stream.Stream)) {
         throw new TypeError("Not a valid stream.");
     }
     __validateCommonParameters(contract, params, format);
-    __innerPrintLogic(PRINT_TYPE.STREAM, contract, params, _stream, format);
+    __innerPrintLogic(PRINT_TYPE.STREAM, contract, params, _stream, format, config);
 }
 
-function printToDataUrl(contract, params, format = "A4") {
+function printToDataUrl(contract, params, format = "A4", config = {}) {
     // Validate parameters
     __validateCommonParameters(contract, params, format);
-    return __innerPrintLogic(PRINT_TYPE.DATA_URL, contract, params, null, format);
+    return __innerPrintLogic(PRINT_TYPE.DATA_URL, contract, params, null, format, config);
 }
 
-function printToBlob(contract, params, format = "A4") {
+function printToBlob(contract, params, format = "A4", config = {}) {
     // Validate parameters
     __validateCommonParameters(contract, params, format);
-    return __innerPrintLogic(PRINT_TYPE.BLOB, contract, params, null, format);
+    return __innerPrintLogic(PRINT_TYPE.BLOB, contract, params, null, format, config);
 }
 
 

package/dist/dev/src/pdfConverterClass.js

@@ -10,6 +10,7 @@ const TableCellIdentifier = require('./tableCellIdentifier');
 
 // required for webpack include (browser impl), used in conjunction with BrowserFonts definition
 const BrowserFontsVfs = require('pdfmake/build/vfs_fonts.js');
+const classLog = require("./logClass");
 
 // => use 'Roboto' font (pdfMake default) due to licensing (Apache 2.0)
 // https://fonts.google.com/specimen/Roboto || https://en.wikipedia.org/wiki/Roboto
@@ -82,6 +83,9 @@ const TableLayouts = {
     }
 };
 
+const ThermalPrintLayoutPageMargins = [5,5,5,5];
+let __log = new classLog();
+
 const STYLE_HEADING1 = "heading1";
 const STYLE_HEADING2 = "heading2";
 const STYLE_PARAGRAPH = "paragraph";
@@ -102,6 +106,11 @@ class PdfConverter {
         }
 
         this.__format = new Format();
+        this.__pdfHeight = null;
+    }
+
+    __isThermalPrintLayout() {
+        return this.__pdfHeight === 'auto';
     }
 
     __applyPageBreakData(pdfDefinition) {
@@ -212,7 +221,11 @@ class PdfConverter {
     }
 
     __getParagraphDefinition(paragraphNode, paragraphStyle) {
-        return this.__createHeadingOrParagraphText(paragraphNode, paragraphNode.elements[0].text, paragraphStyle);
+        let text =  '';
+        if (paragraphNode.elements) {
+            text = paragraphNode.elements[0].text;
+        }
+        return this.__createHeadingOrParagraphText(paragraphNode, text, paragraphStyle);
     }
 
     __getImageDefinition(imageNode, useAlignment) {
@@ -359,6 +372,10 @@ class PdfConverter {
             let i = 0;
 
             if (bAllowedStrings && _.isString(attribute)){
+                //the width can be given as a percentage only if the layout is 3-inch endless printer i.e, the height is auto
+                if(this.__pdfHeight === 'auto' && (/^\d+(\.\d+)?%$/).test(attribute)){
+                    return attribute;
+                }
                 for (i=0; i<allowedStrings.length; i++) {
                     if (attribute === allowedStrings[i]) {
                         return attribute;
@@ -488,9 +505,9 @@ class PdfConverter {
         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);
+    __createTableColumn(content, style, attributesJson) {
+        let bTextOnly = _.isNil(content.image) && _.isNil(style) && _.isNil(attributesJson.colSpan) && _.isNil(attributesJson.rowSpan)
+            && _.isNil(attributesJson.alignment) && _.isNil(attributesJson.bold) && _.isNil(attributesJson.italics) && _.isNil(attributesJson.cellId);
 
         if (bTextOnly) {
             return content.text;
@@ -508,23 +525,23 @@ class PdfConverter {
         if (!_.isNil(style)) {
             column.style = style;
         }
-        if (!_.isNil(colSpan)) {
-            column.colSpan = colSpan;
+        if (!_.isNil(attributesJson.colSpan)) {
+            column.colSpan = attributesJson.colSpan;
         }
-        if (!_.isNil(rowSpan)) {
-            column.rowSpan = rowSpan;
+        if (!_.isNil(attributesJson.rowSpan)) {
+            column.rowSpan = attributesJson.rowSpan;
         }
-        if (!_.isNil(alignment)) {
-            column.alignment = alignment;
+        if (!_.isNil(attributesJson.alignment)) {
+            column.alignment = attributesJson.alignment;
         }
-        if (!_.isNil(bold)) {
-            column.bold = bold;
+        if (!_.isNil(attributesJson.bold)) {
+            column.bold = attributesJson.bold;
         }
-        if (!_.isNil(italics)) {
-            column.italics = italics;
+        if (!_.isNil(attributesJson.italics)) {
+            column.italics = attributesJson.italics;
         }
-        if (!_.isNil(cellId)) {
-            column.id = cellId;
+        if (!_.isNil(attributesJson.cellId)) {
+            column.id = attributesJson.cellId;
         }
 
         return column;
@@ -538,7 +555,14 @@ class PdfConverter {
         let alignmentAttribute = this.__checkEnumAttribute(thOrTdNode, 'alignment', ["left", "center", "right"], null);
         let cellId = this.__checkStringAttribute(thOrTdNode, 'id', null);
 
-        return  [colSpanAttributeValue, rowSpanAttributeValue, alignmentAttribute, boldAttribute, italicsAttribute, cellId];
+        return {
+            colSpan: colSpanAttributeValue,
+            rowSpan: rowSpanAttributeValue,
+            alignment: alignmentAttribute,
+            bold: boldAttribute,
+            italics: italicsAttribute,
+            cellId: cellId
+        };
     }
 
     __evaluateTableDefinitionRowBreak(tableNode, dynamicPageBreak) {
@@ -596,24 +620,10 @@ class PdfConverter {
         let bNoWidths = false;
         let theadNode = _.find(tableNode.elements, {name: 'thead'});
         let tbodyNode = _.find(tableNode.elements, {name: 'tbody'});
+        let theadAlignmentValues =  [];
 
         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;
-            });
+            this.__getTheadNodeDefinition(theadNode, pdfTableDefinition, settings, theadAlignmentValues);
         } else if(!_.isNil(tbodyNode)) {
             bNoWidths = true;
         } else {
@@ -624,24 +634,7 @@ class PdfConverter {
         }
 
         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.__getTbodyNodeDefinition(tbodyNode, pdfTableDefinition, bNoWidths, settings, theadAlignmentValues);
         }
 
         this.__checkSpansAndColumns(pdfTableDefinition);
@@ -649,8 +642,89 @@ class PdfConverter {
         return pdfTableDefinition;
     }
 
+    __getTheadNodeDefinition(theadNode, pdfTableDefinition, settings, theadAlignmentValues) {
+        _.forEach(theadNode.elements, headerTrNode=> {
+            let row = [];
+            _.forEach(headerTrNode.elements, value => {
+                let attributesJson = 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', attributesJson));
+
+                //store the alignment values from th to be set to corresponding td for thermal print layout
+                if(this.__isThermalPrintLayout()) {
+                    theadAlignmentValues.push(attributesJson.alignment || 'left');
+                }
+            });
+
+            pdfTableDefinition.table.body.push(row);
+            pdfTableDefinition.table.headerRows += 1;
+        });
+    }
+
+    __getTbodyNodeDefinition(tbodyNode, pdfTableDefinition, bNoWidths, settings, theadAlignmentValues) {
+        _.forEach(tbodyNode.elements, tbodyTrNode=> {
+            let row = [];
+            _.forEach(tbodyTrNode.elements, (value, index) => {
+                //for thermal printer layout the alignment value for each td should be same as that column's th OR by default left
+                //if alignment for th is not defined
+                if (this.__isThermalPrintLayout()) {
+                    value.attributes = value.attributes || {}; // Ensure attributes exist for the tdNode
+                    value.attributes.alignment = theadAlignmentValues[index] || 'left'; // Set alignment to the corresponding th
+                }
+                let attributesJson = 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, attributesJson));
+            });
+
+            bNoWidths = false;
+            pdfTableDefinition.table.body.push(row);
+        });
+    }
+
+    __getLineFeedDefinition() {
+        return { "text": "\n" };
+    }
+
+    __getRuleDefinition(definition) {
+        //for thermal PL pageMargins will always be ThermalPrintLayoutPageMargins
+        const horizontalMarginSum = ThermalPrintLayoutPageMargins[0] + ThermalPrintLayoutPageMargins[2];
+        const x2 = definition.pageSize.width - horizontalMarginSum;
+        let result = {
+            canvas: [
+                {
+                    type: 'line',
+                    x1: 0, y1: 0,
+                    x2: x2, y2: 0,
+                    lineWidth: 1,
+                    dash: {
+                        length: 4,
+                        space: 2
+                    }
+                },
+            ]
+        };
+        return result;
+    }
+
     __addBody(definition, json) {
 
+        //requirement: for thermal PL the watermark should be added at the top and bottom of the preview
+        //add watermark at the top of the body
+        if(this.__isThermalPrintLayout()) {
+            this.__getWatermarkDefinitionForThermalPrintLayout(definition, json);
+        }
+
         _.forEach(json.elements, contractElement => {
             if(contractElement.name === 'table') {
                 let tableDefintion = this.__getTableDefinition(contractElement);
@@ -667,9 +741,50 @@ class PdfConverter {
             } else if (contractElement.name === 'img' || contractElement.name === 'signature') {
                 let imageDefintion = this.__getImageDefinition(contractElement, true);
                 definition.content.push(imageDefintion);
+            } else if (contractElement.name === 'lineFeed') {
+                if(this.__isThermalPrintLayout()) {
+                    let lineFeedDefintion = this.__getLineFeedDefinition();
+                    definition.content.push(lineFeedDefintion);
+                } else {
+                    //linefeed is only supported for thermal PL so log a warning and ignore
+                    __log.warn(contractElement.name + ' is supported only with thermal print layouts.');
+                }
+            } else if (contractElement.name === 'rule') {
+                if(this.__isThermalPrintLayout()) {
+                    let ruleDefintion = this.__getRuleDefinition(definition);
+                    definition.content.push(ruleDefintion);
+                } else {
+                    //rule is only supported for thermal PL so log a warning and ignore
+                    __log.warn(contractElement.name + ' is supported only with thermal print layouts.');
+                }
             }
         });
 
+        //add watermark at the bottom of the body
+        if(this.__isThermalPrintLayout()) {
+            this.__getWatermarkDefinitionForThermalPrintLayout(definition, json);
+        }
+
+    }
+
+    __getWatermarkDefinitionForThermalPrintLayout(definition, reportLayout) {
+        if(!_.isNil(reportLayout.attributes) && !_.isNil(reportLayout.attributes.watermark)) {
+            let watermarkDefinition = { "text": reportLayout.attributes.watermark };
+
+            //for thermal PL the watermark font size should be same as the H2 font size
+            let styleJson = this.__definition.styles[STYLE_HEADING2];
+
+            if (!_.isNil(styleJson.fontSize)) {
+                watermarkDefinition.fontSize = styleJson.fontSize;
+            }
+
+            //the watermark style should bold and center aligned
+            watermarkDefinition.bold = true;
+            watermarkDefinition.alignment = "center";
+            watermarkDefinition.margin = [0, 5, 0, 5];
+
+            definition.content.push(watermarkDefinition);
+        }
     }
 
     __addHeader(definition, json) {
@@ -739,16 +854,57 @@ class PdfConverter {
 
     __addPageDimensionsOrientationMarginsWatermark(definition, reportLayout){
         if(!_.isNil(reportLayout.attributes) && !_.isNil(reportLayout.attributes.pageSize)){
-            definition.pageSize = reportLayout.attributes.pageSize;
+            if (/^\s*\[\s*\d+\s*,\s*(\d+|auto)\s*\]\s*$/.test(reportLayout.attributes.pageSize)) {
+                // pageSize is given as [width, height]
+                const [width, height] = reportLayout.attributes.pageSize
+                    .replace(/\s/g, '') // remove whitespace
+                    .replace('[', '').replace(']', '') //remove brackets
+                    .split(',');
+                definition.pageSize = {
+                    width : Number(width),
+                    height: height === 'auto' ? height : Number(height)
+                };
+                this.__pdfHeight = height;
+            } else {
+                // assuming no other possibility for invalid pageSize format as it will be caught by during build
+                definition.pageSize = reportLayout.attributes.pageSize;
+            }
         }
         if(!_.isNil(reportLayout.attributes) && !_.isNil(reportLayout.attributes.watermark)){
-            definition.watermark =  {text: reportLayout.attributes.watermark, opacity:0.1, fontSize: 120};
+            //for thermal PL the watermark shouldn't be shown in the background so added a check
+            if(!this.__isThermalPrintLayout()) {
+                definition.watermark =  {text: reportLayout.attributes.watermark, opacity:0.1, fontSize: 120};
+            }
         }
-        if(!_.isNil(reportLayout.attributes) && !_.isNil(reportLayout.attributes.pageMargins)){
+        //for bluetooth thermal PL the pageMargins is not supported from the contracts and should be provided implicitly
+        if(this.__isThermalPrintLayout()) {
+            definition.pageMargins = ThermalPrintLayoutPageMargins;
+        } else if(!_.isNil(reportLayout.attributes) && !_.isNil(reportLayout.attributes.pageMargins)){
             definition.pageMargins = JSON.parse(reportLayout.attributes.pageMargins);
         }
     }
 
+    __addStyles(definition, json) {
+        let stylesNode = _.find(json.elements, {name:"styles"});
+        if(_.isNil(stylesNode)) return;
+        for (const styleElement of stylesNode.elements) {
+            for (let [property, value] of Object.entries(styleElement.attributes)) {
+                // invalid formats will be caught during build
+                if (property === 'fontSize') {
+                    value = Number(value);
+                } else if (property === 'bold' || property === 'italics') {
+                    value = value === 'true' || value === '1';
+                } else if (property === 'margin') {
+                    value = JSON.parse(value);
+                }
+
+                if (property !== 'name') {
+                    definition.styles[styleElement.attributes.name][property] = value;
+                }
+            }
+        }
+    }
+
     __isLastMainRowOnPage(followingNodesOnPage) {
         let result = false;
 
@@ -948,6 +1104,7 @@ class PdfConverter {
         let reportLayout = json.reportLayout;
         this.__configureAutomaticPageBreak(reportLayout);
         this.__addPageDimensionsOrientationMarginsWatermark(this.__definition, reportLayout);
+        this.__addStyles(this.__definition, reportLayout);
         this.__addHeader(this.__definition, reportLayout);
         this.__addBody(this.__definition, reportLayout);
         this.__addFooter(this.__definition,reportLayout);