@ind-rcg/plugins-printengine 246.1010.0

package/dist/dev/src/formatClass.js

@@ -0,0 +1,156 @@
+/*
+ * FILE_HEADER
+ */
+'use strict';
+
+const _ = require('lodash');
+const dayjs = require('dayjs');
+
+class Format {
+
+    constructor() {
+        this.INVALID_VALUE = "###";
+
+    }
+
+    formatDate(value, format){
+        if(!_.isString(value)) {
+            return this.INVALID_VALUE;
+        }
+        if(!_.isString(format)){
+            return  this.INVALID_VALUE;
+        }
+        // restrict the library a bit more because it also parses fragments of a date
+        const allowedDateRegex = /^\d{4}-\d{2}-\d{2}([ T]\d{2}:\d{2}:\d{2}(\.\d{3}Z)?)?$/;
+        if(! allowedDateRegex.test(value)) {
+            return  this.INVALID_VALUE;
+        }
+
+        // restrict also format strings more as otherwise the library creates suprising results
+        const allowedFormatRegex = /^[:\-/.YMDdHhmsSZTAa ]+$/;
+        if(! allowedFormatRegex.test(format)) {
+            return  this.INVALID_VALUE;
+        }
+        const parsedDate = dayjs(value);
+        if(parsedDate.isValid()){
+            const formatedValue = parsedDate.format(format);
+            return formatedValue;
+
+        } else {
+            return  this.INVALID_VALUE;
+        }
+    }
+
+    /**
+     * Formats a string of raw decimal to the locale format with 1000 seperator
+     * This function is a direct copy from mobility framework and therefore the max lines rule was disabled.
+     * @param value             : needs to be a number or a string representing a number and needs to match the regex description below
+     * @param format            : needs to be a string and  needs to match the regex description below
+     * @param decimalSeparator  : optional should be overwritten by localization
+     * @param thousandSeparator : optional should be overwritten by localization
+     * @private
+     */
+    // eslint-disable-next-line max-lines-per-function
+    formatDecimalV2(value, format, decimalSeparator = ".", thousandSeparator = ",") {
+        let result;
+        let invalidValue = this.INVALID_VALUE;
+
+        if (!_.isNil(value)) {
+            if (_.isNil(format) || !_.isString(format) || (!_.isString(value) && isNaN(value))) {
+                return invalidValue;
+            }
+
+            if (_.isString(value)) {
+                let numericStringPatternRegex = /^-?\d+\.?\d*$|^\d*\.?\d+$/;
+                let numericStringPatternMatches = value.match(numericStringPatternRegex);
+
+                if (numericStringPatternMatches === null) {
+                    return invalidValue;
+                }
+            }
+
+            let decimalStringPatternRegex = /\d+\.\d+/;
+            let decimalStringPatternMatches = format.match(decimalStringPatternRegex);
+
+            if (decimalStringPatternMatches === null) {
+                return invalidValue;
+            }
+
+            let stringNumber = value.toString();
+            let integerPart;
+            let decimalPart;
+
+            //Get integer and decimal part from input
+            if (stringNumber.indexOf(".") >= 0) {
+                integerPart = stringNumber.substring(0, stringNumber.indexOf("."));
+                decimalPart = stringNumber.substr(stringNumber.indexOf(".") + 1);
+            } else {
+                integerPart = stringNumber;
+                decimalPart = "0";
+            }
+
+            //Get integer and decimal part length from format
+            let integerLengthInFormat = parseInt(format.substr(0, format.indexOf(".")), 10);
+            let decimalLengthInFormat = parseInt(format.substr(format.indexOf(".") + 1), 10);
+
+            //Remove leading zero for integer part
+            integerPart = integerPart.replace(/^(-)?0+(?=\d)/,'$1');
+            let inputIntegerPartLength = integerPart.length;
+            if(integerPart.startsWith("-")){
+                //If its negative, then exlcude it in format length checking
+                inputIntegerPartLength = Math.max(0, inputIntegerPartLength - 1);
+            }
+            if (inputIntegerPartLength > integerLengthInFormat) {
+                result = invalidValue;
+            } else {
+                if (decimalPart.length > decimalLengthInFormat) {
+                    //If decimal part length is greater than decimal length in format, round the value.
+                    let roundedValue = parseFloat(integerPart + "." + decimalPart).toFixed(decimalLengthInFormat).split(".");
+                    /**If after rounding the value, integer part length exceeds integerLengthInFormat
+                    ** example 99.999 with format 2.2 , after rounding it becomes 100.00 which violates 2.2 format
+                    ** Display 99.99 in this case*/
+                    if(roundedValue[0].length > integerLengthInFormat)
+                    {
+                        decimalPart = decimalPart.substr(0,decimalLengthInFormat);
+                    }
+                    else
+                    {
+                        integerPart = roundedValue[0];
+                        decimalPart = roundedValue[1];
+                    }
+                } else {
+                    decimalPart = decimalPart.padEnd(decimalLengthInFormat, "0");
+                }
+
+                let returnString = "";
+                let ts = thousandSeparator;
+                let endIndex = integerPart.length;
+                let startIndex = endIndex - 3;
+                while (startIndex >= 0) {
+                    returnString = integerPart.substring(startIndex, endIndex) + ts + returnString;
+                    endIndex -= 3;
+                    startIndex -= 3;
+                }
+                if (endIndex > 0) {
+                    returnString = integerPart.substring(0, endIndex) + ts + returnString;
+                    if (returnString.indexOf("-" + ts) === 0) {
+                        returnString = "-" + returnString.substr(2);
+                    }
+                }
+                if (decimalLengthInFormat > 0) {
+                    // Replace decimal separator
+                    result = returnString.substring(0, returnString.length - 1) + decimalSeparator + decimalPart;
+                } else {
+                    result = returnString.substring(0, returnString.length - 1);
+                }
+            }
+        }
+        else
+        {
+            result = invalidValue;
+        }
+        return result;
+    }
+}
+
+module.exports = Format;

package/dist/dev/src/index.js

@@ -0,0 +1,110 @@
+/*
+ * FILE_HEADER
+ */
+
+'use strict';
+const classPrintEngineParams = require("../src/printEngineParams");
+const classLocalization = require('./localizationClass');
+const classToggles = require('./togglesClass');
+const classMacroHandler = require('./macroHandlerClass');
+const PdfConverter = require('./pdfConverterClass');
+const ContractToIntermediateJSON = require('./contractToIntermediateJSONClass');
+const classLog = require('./logClass');
+let __log = new classLog();
+const contractParser= new ContractToIntermediateJSON(__log );
+
+const stream = require('stream');
+const _ = require('lodash');
+
+let pdfConverter = new PdfConverter();
+
+// This will always stay undefined, and will only be activated via Rewire for tests
+let testReportName;
+
+const PRINT_TYPE = {
+    "STREAM": "STREAM",
+    "DATA_URL": "DATA_URL",
+    "BLOB": "BLOB"
+};
+Object.freeze(PRINT_TYPE);
+
+function __validateCommonParameters(contract, params, format){
+    if (typeof contract !== 'string') {
+        throw new TypeError("Not a valid contract object");
+    }
+
+    if (!(params instanceof classPrintEngineParams)){
+        throw new TypeError("Not a valid PrintEngineParams object");
+    }
+
+    if ((typeof params.getBOs() !== 'object') || (_.isEmpty(params.getBOs()))) {
+        throw new TypeError("Not a valid business object dictionary");
+    }
+
+    let localization = params.getLocalization();
+
+    if ((typeof localization !== 'object') || (Object.keys(localization).length === 0)) {
+        throw new TypeError("Not a valid localization object");
+    }
+
+    if(!PdfConverter.isValidFormat(format)) {
+        throw new TypeError("Not a valid print format");
+    }
+}
+
+function __innerPrintLogic(printType, contract, params, _stream, format) {
+    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);
+        
+    case PRINT_TYPE.DATA_URL:
+        return pdfConverter.toDataUrl(pdfDefinition);        
+
+    default:
+        __log.error('PRINT_TYPE ' + printType + ' not supported in innerPrintLogic');
+        break;
+    }
+}
+
+function printToStream(contract, params, _stream, format = "A4") {
+    // 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);
+}
+
+function printToDataUrl(contract, params, format = "A4") {
+    // Validate parameters
+    __validateCommonParameters(contract, params, format);
+    return __innerPrintLogic(PRINT_TYPE.DATA_URL, contract, params, null, format);
+}
+
+function printToBlob(contract, params, format = "A4") {
+    // Validate parameters
+    __validateCommonParameters(contract, params, format);
+    return __innerPrintLogic(PRINT_TYPE.BLOB, contract, params, null, format);
+}
+
+
+module.exports = {
+    "printToStream": printToStream,
+    "printToDataUrl": printToDataUrl,
+    "printToBlob": printToBlob,
+    "PdfConverter": PdfConverter,
+    "ContractToIntermediateJSON": ContractToIntermediateJSON,
+    "Localization": classLocalization,
+    "Toggles": classToggles,
+    "PrintEngineParams": classPrintEngineParams,
+    "MacroHandler": classMacroHandler,
+    "Log": classLog,
+    "onMessage": __log.onMessage
+};

package/dist/dev/src/localizationClass.js

@@ -0,0 +1,89 @@
+/*
+ * FILE_HEADER
+ */
+
+'use strict';
+const _ = require('lodash');
+
+class Localization {
+    constructor(localization, isSfBackend = true) {
+        if (typeof localization !== 'object') {
+            throw new TypeError("Not a valid localization object");
+        }
+        this.localization = localization;
+        this.intMinDateTimeAnsi = isSfBackend ? '1700-01-01 00:00:00' : '1800-01-01 00:00:00';
+        this.separatorDecimalDefault = ".";
+        this.separatorThousandDefault = ",";
+    }
+
+    resolve(key, defaultValue) {
+        let result = this.localization[key];
+        if (_.isNil(result) && key && key.length > 0) {
+            // try with a global label, used for Context Menu
+            let globalLabelName = key.substring(key.lastIndexOf(".") + 1);
+            result = this.localization[globalLabelName];
+        }
+        return !_.isNil(result) ? result : (!_.isNil(defaultValue) ? defaultValue : key);
+    }
+
+    get separatorDecimal() {
+        if (!_.isNil(this.localization) && !_.isNil(this.localization.FORMATS) && !_.isNil(this.localization.FORMATS.NumberFormats)) {
+            return this.localization.FORMATS.NumberFormats.DecimalSeparator.value;
+        } else {
+            return this.separatorDecimalDefault;
+        }
+    }
+
+    get separatorThousand() {
+        if (!_.isNil(this.localization) && !_.isNil(this.localization.FORMATS) && !_.isNil(this.localization.FORMATS.NumberFormats)) {
+            return this.localization.FORMATS.NumberFormats.ThousandSeparator.value;
+        } else {
+            return this.separatorThousandDefault;
+        }
+    }
+
+    get minDateTimeAnsi() {
+        return this.intMinDateTimeAnsi;
+    }
+
+    get dateFormat() {
+        const fallback = "MM/DD/YYYY";
+        if(_.isNil(this.localization.FORMATS) || _.isNil(this.localization.FORMATS.DateFormats)
+            || _.isNil(this.localization.FORMATS.DateFormats.Date)){
+            return fallback;
+        }
+        return this.localization.FORMATS.DateFormats.Date.value;
+    }
+
+    get shortDateFormat() {
+        const fallback = "dd MM/DD";
+        if(_.isNil(this.localization.FORMATS) || _.isNil(this.localization.FORMATS.DateFormats)
+            || _.isNil(this.localization.FORMATS.DateFormats.ShortDate)){
+            return fallback;
+        }
+        return this.localization.FORMATS.DateFormats.ShortDate.value;
+    }
+
+    get dateTimeFormat() {
+        const fallback = "MM/DD/YYYY h:mm a";
+        if(_.isNil(this.localization.FORMATS) || _.isNil(this.localization.FORMATS.DateFormats)
+            || _.isNil(this.localization.FORMATS.DateFormats.DateTime)){
+            return fallback;
+        }
+        return this.localization.FORMATS.DateFormats.DateTime.value;
+    }
+
+    get timeFormat() {
+        const fallback = "h:mm a";
+        if(_.isNil(this.localization.FORMATS) || _.isNil(this.localization.FORMATS.DateFormats)
+            || _.isNil(this.localization.FORMATS.DateFormats.Time)){
+            return fallback;
+        }
+
+        return this.localization.FORMATS.DateFormats.Time.value;
+    }
+
+}
+
+
+module.exports = Localization;

package/dist/dev/src/logClass.js

@@ -0,0 +1,38 @@
+/*
+ * FILE_HEADER
+ */
+"use strict";
+const __Logger = require('js-logger');
+const _ = require('lodash');
+
+class Log {
+    /**********************************************************************************************************
+     *  The purpose of this class is to wrap the external logger library. The goal is to make future migration
+     *  to a different logger library easy.
+     **********************************************************************************************************/
+    constructor() {
+        __Logger.useDefaults();
+    }
+
+
+    onMessage(handlerFunction){
+        if(!_.isFunction(handlerFunction)){
+            throw new Error("Not a valid function.");
+        }
+        const consoleHandler = __Logger.createDefaultHandler();
+        __Logger.setHandler(function __printEngineOnMessageHandler(messages, context){
+            consoleHandler(messages, context);
+            handlerFunction(messages, context);
+        } );
+    }
+
+    error(...args) {
+        __Logger.error.apply(this, args);
+    }
+
+    warn(...args){
+        __Logger.warn.apply(this, args);
+    }
+}
+
+module.exports = Log;

package/dist/dev/src/macroHandlerClass.js

@@ -0,0 +1,132 @@
+/*
+ * FILE_HEADER
+ */
+
+'use strict';
+const LogClass = require('./logClass');
+const _ = require('lodash');
+
+//MacroDefintion   = "{", "{", MacroList, "}", "}" ;
+//MacroList        = KeyValuePair, { ";" KeyValuePair } ;
+//KeyValuePair     = Value | Key "=" Value ;
+//Key              = "path" | "format" | "toggleId" | "toggleField" ;
+//Value            = Path | Number | SimpleFloat;
+//Path             = ".", Identifier | Scope, Identifier, { ".", Identifier} ;
+//Scope            = Identifier, ":", ":"
+//Identifier       = Letter, { Letter | Digit } ;
+//Number           = Digit, { Digit } ;
+//SimpleFloat      = Digit, { Digit } ( ".", Digit, { Digit } ).
+//Letter           = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" |
+//                   "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" ;
+//Digit            = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
+
+class MacroHandler {
+    constructor(log) {
+        if(!(log instanceof LogClass)) {
+            throw new Error("Invalid constructor parameters");
+        }
+        this.__log = log;
+    }
+
+    __parseValue(property, value, result) {
+        if (_.startsWith(value, ".")) {
+            result[property] = value.substr(1);
+        }
+        else {
+            let fullValueList = value.split("::");
+            if (fullValueList.length === 2) {
+                result.scope = fullValueList[0];
+                result[property] = fullValueList[1];
+            } else if (fullValueList.length === 1) {
+                result[property] = fullValueList[0];
+            } else {
+                let error = "Unexpected macro value: " + value;
+                this.__log.error(error);
+                throw new Error(error);
+            }
+        }
+    }
+
+    __isWhitespaceKeptForThisProperty(key){
+        return key === "defaultLabel" || key === "dateTimeFormat";
+    }
+
+    __parseKeyValuePair(keyValuePair, result) {
+        let keyValueList = keyValuePair.split("=");
+        let trimmedKey = _.trim(keyValueList[0]);
+
+        if(trimmedKey.length > 0) {
+            // ingore empty contents which is created by just placing ;
+            if (keyValueList.length === 1) {
+                // remove all whitespace
+                let strippedValue = keyValueList[0].replace(/\s/g,'');
+                this.__parseValue("path", strippedValue, result);
+            } else {
+                let strippedValue = keyValueList[1];
+                if(!this.__isWhitespaceKeptForThisProperty(trimmedKey)) {
+                    strippedValue = keyValueList[1].replace(/\s/g,'');
+                }
+                this.__parseValue(trimmedKey, strippedValue, result);
+            }
+        }
+    }
+
+    // This is the regular expression which is used to find macros in the printV2 contract.
+    getMacroRegex() {
+        return /{\s*{[\s:.;=A-Za-z\-_0-9]*}\s*}/g;
+    }
+
+
+    parseMacro( macroString ) {
+        // console.log(JSON.stringify(macroString));
+
+        if (_.isNil(macroString) || !_.isString(macroString)) {
+            throw new TypeError("Invalid macro string parameter");
+        }
+
+        let result = {};
+
+        let macroRegex = /^\s*{\s*{[\s:.;=A-Za-z\-_0-9]*}\s*}\s*$/g;
+        let macroMatches = macroString.match(macroRegex);
+
+        // console.log(macroString);
+        // console.log(JSON.stringify(macroMatches));
+
+        //Note that any invalid character between {{}} will be filtered out like "{{{}}}" will become "{{}}" which is shorter than the original.
+        if (_.isNil(macroMatches) || _.isNil(macroMatches[0]) ) {
+            return result;
+        }
+
+        macroString = macroMatches[0].replace(/[{}]/g,'');
+
+        if (macroString === "") {
+            return result;
+        }
+
+        // console.log(macroString);
+
+        let macroList = macroString.split(";");
+
+        try {
+            for (let i = 0; i < macroList.length; i++) {
+                this.__parseKeyValuePair(macroList[i], result);
+            }
+        } catch (err){
+            // some invalid value encountered during parse
+            result = {};
+        }
+
+        // avoid results where path contains ":" inside. Because this will generate a lot of complexity for calling components
+        // to handle this
+        if(!_.isNil(result.path)){
+            if(result.path.indexOf(":") > 0) {
+                result = {};
+            }
+        }
+        // console.log(JSON.stringify(result));
+
+        return result;
+    }
+}
+
+module.exports = MacroHandler;