@ind-rcg/plugins-printengine 250.1002.0 → 252.1008.0

package/dist/dev/src/contractToIntermediateJSONClass.js

@@ -167,7 +167,7 @@ class ContractToIntermediateJSON {
         let documentPropertiesRaw = _.find(printLayoutNode.elements, {name:DOCUMENT_PROPERTIES_NODE});
         let documentProperties = this.__reformatDocumentProperties(documentPropertiesRaw);    
 
-        return {"reportLayout": reportLayout, "documentProperties": documentProperties};
+        return {"reportLayout": reportLayout, "documentProperties": documentProperties, "printFont": params.getPrintFont() };
     }
 
     __processDivs(params) {

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

@@ -28,6 +28,12 @@ const BrowserFonts = {
         bold: 'Roboto-Medium.ttf',
         italics: 'Roboto-Italic.ttf',
         bolditalics: 'Roboto-MediumItalic.ttf'
+    },
+    PrintFont: {
+        normal: 'Regular',
+        bold: 'Bold',
+        italics: 'Italic',
+        bolditalics: 'BoldItalic'
     }
 };
 
@@ -96,6 +102,7 @@ class PdfConverter {
         }
 
         this.__format = new Format();
+        this.__pdfHeight = null;
     }
 
     __applyPageBreakData(pdfDefinition) {
@@ -206,7 +213,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) {
@@ -353,6 +364,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;
@@ -705,6 +720,17 @@ class PdfConverter {
         }
     }
 
+    __addPrintFont(definition, printFont) {
+        if (_.isObject(printFont)
+            && ("Regular" in printFont)
+            && ("Bold" in printFont)
+            && ("Italic" in printFont)
+            && ("BoldItalic" in printFont)) {
+            definition.defaultStyle.font = "PrintFont";
+            definition.printFont = printFont;
+        }
+    }
+
     __addDocumentMetadata(definition, documentProperties){
         definition.info = {};
         definition.info.creator = "Consumer Goods Cloud";
@@ -722,7 +748,21 @@ 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};
@@ -732,6 +772,27 @@ class PdfConverter {
         }
     }
 
+    __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;
 
@@ -926,10 +987,12 @@ class PdfConverter {
 
     toPdfDefinition(json/*, format*/) {
         this.__initializePdfDefinition();
+        this.__addPrintFont(this.__definition, json.printFont);
         this.__addDocumentMetadata(this.__definition, json.documentProperties);
         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);
@@ -1030,8 +1093,14 @@ class PdfConverter {
                 if (_.isNil(pdfDefinition) && !_.isNil(previousResult)) {
                     resolve(previousResult);
                 } else {
-                    let pdfDocGenerator = this.__pdfMake.createPdf(pdfDefinition, TableLayouts, BrowserFonts, BrowserFontsVfs.pdfMake.vfs);
-
+                    let pdfDocGenerator = null;
+                    if (pdfDefinition.defaultStyle.font !== "PrintFont") {
+                        pdfDocGenerator = this.__pdfMake.createPdf(pdfDefinition, TableLayouts, BrowserFonts, BrowserFontsVfs.pdfMake.vfs);
+                    }
+                    else {
+                        pdfDocGenerator = this.__pdfMake.createPdf(pdfDefinition, TableLayouts, BrowserFonts, pdfDefinition.printFont);
+                    }
+                    
                     switch (type) {
                     case EXPORT_TYPE.BASE_64:
                         pdfDocGenerator.getBase64((data) => {

package/dist/dev/src/printEngineParams.js

@@ -10,7 +10,8 @@ const STORAGE_KEYS = {
     "LOCALIZATION": "LOCALIZATION",
     "IMAGES": "IMAGES",
     "TOGGLES":"TOGGLES",
-    "METADATA": "METADATA"
+    "METADATA": "METADATA",
+    "PRINTFONT": "PRINTFONT"
 };
 Object.freeze(STORAGE_KEYS);
 
@@ -24,19 +25,21 @@ const DATATYPE_ERROR_MSG = "Wrong datatype.";
 
 class PrintEngineParams {
 
-    constructor(bos = {}, images = {}, localization = {}, toggles = new ClassToggles({}), metadata = {}) {
+    constructor(bos = {}, images = {}, localization = {}, toggles = new ClassToggles({}), metadata = {}, printfont = {}) {
         //Optional parameters for constructor via destructuring assignments including call without parameters.
         this.__checkInputSetBOs(bos);
         this.__checkInputSetImages(images);
         this.__checkInputSetLocalization(localization);
         this.__checkInputSetToggles(toggles);
         this.__checkInputSetMetadata(metadata);
+        this.__checkInputSetPrintFont(printfont);
         this.__internalStorage = {};
         this.__internalStorage[STORAGE_KEYS.BOS] = bos;
         this.__internalStorage[STORAGE_KEYS.IMAGES] = images;
         this.__internalStorage[STORAGE_KEYS.LOCALIZATION] = localization;
         this.__internalStorage[STORAGE_KEYS.TOGGLES] = toggles;
         this.__internalStorage[STORAGE_KEYS.METADATA] = metadata;
+        this.__internalStorage[STORAGE_KEYS.PRINTFONT] = printfont;
     }
 
     __checkInputSetBOs(boDictionary){
@@ -69,6 +72,19 @@ class PrintEngineParams {
         this.__checkInputSetMetadata(metadataDictionary);
         this.__internalStorage[STORAGE_KEYS.METADATA] = metadataDictionary;
     }
+    
+    getPrintFont(){
+        return this.__internalStorage[STORAGE_KEYS.PRINTFONT];
+    }
+    __checkInputSetPrintFont(printFont){
+        if(!_.isObject(printFont)) {
+            throw new Error(DATATYPE_ERROR_MSG);
+        }
+    }
+    setPrintFont(printFont) {
+        this.__checkInputSetPrintFont(printFont);
+        this.__internalStorage[STORAGE_KEYS.PRINTFONT] = printFont;
+    }
 
     __checkInputSetImages(imageDictionary){
         if(!_.isObject(imageDictionary) || _.isArray(imageDictionary)) {