@devassure/tpp-engine 0.0.0-stage → 1.8.0

package/src/library/file/file-action-utils.js

@@ -0,0 +1,129 @@
+const fs = require('fs');
+const fsExtra = require('fs-extra');
+const { Logger } = require('../../utils/logger');
+const path = require('path');
+const { FileUtils } = require('./file-utils');
+
+class FileActionUtils {
+
+    constructor(caller, blacklistedLogs) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    readContent(filePath, logLabel) {
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        filePath = new FileUtils().getFilePath(filePath);
+        if(!fs.existsSync(filePath)) {
+            logger.failureLog(logLabel);
+            throw {message: `File ${filePath} does not exists!`}
+        }
+        const content = fs.readFileSync(filePath, {encoding: 'utf-8'})?.replaceAll('\r', '');
+        return content;
+    }
+
+    readContentIgnoreMissing(filePath, fallBack) {
+        filePath = new FileUtils().getFilePath(filePath);
+        if(!fs.existsSync(filePath)) {
+            return fallBack || "";
+        }
+        const content = fs.readFileSync(filePath, {encoding: 'utf-8'})?.replaceAll('\r', '');
+        return content;
+    }
+
+    read_content_as_text(filePath) {
+        const logLabel = `File.Read content as text ${filePath}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const content = this.readContent(filePath, logLabel);
+        logger.endLog(logLabel);
+        return content;
+    }
+
+    read_content_as_json(filePath) {
+        const logLabel = `File.Read content as json ${filePath}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const content = this.readContent(filePath, logLabel);
+        let jsonData;
+        try {
+            jsonData = JSON.parse(content?.trim());
+          } catch (ex) {
+            throw { message: `Content is not a valid JSON - ${ex}`};
+          }
+        logger.endLog(logLabel);
+        return jsonData;
+    }
+
+    write_content_to_file(content, filePath) {
+        const logLabel = `File.Write content to ${filePath}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        new FileUtils().writeTextContent(filePath, content);
+        logger.endLog(logLabel);
+    }
+
+    is_present(filePath) {
+        const logLabel = `File.Is Present ${filePath}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        let exists = fs.existsSync(filePath);
+        logger.endLog(logLabel);
+        return exists;
+    }
+
+    delete_file(filePath) {
+        const logLabel = `File.Delete file`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        if(!fs.existsSync(filePath)) {
+            logger.failureLog(logLabel);
+            throw {message: `File ${filePath} does not exists!`}
+        }
+        fsExtra.removeSync(filePath);
+        logger.endLog(logLabel);
+    }
+
+    get_absolute_path(filePath) {
+        const logLabel = `File.Get absolute path of ${filePath}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        filePath = new FileUtils().getFilePath(filePath);
+        if(!fs.existsSync(filePath)) {
+            logger.failureLog(logLabel);
+            throw {message: `File ${filePath} does not exists!`}
+        }
+        const absPath = path.resolve(filePath);
+        logger.endLog(logLabel);
+        return absPath;
+    }
+
+    copy_file(filePath, targetDirectory) {
+        const logLabel = `File.Copy file ${filePath} to directory ${targetDirectory}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        filePath = new FileUtils().getFilePath(filePath);
+
+         if(!fs.existsSync(filePath)) {
+            logger.failureLog(logLabel);
+            throw {message: `File ${filePath} does not exists!`}
+        }
+
+        const fileName = path.basename(filePath);
+        const targetPath = path.join(targetDirectory, fileName);
+        new FileUtils().copyFile(filePath, targetPath);
+        logger.log(logLabel, `Copied to ${targetPath}`);
+        logger.endLog(logLabel);
+    }
+
+}
+
+exports.FileActionUtils = FileActionUtils;

package/src/library/file/file-utils.js

@@ -0,0 +1,127 @@
+const fs = require('fs');
+const path = require('path');
+const fsExtra = require('fs-extra');
+
+class FileUtils {
+
+    isExists(filePath) {
+        return fs.existsSync(filePath);
+    }
+
+    readTextContent(filePath) {
+        if(!fs.existsSync(filePath)) {
+            throw {
+                message: `file ${filePath} does not exists!`
+            }
+        }
+        const data = fs.readFileSync(filePath, {encoding: 'utf-8'});
+        return data;
+    }
+
+    writeTextContent(filePath, content) {
+        this.createParentIfNotPresent(filePath);
+        fs.writeFileSync(filePath, content);
+    }
+
+    copyFile(sourcePath, targetPath) {
+        this.createParentIfNotPresent(targetPath);
+        fs.copyFileSync(sourcePath, targetPath);
+    }
+
+    getFilePath(filePath) {
+        if(filePath.startsWith('/')) {
+            return filePath;
+        }
+        if(!fs.existsSync(filePath)) {
+            const internalPath = filePath.replaceAll('\\', '/');
+            const startSep = internalPath.startsWith('/') ? '' : '/';
+            return `resources${startSep}${internalPath}`;
+        }
+        return filePath;
+    }
+
+    createParentIfNotPresent(filePath) {
+        if(!filePath.includes('/') && !filePath.includes('\\')) {
+            return;
+        }
+        const lastSepI = filePath.includes('/')
+        ? filePath.lastIndexOf('/')
+        : filePath.lastIndexOf(path.sep);
+        const parentPath = filePath.slice(0, lastSepI+1);
+        if(!fs.existsSync(parentPath)) {
+            fs.mkdirSync(parentPath, {recursive: true});
+        }
+    }
+
+    createDirIfNotPresent(dirPath) {
+        if(!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, {recursive: true});
+        }
+    }
+    
+    // Utility function to wait until file exists and is not empty
+    async waitForFile(filePath, timeout = 10000) {
+        const start = Date.now();
+        while (true) {
+            if (fs.existsSync(filePath)) {
+                const stats = fs.statSync(filePath);
+                if (stats.size > 0) {
+                    return;
+                }
+            }
+            if (Date.now() - start > timeout) {
+                throw new Error(`Timeout: Video file at ${filePath} not finalized`);
+            }
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+    }
+
+    deleteFile(filePath) {
+        if(!fs.existsSync(filePath)) {
+            return;
+        }
+        fsExtra.removeSync(filePath);
+    }
+
+    async pngToBase64(filePath) {
+        const imageBuffer = fs.readFileSync(filePath);
+        return imageBuffer.toString('base64');
+    }
+
+    async readJSONContent(filePath, create = false) {
+        if(!fs.existsSync(filePath)) {
+            if (create) {
+                this.createParentIfNotPresent(filePath);
+                fs.writeFileSync(filePath, '{}');
+            }
+            return {};
+        }
+        const data = fs.readFileSync(filePath, {encoding: 'utf-8'});
+        try {
+            return JSON.parse(data);
+        } catch (error) {
+            throw {
+                message: `Error parsing JSON from file ${filePath}: ${error.message}`
+            };
+        }
+    }
+
+    async writeJSONContent(filePath, content) {
+        this.createParentIfNotPresent(filePath);
+        try {
+            const jsonContent = JSON.stringify(content, null, 2);
+            fs.writeFileSync(filePath, jsonContent);
+        } catch (error) {
+            throw {
+                message: `Error writing JSON to file ${filePath}: ${error.message}`
+            };
+        }
+    }
+
+    getFileSizeInMB(filePath) {
+        filePath = this.getFilePath(filePath);
+        return fs.statSync(filePath).size / 1024 / 1024;
+    }
+}
+
+exports.FileUtils = FileUtils;

package/src/library/json/json-utils.js

@@ -0,0 +1,104 @@
+const { Logger } = require("../../utils/logger");
+const _ = require('lodash');
+
+class JsonUtils {
+
+    constructor(caller, blacklistedLogs) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    compareJson(obj1, obj2) {
+        if (_.isEqual(obj1, obj2)) {
+            return {success: true};
+        } else {
+            const differences = [];
+
+            function findDifferences(path, val1, val2) {
+                if (_.isEqual(val1, val2)) return;
+
+                if (_.isObject(val1) && _.isObject(val2)) {
+                    const allKeys = _.union(_.keys(val1), _.keys(val2));
+                    allKeys.forEach(key => {
+                        if(!val1.hasOwnProperty(key)) {
+                            differences.push({  path: `${path}.${key}`, value1: "key not found", value2: val2[key]});
+                            return;
+                        }
+                        if(!val2.hasOwnProperty(key)) {
+                            differences.push({  path: `${path}.${key}`, value1: val1[key], value2: "key not found"});
+                            return;
+                        }
+                        findDifferences(`${path}.${key}`, val1[key], val2[key]);
+                    });
+                } else {
+                    differences.push({
+                        path: `${path}`,
+                        value1: val1,
+                        value2: val2
+                    });
+                }
+            }
+
+            findDifferences('root', obj1, obj2);
+
+            return {success: false, differences};
+        }
+    }
+
+    compare(json1, json2) {
+        const logLabel = `Json.Compare`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = this.compareJson(json1, json2);
+        if(!result.success) {
+            logger.log(logLabel, "JSON objects are not equal. Differences:");
+            result?.differences?.forEach(diff => {
+                logger.log(logLabel, `-> Path: ${diff.path}, Value1: ${JSON.stringify(diff.value1)}, Value2: ${JSON.stringify(diff.value2)}`);
+            });
+            logger.failureLog(logLabel);
+            throw {message: 'JSON objects are not equal'};
+        }
+        logger.endLog(logLabel);
+    }
+
+    is_equal(json1, json2) {
+        const logLabel = `Json.Is Equal`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = _.isEqual(json1, json2);
+        logger.log(logLabel, `JSON objects equality: ${result}`);
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    is_valid_json(text) {
+        const logLabel = `Json.Is Valid JSON`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        if(!_.isString(text) || !text.trim()) {
+            logger.log(logLabel, 'Input is empty - not a valid JSON string');
+            logger.endLog(logLabel);
+            return false;
+        }
+        try {
+            JSON.parse(text);
+            logger.endLog(logLabel);
+            return true;
+        } catch (ex) {
+            logger.log(logLabel, `Input is not a valid JSON string - ${ex}`);
+            logger.endLog(logLabel);
+            return false;
+        }
+    }
+
+}
+
+exports.JsonUtils = JsonUtils;

package/src/library/math/math-utils.js

@@ -0,0 +1,283 @@
+const { Logger } = require("../../utils/logger");
+const _ = require('lodash');
+
+class MathUtils {
+
+    constructor(caller, blacklistedLogs) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    round_number(number, digits) {
+        const logLabel = `Math.Round number ${number} to decimal places ${digits}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = _.round(number, digits);
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    random_number(min, max) {
+        const logLabel = `Math.Random number between ${min} and ${max}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result =  Math.floor(Math.random() * (max - min + 1)) + min;
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    truncate_number(number, digits) {
+        const logLabel = `Math.Truncate number ${number} to decimal places ${digits}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const factor = Math.pow(10, digits);
+        const result =  Math.trunc(number * factor) / factor;
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    absolute_value(number) {
+        const logLabel = `Math.Absolute value of ${number}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = Math.abs(number);
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    max(numbers) {
+        const logLabel = `Math.Max of ${numbers.join(', ')}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = _.max(numbers);
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    min(numbers) {
+        const logLabel = `Math.Min of ${numbers.join(', ')}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = _.min(numbers);
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    sum(numbers) {
+        const logLabel = `Math.Sum of ${numbers.join(', ')}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = _.sum(numbers);
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    average(numbers) {
+        const logLabel = `Math.Average of ${numbers.join(', ')}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = numbers?.length === 0 ? 0
+        : _.sum(numbers) / numbers.length;
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    text_to_number(str) {
+        const logLabel = `Math.Text to number ${str}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        let cleanedStr = _.replace(str, /,/g, '');
+        const num = parseFloat(cleanedStr);
+        if (_.isNaN(num)) {
+            logger.failureLog(logLabel);
+            throw {message: 'Not a valid number!'};
+        }
+        logger.endLog(logLabel);
+        return num;
+    }
+
+    currency_format(number, currencyCode) {
+        const logLabel = `Math.Format currency ${number} currency code ${currencyCode}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = this.formatToCurrency(logLabel, number, currencyCode);
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    currency_format_locale(number, currencyCode, locale) {
+        const logLabel = `Math.Format currency ${number} currency code ${currencyCode} in locale ${locale}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = this.formatToCurrency(logLabel, number, currencyCode, locale);
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    formatToCurrency(logLabel, number, currencyCode, locale = 'en-US') {
+        if(!this.isValidCurrencyCode(currencyCode)) {
+            logLabel && new Logger(this.caller, this.blacklistedLogs).failureLog(logLabel);
+            throw {message: `${currencyCode} is not a valid currency code!`};
+        }
+        if(!this.isValidLocale(locale)) {
+            logLabel && new Logger(this.caller, this.blacklistedLogs).failureLog(logLabel);
+            throw {message: `${locale} is not a valid locale!`};
+        }
+        if(_.isNaN(number)) {
+            logLabel && new Logger(this.caller, this.blacklistedLogs).failureLog(logLabel);
+            throw {message: `${number} is not a valid number!`};
+        }
+        return new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency: currencyCode
+        }).format(number);
+    }
+
+    isValidLocale(locale) {
+        if (!_.isString(locale) || _.isEmpty(locale)) {
+            return false;
+        }
+        try {
+            new Intl.NumberFormat(locale);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+    
+    isValidCurrencyCode(currencyCode) {
+        if (!_.isString(currencyCode) || _.isEmpty(currencyCode)) {
+            return false;
+        }
+        try {
+            new Intl.NumberFormat('en-US', { style: 'currency', currency: currencyCode }).format(1);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    advanced_number_format(params) {
+        const logLabel = `Advanced number formatting`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = this.formatNumber(params, logLabel);
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    custom_formula(params) {
+        const logLabel = `Custom Math Formula`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const value = this.evaluateFormula(params, logLabel);
+        const result = this.formatNumber({...params, number: value}, logLabel, true);
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    custom_formula_with_format(params) {
+        const logLabel = `Custom Math Formula + Formatting`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const value = this.evaluateFormula(params, logLabel);
+        const result = this.formatNumber({...params, number: value}, logLabel);
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    formatNumber({ 
+        number,
+        absoluteValue = false,
+        round = null,
+        truncate = null,
+        currencyCode = null,
+        locale = null,
+        prefix = '',
+        suffix = '',
+    }, logLabel, returnNumber) {
+        if(_.isNaN(number)) {
+            logLabel && new Logger(this.caller, this.blacklistedLogs).failureLog(logLabel);
+            throw {message: `${number} is not a valid number!`};
+        }
+    
+        if (absoluteValue === true || (_.isString(absoluteValue) && absoluteValue.toLowerCase() === "true")) {
+            number = Math.abs(number);
+        }
+    
+        if (round != null && (!_.isString(round) || round.trim() !== '') && !_.isNaN(Number(round))) {
+            number = _.round(number, Number(round));
+        }
+    
+        if (truncate != null && (!_.isString(truncate) || truncate.trim() !== '') && !_.isNaN(Number(truncate))) {
+            const factor = Math.pow(10, Number(truncate));
+            number = Math.trunc(number * factor) / factor;
+        }
+
+        if(returnNumber) {
+            return number;
+        }
+
+        if(currencyCode?.trim() && !this.isValidCurrencyCode(currencyCode)) {
+            logLabel && new Logger(this.caller, this.blacklistedLogs).failureLog(logLabel);
+            throw {message: `${currencyCode} is not a valid currency code!`};
+        }
+        if(locale?.trim() && !this.isValidLocale(locale)) {
+            logLabel && new Logger(this.caller, this.blacklistedLogs).failureLog(logLabel);
+            throw {message: `${locale} is not a valid locale!`};
+        }
+    
+        let formattedValue;
+        if (currencyCode) {
+            if (locale) {
+                formattedValue = new Intl.NumberFormat(locale, {
+                    style: 'currency',
+                    currency: currencyCode
+                }).format(number);
+            } else {
+                formattedValue = new Intl.NumberFormat(undefined, {
+                    style: 'currency',
+                    currency: currencyCode
+                }).format(number);
+            }
+        } else {
+            if (locale) {
+                formattedValue = new Intl.NumberFormat(locale).format(number);
+            } else {
+                formattedValue = number.toString();
+            }
+        }
+    
+        formattedValue = `${prefix}${formattedValue}${suffix}`;
+    
+        return formattedValue;
+    }
+
+    evaluateFormula(params, logLabel) {
+        let formula = params.formula;
+        formula = formula.replaceAll('^', '**');
+        if(params?.savedArgs) {
+            for (const [key, value] of Object.entries(params.savedArgs)) {
+                const regex = new RegExp(`\\b${key}\\b`, 'g');
+                formula = formula.replace(regex, value);
+            }
+        }
+        try {
+            return eval(formula);
+        } catch (ex) {
+            logLabel && new Logger(this.caller, this.blacklistedLogs).failureLog(logLabel);
+            throw {message: `Error evaluating formula! "${params.formula}" ${ex}`};
+        }
+    }
+
+}
+
+exports.MathUtils = MathUtils;