@ind-rcg/plugins-printengine 252.1008.0 → 258.1001.0

package/dist/dev/src/macroHandlerClass.js

@@ -111,6 +111,7 @@ class MacroHandler {
             for (let i = 0; i < macroList.length; i++) {
                 this.__parseKeyValuePair(macroList[i], result);
             }
+            // eslint-disable-next-line no-unused-vars
         } catch (err){
             // some invalid value encountered during parse
             result = {};

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";
@@ -105,6 +109,10 @@ class PdfConverter {
         this.__pdfHeight = null;
     }
 
+    __isThermalPrintLayout() {
+        return this.__pdfHeight === 'auto';
+    }
+
     __applyPageBreakData(pdfDefinition) {
         if (!_.isUndefined(pdfDefinition.dynamicPageBreak) && pdfDefinition.dynamicPageBreak && 
             !_.isUndefined(pdfDefinition.dynamicPageBreakData) && _.isArray(pdfDefinition.dynamicPageBreakData) && pdfDefinition.dynamicPageBreakData.length > 0) {
@@ -497,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;
@@ -517,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;
@@ -547,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) {
@@ -605,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 {
@@ -633,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);
@@ -658,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);
@@ -676,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) {
@@ -765,9 +871,15 @@ class PdfConverter {
             }
         }
         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);
         }
     }
@@ -1095,7 +1207,7 @@ class PdfConverter {
                 } else {
                     let pdfDocGenerator = null;
                     if (pdfDefinition.defaultStyle.font !== "PrintFont") {
-                        pdfDocGenerator = this.__pdfMake.createPdf(pdfDefinition, TableLayouts, BrowserFonts, BrowserFontsVfs.pdfMake.vfs);
+                        pdfDocGenerator = this.__pdfMake.createPdf(pdfDefinition, TableLayouts, BrowserFonts, BrowserFontsVfs.vfs);
                     }
                     else {
                         pdfDocGenerator = this.__pdfMake.createPdf(pdfDefinition, TableLayouts, BrowserFonts, pdfDefinition.printFont);