condcal-cjs 1.0.0

package/index.js

@@ -0,0 +1,260 @@
+const REGEX_CONDITION = /((Date|Number|)(\(|)([\w- ]{1,})(==|!=|>|>=|<|<=)([\w- ]{1,})(\)|))(&&|\|\||){1,}/g;
+
+// OLD
+//const REGEX_QUOTATIONS = /(\(\([a-zA-Z0-9=<>&() ]{1,}\)=\([a-zA-Z0-9.+\-*/]{1,}\)\))(\^\^|){1,}/g;
+//const REGEX_CONDITION_VALUE = /\(\((\(|)((Date|Number|)([a-zA-Z0-9=<>&() ]{1,}))(\)|)\)=\(([a-zA-Z0-9.+\-*/]{1,})\)\)/;
+
+// NEW
+const REGEX_QUOTATIONS = /(\(\({1}[a-zA-Z0-9=<>&()\- ]{1,}\){1}=\({1}[a-zA-Z0-9.+\-*/()]{1,}\){1}\))(\^\^|){1,}/g
+const REGEX_CONDITION_VALUE = /\(\((\(|)((Date|Number|)([a-zA-Z0-9=<>&()\- ]{1,}))(\)|)\)=\(([a-zA-Z0-9.+\-*/()]{1,})\)\)/;
+
+// COMPUTATION
+const REGEX_HAS_PARENTHESIS = /\((.{1,})\)/g;
+const REGEX_PARENTHESIS = /\((((-|)\d{1,}((?=\.)\.\d{1,}|)((?=[+\-*/])[+\-*/]{1})){1,}(-|)\d{1,}((?=\.)\.\d{1,}|))\)/g;
+const REGEX_MUL_DIV = /(((?=[+\-*/])[+\-]{0,}|(?=^)[+\-]{0,})\d+(\.(?=\d)|)\d{0,})([*/]{1})(((?=[+\-*/])[+\-]{0,}|)\d+(\.(?=\d)|)\d{0,})/g;
+const REGEX_ADD_SUB = /(((?=[+\-*/])[+\-]{0,}|(?=^)[+\-]{0,})\d+(\.(?=\d)|)\d{0,})([+\-]{1})(((?=[+\-*/])[+\-]{0,}|)\d+(\.(?=\d)|)\d{0,})/g;
+const REGEX_MATH_FUNCTIONS = /()/g;
+
+const REGEX_VARIABLES_TO_NUMBERS = /[a-zA-Z]{1,}/g;
+
+var moment = require('moment');
+
+var checkCondition = (condition, params) => {
+    let allGrants = [];
+
+    let result;
+    while (result = REGEX_CONDITION.exec(condition)) {
+        let granted = false;
+
+        let paramName1 = result[4], paramName2 = result[6], operation = result[5];
+
+        let type = 'Text';
+        if (result[2]) { type = result[2]; }
+
+        let param1 = "", param2 = "";
+        
+        if (params[paramName1]) param1 = params[paramName1];
+        else param1 = paramName1;
+
+        if (params[paramName2]) param2 = params[paramName2];
+        else param2 = paramName2;
+
+        if (type === 'Text') {
+            if (operation === '==') {
+            if (param1 === param2) {
+                granted = true;
+            }
+            }
+        } else if (type === 'Number') {
+            let paramDouble1 = 0, paramDouble2 = 0;
+            try {
+            paramDouble1 = parseFloat(param1);
+            paramDouble2 = parseFloat(param2);
+            } catch (e) {
+            console.log('error', e);
+            }
+
+            if (operation === '==') {
+            if (paramDouble1 === paramDouble2) {
+                granted = true;
+            }
+            } else if (operation === '>') {
+            if (paramDouble1 > paramDouble2) {
+                granted = true;
+            }
+            } else if (operation === '>=') {
+            if (paramDouble1 >= paramDouble2) {
+                granted = true;
+            }
+            } else if (operation === '<') {
+            if (paramDouble1 < paramDouble2) {
+                granted = true;
+            }
+            } else if (operation === '<=') {
+            if (paramDouble1 <= paramDouble2) {
+                granted = true;
+            }
+            }
+        } else if (type === 'Date') {
+            let paramDate1 = null, paramDate2 = null;
+            try {
+            paramDate1 = new Date(param1);
+            paramDate2 = new Date(param2);
+            } catch (e) {
+            console.log('err', e);
+            }
+
+            if (operation === '==') {
+            if (moment(paramDate1).isSame(paramDate2)) {
+                granted = true;
+            }
+            } else if (operation === '>') {
+            if (moment(paramDate1).isAfter(paramDate2)) {
+                granted = true;
+            }
+            } else if (operation === '>=') {
+            if (moment(paramDate1).isSameOrAfter(paramDate2)) {
+                granted = true;
+            }
+            } else if (operation === '<') {
+            if (moment(paramDate1).isBefore(paramDate2)) {
+                granted = true;
+            }
+            } else if (operation === '<=') {
+            if (moment(paramDate1).isSameOrBefore(paramDate2)) {
+                granted = true;
+            }
+            }
+        }
+
+        allGrants.push(granted);
+    }
+
+    let allGranted = true;
+    for (let i = 0; i < allGrants.length; i++) {
+        if (!allGrants[i]) allGranted = false;
+    }
+    return allGranted;
+};
+
+var getValueInCondition = (formula, params) => {
+    // CONVERTING VARIABLES TO NUMBERS
+    let nFormula = formula;
+
+    let matches = [];
+    let result;
+    while (result = REGEX_VARIABLES_TO_NUMBERS.exec(nFormula)) {
+        matches.push({
+            text: result[0],
+            startIndex: result.index
+        });
+    }
+    
+    for (let i = matches.length - 1; i >= 0; i--) {
+        let match = matches[i];
+
+        let value = 0;
+        try {
+            if (params[match.text]) value = params[match.text];
+        } catch (e) {
+            console.log('err', e);
+        }
+        nFormula = nFormula.substring(0, match.startIndex) + nFormula.substring(match.startIndex + match.text.length);
+        nFormula = nFormula.substring(0, match.startIndex) + value + nFormula.substring(match.startIndex);
+    }
+    return this.getValueInParenthesis(nFormula);
+};
+
+var getValueInParenthesis = (formula) => {
+    let nFormula = formula;
+
+    let resultParenthesis, resultHasParenthesis;
+    while (resultHasParenthesis = REGEX_HAS_PARENTHESIS.exec(nFormula)) {
+        let matches = [];
+        
+        while (resultParenthesis = REGEX_PARENTHESIS.exec(nFormula)) {
+            matches.push({
+                text: resultParenthesis[0],
+                value: resultParenthesis[1],
+                startIndex: resultParenthesis.index
+            });
+        }
+
+        for (let i = matches.length - 1; i >= 0; i--) {
+            let match = matches[i];
+
+            let value = this.getValueInParenthesis(match.value);
+
+            nFormula = nFormula.substring(0, match.startIndex) + nFormula.substring(match.startIndex + match.text.length);
+            nFormula = nFormula.substring(0, match.startIndex) + value + nFormula.substring(match.startIndex);
+        }
+    }
+
+    let value = 0;
+    let concat = '';
+
+    // MULTIPLICATION & DIVISION
+    let resultMulDiv = new RegExp(REGEX_MUL_DIV).exec(nFormula);
+    while (resultMulDiv) {
+        let param1 = 0, param2 = 0;
+        try {
+            param1 = parseFloat(resultMulDiv[1]);
+            param2 = parseFloat(resultMulDiv[5]);
+        } catch (e) {
+            console.log('err', e);
+        }
+
+        if (resultMulDiv[4] === '*') {
+            value = param1 * param2;
+        } else if (resultMulDiv[4] === '/') {
+            value = param1 / param2;
+        }
+
+        concat = (value >= 0) ? ('+' + value) : (value + '');
+
+        nFormula = nFormula.substring(0, resultMulDiv.index) + nFormula.substring(resultMulDiv.index + resultMulDiv[0].length);
+        nFormula = nFormula.substring(0, resultMulDiv.index) + concat + nFormula.substring(resultMulDiv.index);
+        
+        resultMulDiv = new RegExp(REGEX_MUL_DIV).exec(nFormula);
+    }
+
+    // ADDITION & SUBSTRACTION
+    let resultAddSub = new RegExp(REGEX_ADD_SUB).exec(nFormula);
+    while (resultAddSub) {
+        let param1 = 0, param2 = 0;
+        try {
+            param1 = parseFloat(resultAddSub[1]);
+            param2 = parseFloat(resultAddSub[5]);
+        } catch (e) {
+            console.log('err', e);
+        }
+
+        if (resultAddSub[4] === '+') {
+            value = param1 + param2;
+        } else if (resultAddSub[4] === '-') {
+            value = param1 - param2;
+        }
+        
+        concat = (value >= 0) ? ('+' + value) : (value + '');
+
+        nFormula = nFormula.substring(0, resultAddSub.index) + nFormula.substring(resultAddSub.index + resultAddSub[0].length);
+        nFormula = nFormula.substring(0, resultAddSub.index) + concat + nFormula.substring(resultAddSub.index);
+        
+        resultAddSub = new RegExp(REGEX_ADD_SUB).exec(nFormula);
+    }
+
+    let finalValue = 0;
+    try {
+        finalValue = parseFloat(nFormula);
+    } catch (e) {
+        console.log('err', e);
+    }
+    
+    return finalValue;
+};
+
+module.exports = {
+    getValue: (condCal, parameters) => {
+        let v = 0;
+
+        let pattern = new RegExp(REGEX_QUOTATIONS);
+        let result;
+        while (result = pattern.exec(condCal)) {
+            let conditionResult = REGEX_CONDITION_VALUE.exec(result[1]);
+
+            if (conditionResult) {
+                let condition = conditionResult[2], value = conditionResult[6];
+
+                if (checkCondition(condition, parameters)) {
+                    v = getValueInCondition(value, parameters);
+                    break;
+                }
+            }
+        }
+        return v;
+    },
+
+    checkCondition: checkCondition,
+    getValueInCondition: getValueInCondition,
+    getValueInParenthesis: getValueInParenthesis
+};

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "condcal-cjs",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "moment": "^2.30.1"
+  }
+}