@ind-rcg/plugins-printengine 246.1010.0

package/dist/dev/src/printEngineParams.js

@@ -0,0 +1,124 @@
+/*
+ * FILE_HEADER
+ */
+"use strict";
+const _ = require('lodash');
+const ClassLocalization = require('./localizationClass');
+const ClassToggles = require('./togglesClass');
+const STORAGE_KEYS = {
+    "BOS": "BOS",
+    "LOCALIZATION": "LOCALIZATION",
+    "IMAGES": "IMAGES",
+    "TOGGLES":"TOGGLES",
+    "METADATA": "METADATA"
+};
+Object.freeze(STORAGE_KEYS);
+
+const METADATA_KEYS = {
+    "LOCALE": "locale",
+    "WATERMARK": "watermark",
+    "AUTOMATIC_PAGEBREAK": "automaticPageBreak"
+};
+Object.freeze(METADATA_KEYS);
+const DATATYPE_ERROR_MSG = "Wrong datatype.";
+
+class PrintEngineParams {
+
+    constructor(bos = {}, images = {}, localization = {}, toggles = new ClassToggles({}), metadata = {}) {
+        //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.__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;
+    }
+
+    __checkInputSetBOs(boDictionary){
+        if(!_.isObject(boDictionary) || _.isArray(boDictionary)) {
+            throw new Error(DATATYPE_ERROR_MSG);
+        }
+    }
+    setBOs(boDictionary) {
+        this.__checkInputSetBOs(boDictionary);
+        this.__internalStorage[STORAGE_KEYS.BOS] = boDictionary;
+    }
+
+    getMetadataKeys(){
+        return METADATA_KEYS;
+    }
+
+    getBOs(){
+        return this.__internalStorage[STORAGE_KEYS.BOS];
+    }
+    __checkInputSetMetadata(metadataDictionary){
+        if(!_.isObject(metadataDictionary) || _.isArray(metadataDictionary)) {
+            throw new Error(DATATYPE_ERROR_MSG);
+        }
+    }
+    getMetadata(){
+        return this.__internalStorage[STORAGE_KEYS.METADATA];
+    }
+
+    setMetadata(metadataDictionary) {
+        this.__checkInputSetMetadata(metadataDictionary);
+        this.__internalStorage[STORAGE_KEYS.METADATA] = metadataDictionary;
+    }
+
+    __checkInputSetImages(imageDictionary){
+        if(!_.isObject(imageDictionary) || _.isArray(imageDictionary)) {
+            throw new Error(DATATYPE_ERROR_MSG);
+        }
+    }
+    setImages(imageDictionary){
+        this.__checkInputSetImages(imageDictionary);
+        this.__internalStorage[STORAGE_KEYS.IMAGES] = imageDictionary;
+    }
+
+    getImages(){
+        return this.__internalStorage[STORAGE_KEYS.IMAGES];
+    }
+
+    __checkInputSetLocalization(localizationDictionary){
+        if(!_.isObject(localizationDictionary) || _.isArray(localizationDictionary) ||
+            localizationDictionary instanceof ClassLocalization) {
+            throw new Error(DATATYPE_ERROR_MSG);
+        }
+    }
+    setLocalization(localizationDictionary){
+        this.__checkInputSetLocalization(localizationDictionary);
+        this.__internalStorage[STORAGE_KEYS.LOCALIZATION] = localizationDictionary;
+    }
+
+    getLocalization(){
+        return this.__internalStorage[STORAGE_KEYS.LOCALIZATION];
+    }
+
+    __checkInputSetToggles(togglesDictionary){
+        if(! (togglesDictionary instanceof ClassToggles)) {
+            throw new Error(DATATYPE_ERROR_MSG);
+        }
+    }
+    setToggles(togglesDictionary){
+        this.__checkInputSetToggles(togglesDictionary);
+        this.__internalStorage[STORAGE_KEYS.TOGGLES] = togglesDictionary;
+    }
+
+    getToggles(){
+        return this.__internalStorage[STORAGE_KEYS.TOGGLES];
+    }
+
+    serialize(){
+        let storageClone = _.cloneDeep(this.__internalStorage);
+        delete storageClone[STORAGE_KEYS.LOCALIZATION];
+        storageClone[STORAGE_KEYS.TOGGLES] = storageClone[STORAGE_KEYS.TOGGLES].getToggleBuffer();
+        return JSON.stringify(storageClone);
+    }
+}
+
+module.exports = PrintEngineParams;

package/dist/dev/src/tableCellIdentifier.js

@@ -0,0 +1,116 @@
+/*
+ * FILE_HEADER
+ */
+
+'use strict';
+const _ = require('lodash');
+
+const CELL_TYPE = {
+    "STANDARD": "tcid",
+    "UNKNOWN" : ""
+};
+Object.freeze(CELL_TYPE);
+
+class TableCellIdentifier {
+    constructor(type, eachName, listItemIndex, correlatedListItemIndex, columnIndex) {
+
+        if (!_.isNil(type) && _.isString(type) && !_.isNil(eachName) && _.isString(eachName) && 
+            !_.isNil(listItemIndex) && (_.isString(listItemIndex) || _.isInteger(listItemIndex)) && 
+            !_.isNil(correlatedListItemIndex) && (_.isString(correlatedListItemIndex) || _.isInteger(correlatedListItemIndex)) && 
+            !_.isNil(columnIndex) && (_.isString(columnIndex) || _.isInteger(columnIndex))) {
+            
+            if (type === CELL_TYPE.STANDARD &&_.toInteger(listItemIndex) === -1) {
+                this.__type = CELL_TYPE.UNKNOWN;        
+            } else {
+                this.__type = type;
+            }
+            this.__eachName = _.toString(eachName);           
+            this.__listItemIndex = _.toInteger(listItemIndex);
+            this.__correlatedListItemIndex = _.toInteger(correlatedListItemIndex);
+            this.__columnIndex = _.toInteger(columnIndex);
+
+        } else {
+            throw new Error('Error creating TableCellIdentifier.');
+        }        
+
+    }    
+
+    static create(eachName, listItemIndex, correlatedListItemIndex, columnIndex) {
+        return new TableCellIdentifier(CELL_TYPE.STANDARD, eachName, listItemIndex, correlatedListItemIndex, columnIndex);
+    }
+
+    static getUnknownIdentifier() {
+        return new TableCellIdentifier(CELL_TYPE.UNKNOWN ,'', -1, -1, -1);
+    }
+
+    static fromString(idString) {
+
+        // sample Id:   'tcid.each1.0.0.0'
+        //              '{PREFIX}.{eachName}.{listItemIndex}.{correlatedListItemIndex}.{columnIndex}'
+        if (!_.isNil(idString) && _.isString(idString) && _.startsWith(idString, CELL_TYPE.STANDARD)) { // || _.startsWith(Id, CELL_TYPE.SUBTOTAL))) {
+
+            let idSegments = _.split(idString, '.');
+            if (!_.isNil(idSegments) && _.isArray(idSegments) && idSegments.length === 5) {
+                return new TableCellIdentifier(...idSegments);
+            } else {
+                throw new Error('Invalid TableCellIdentifier detected.');
+            }
+
+        } else {
+            // return static tcid...
+            return TableCellIdentifier.getUnknownIdentifier();
+        }
+    }
+
+    isKnown() {
+        return !(this.__type === CELL_TYPE.UNKNOWN);
+    }
+
+    toString() {
+        if (!this.isKnown()) {
+            return null;
+        }
+        else {
+            return _.join([this.__type, this.__eachName, this.__listItemIndex, this.__correlatedListItemIndex, this.__columnIndex], '.');
+        }
+    }
+
+    isFirstMainRowCell() {
+        return (this.isKnown() && this.__type === CELL_TYPE.STANDARD && this.__listItemIndex >= 0 && this.__correlatedListItemIndex === -1 && this.__columnIndex === 0);
+    }
+
+    isSubsequentMainRowCell() {
+        return (this.isKnown() && this.__type === CELL_TYPE.STANDARD && this.__listItemIndex >= 0 && this.__correlatedListItemIndex === -1 && this.__columnIndex > 0);       
+    }
+
+    isFirstCorrelatedRowCell() {
+        return (this.isKnown() && this.__type === CELL_TYPE.STANDARD && this.__listItemIndex >= 0 && this.__correlatedListItemIndex >= 0 && this.__columnIndex === 0);
+    }
+
+    isSubsequentCorrelatedRowCell() {
+        return (this.isKnown() && this.__type === CELL_TYPE.STANDARD && this.__listItemIndex >= 0 && this.__correlatedListItemIndex >= 0 && this.__columnIndex > 0);
+    }
+
+    sharesMainRow(compareTcid) {
+        return (this.__checkTableCellIdentifier(compareTcid) && this.isKnown() && this.__type === compareTcid.__type && this.__listItemIndex === compareTcid.__listItemIndex);
+    }
+
+    sharesCorrelatedRow(compareTcid) {
+        return (this.__checkTableCellIdentifier(compareTcid) && this.isKnown() && this.sharesMainRow(compareTcid) && this.__correlatedListItemIndex === compareTcid.__correlatedListItemIndex);
+    }
+
+    isPreviousCell(compareTcid) {
+        return (this.__checkTableCellIdentifier(compareTcid) && this.sharesCorrelatedRow(compareTcid) && this.__columnIndex === compareTcid.__columnIndex + 1);
+    }
+
+    belongsToMainRow() {
+        return (this.isFirstMainRowCell() || this.isSubsequentMainRowCell());
+    }
+
+    __checkTableCellIdentifier(tcid) {
+        return (!_.isNil(tcid) && _.isObject(tcid) && _.isFunction(tcid.isKnown) && tcid.isKnown());
+    }
+
+}
+
+module.exports = TableCellIdentifier;

package/dist/dev/src/togglesClass.js

@@ -0,0 +1,61 @@
+/*
+ * FILE_HEADER
+ */
+'use strict';
+
+const _ = require('lodash');
+
+class Toggles {
+    constructor(toggles) {
+        if (typeof toggles !== 'object') {
+            throw new TypeError("Not a valid toggles object");
+        }
+        this.__toggles = toggles;
+    }
+
+    checkToggleParams(toggleId, toggleValue, toggleField) {
+        if (_.isNil(toggleId) || !_.isString(toggleId)) {
+            throw new TypeError("Invalid toggle Id parameter");
+        }
+        if (_.isNil(toggleValue) || !_.isString(toggleValue)) {
+            throw new TypeError("Invalid toggle value parameter");
+        }
+        if (_.isNil(toggleField) || !_.isString(toggleField)) {
+            throw new TypeError("Invalid toggle field parameter");
+        }
+    }
+
+    getToggleText(toggleId, toggleValue, toggleField = "shortText") {
+        this.checkToggleParams(toggleId, toggleValue, toggleField);
+
+        if (toggleId.substr(0,3) !== "Dom") {
+            toggleId = "Dom" + toggleId;
+        }
+
+        let toggle = this.__toggles[toggleId];
+
+        if (_.isNil(toggle)) {
+            throw new TypeError("Invalid toggle " + toggleId);
+        }
+
+        let value = toggle.values[toggleValue];
+
+        if (_.isNil(value)) {
+            throw new TypeError("Invalid toggle value " + toggleValue);
+        }
+
+        let text = value[toggleField];
+
+        if (_.isNil(text)) {
+            throw new TypeError("Invalid toggle field property " + toggleField);
+        }
+
+        return text;
+    }
+
+    getToggleBuffer(){
+        return _.cloneDeep(this.__toggles);
+    }
+}
+
+module.exports = Toggles;