js-gei 1.0.0

package/dist/Evaluator/Parser/IfStategment.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IfStategment = void 0;
+class IfStategment {
+    ;
+    ;
+    ;
+    ;
+    // public constructor(ifSt:string)
+    // {
+    //     for (var op in this.operators)
+    //     {
+    //         if (ifSt.indexOf(this.operators[op])!=-1)
+    //         {
+    //             this.Operator = this.operators[op]; break;
+    //         }
+    //     }
+    //     if(this.Operator==null)
+    //     {
+    //       throw "Can't find operator";
+    //     }
+    //     var split = ifSt.split(this.Operator);
+    //     if (split.length == 2)
+    //     {
+    //         this.LeftSide = split[0];
+    //         this.RightSide = split[1];
+    //     }
+    //     else if (split.length == 1)
+    //     {
+    //       this.OneSide = split[0];
+    //     }
+    // }
+    constructor(ifSt) {
+        this.operators = ["<=", ">=", "!=", "<>", "==", "<", ">", "="];
+        this.LeftSide = null;
+        this.RightSide = null;
+        this.OneSide = null;
+        this.Operator = null;
+        for (var op in this.operators) {
+            if (ifSt.indexOf(this.operators[op]) != -1) {
+                this.Operator = this.operators[op];
+                break;
+            }
+        }
+        if (this.Operator == null) {
+            this.OneSide = ifSt;
+            return;
+        }
+        var split = ifSt.split(this.Operator);
+        if (split.length == 2) {
+            this.LeftSide = split[0];
+            this.RightSide = split[1];
+        }
+        else if (split.length == 1) {
+            this.OneSide = split[0];
+        }
+    }
+    CastToDecimal(side, citm) {
+        if (side == null || side == "null") {
+            return null;
+        }
+        if (side.startsWith("N.")) {
+            side = side.substring(2);
+        }
+        let value = null;
+        if (side.startsWith("%") && side.endsWith("%")) {
+            value = citm.ValueExpresion(side);
+        }
+        else {
+            value = side;
+        }
+        if (typeof value === 'number') {
+            return value;
+        }
+        let valStr = null;
+        if (typeof value === 'string') {
+            valStr = value;
+        }
+        if (valStr == null || valStr == "") {
+            return 0;
+        }
+        try {
+            return parseFloat(valStr);
+        }
+        catch (e) {
+            return 0;
+        }
+    }
+    TryParse(exp) {
+        if (exp == null) {
+            return false;
+        }
+        const reg = /^-?\d*\.?\d*$/;
+        const rege = new RegExp(reg);
+        if (!rege.test(exp)) {
+            return false;
+        }
+        try {
+            parseFloat(exp);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    Validate(citm) {
+        // if (this.OneSide!=null)
+        // {
+        //    var oneSide = citm.ValueExpresion(this.OneSide); ;
+        //     if (typeof oneSide === "boolean")
+        //     {
+        //       if(true)
+        //       {
+        //         // console.log("OneSide:"+oneSide);
+        //       }
+        //         return oneSide;
+        //     }
+        var _a, _b;
+        //     throw "Unsupported validation";
+        // }
+        if (this.OneSide != null) {
+            var oneSide = citm.ValueExpresion(this.OneSide);
+            ;
+            if (oneSide == null) {
+                return false;
+            }
+            if (typeof oneSide === "boolean") {
+                if (true) {
+                    // console.log("OneSide:"+oneSide);
+                }
+                return oneSide;
+            }
+            else if (typeof oneSide === "string") {
+                if (oneSide != null) {
+                    if (oneSide.toLocaleLowerCase() == "true") {
+                        return true;
+                    }
+                    if (oneSide.toLocaleLowerCase() == "false") {
+                        return false;
+                    }
+                    throw "Unsupported validation:Value:" + oneSide;
+                }
+                throw "Unsupported validation expression(" + this.OneSide + ") returned null!";
+            }
+            throw "Unsupported validation";
+        }
+        if ((((_a = this.LeftSide) === null || _a === void 0 ? void 0 : _a.startsWith("N.")) || this.TryParse(citm.ValueExpresion(this.LeftSide))
+            || this.LeftSide == "null") &&
+            (((_b = this.RightSide) === null || _b === void 0 ? void 0 : _b.startsWith("N.")) || this.TryParse(citm.ValueExpresion(this.RightSide))
+                || this.RightSide == "null")) {
+            let leftSide = this.CastToDecimal(this.LeftSide, citm);
+            let rightSide = this.CastToDecimal(this.RightSide, citm);
+            if (leftSide == null || rightSide == null) {
+                let returnValue = false;
+                switch (this.Operator) {
+                    case "!=":
+                    case "<>":
+                        {
+                            returnValue = leftSide != rightSide;
+                            break;
+                        }
+                    case "==":
+                    case "=":
+                        {
+                            returnValue = leftSide == rightSide;
+                            break;
+                        }
+                    default:
+                        {
+                            throw "Operator " + this.Operator + " not supported on condition decimal and decimal";
+                        }
+                }
+                if (true) {
+                    // console.log(leftSide+" "+ this.Operator+" "+rightSide+" "+returnValue);
+                }
+                return returnValue;
+            }
+            else {
+                let returnValue = false;
+                switch (this.Operator) {
+                    case ">=":
+                        {
+                            returnValue = leftSide >= rightSide;
+                            break;
+                        }
+                    case "<=":
+                        {
+                            returnValue = leftSide <= rightSide;
+                            break;
+                        }
+                    case "!=":
+                    case "<>":
+                        {
+                            returnValue = leftSide != rightSide;
+                            break;
+                        }
+                    case "<":
+                        {
+                            returnValue = leftSide < rightSide;
+                            break;
+                        }
+                    case ">":
+                        {
+                            returnValue = leftSide > rightSide;
+                            break;
+                        }
+                    case "==":
+                    case "=":
+                        {
+                            returnValue = leftSide == rightSide;
+                            break;
+                        }
+                    default:
+                        {
+                            throw "Operator " + this.Operator + " not supported on condition decimal and decimal";
+                        }
+                }
+                if (true) {
+                    // console.log(this.LeftSide+" "+ this.Operator+" "+this.RightSide);
+                    // console.log(leftSide+" "+ this.Operator+" "+rightSide+" =N "+returnValue);
+                }
+                return returnValue;
+            }
+        }
+        else {
+            let leftSide = citm.ValueExpresion(this.LeftSide);
+            ;
+            let rightSide = citm.ValueExpresion(this.RightSide);
+            if ((typeof leftSide === "boolean" || leftSide == null) && (typeof rightSide === "boolean" || rightSide == null)) {
+                let returnValue = false;
+                switch (this.Operator) {
+                    case "!=":
+                    case "<>":
+                        {
+                            returnValue = leftSide != rightSide;
+                            break;
+                        }
+                    case "==":
+                    case "=":
+                        {
+                            returnValue = leftSide == rightSide;
+                            break;
+                        }
+                    default:
+                        {
+                            throw "Operator " + this.Operator + " not supported on condition boolean and boolean";
+                        }
+                }
+                if (true) {
+                    // console.log(this.LeftSide+" "+ this.Operator+" "+this.RightSide);
+                    // console.log(leftSide+" "+ this.Operator+" "+rightSide+" = "+returnValue);
+                }
+                return returnValue;
+            }
+            if ((typeof leftSide === "string" || leftSide == null) &&
+                (typeof rightSide === "string" || rightSide == null)) {
+                let returnValue = false;
+                switch (this.Operator) {
+                    case "!=":
+                    case "<>":
+                        {
+                            returnValue = leftSide != rightSide;
+                            break;
+                        }
+                    case "==":
+                    case "=":
+                        {
+                            returnValue = leftSide == rightSide;
+                            break;
+                        }
+                    default:
+                        {
+                            throw "Operator " + this.Operator + " not supported on condition string and string";
+                        }
+                }
+                if (true) {
+                    // console.log(this.LeftSide+" "+ this.Operator+" "+this.RightSide);
+                    // console.log(leftSide+" "+ this.Operator+" "+rightSide+" = "+returnValue);
+                }
+                return returnValue;
+            }
+        }
+        // debugger
+        throw "Unsupported validation";
+    }
+}
+exports.IfStategment = IfStategment;

package/dist/Evaluator/Parser/InDetailParse.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InDetailParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+const ExpresionLogicService_1 = require("../ExpresionLogicService");
+class InDetailParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        super(valueExpression, funname);
+        this.Negate = false;
+        this.TableAndField = "";
+        this.Table = "";
+        this.Field = "";
+        this.aviableValues = [];
+        if (this.Expression == null) {
+            return;
+        }
+        if (!this.Expression.startsWith("(")) {
+            return;
+        }
+        var index = ExpresionLogicService_1.ExpresionLogicService.FindEnd(this.Expression);
+        var set = this.Expression.substring(1, index);
+        this.TableAndField = this.Expression.substring(index + 2);
+        if (this.TableAndField == null || this.TableAndField == "") {
+            throw "Invalid expresion InDetail - table.field is empty!";
+        }
+        if (set == null || set == "") {
+            throw "Invalid expresion InDetail - set of values is empty!";
+        }
+        var split = this.TableAndField.split(".");
+        if (split.length == 2) {
+            this.Table = split[0];
+            this.Field = split[1];
+        }
+        else {
+            throw "Invalid expresion InDetail - table.field not in correction format!";
+        }
+        this.aviableValues = set.split(",");
+        if ((funname === null || funname === void 0 ? void 0 : funname.toLowerCase()) == "notindetail(") {
+            this.Negate = true;
+        }
+    }
+    Evaluate(obj, critm, record, item) {
+        // var tableLevel = obj.FindTableLevel(this.Table, critm.Parent, critm);todo
+        var tableLevel = obj.FindTableLevel(this.Table);
+        if (tableLevel == null) {
+            return false;
+        }
+        if (tableLevel.Records != null) {
+            var array = tableLevel.Records.Records;
+            if (!this.Negate) {
+                for (var i = 0; i < tableLevel.Records.Records.length; i++) {
+                    let single = tableLevel.Records.Records[i];
+                    if (single.Record[this.Field] == null) {
+                        continue;
+                    }
+                    let cand = this.aviableValues.filter((x) => x == single.Record[this.Field].toString());
+                    if (cand.length > 0) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            else {
+                for (var i = 0; i < tableLevel.Records.Records.length; i++) {
+                    let single = tableLevel.Records.Records[i];
+                    if (single.Record[this.Field] == null) {
+                        continue;
+                    }
+                    let cand = this.aviableValues.filter((x) => x != single.Record[this.Field].toString());
+                    if (cand.length > 0) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+    }
+}
+exports.InDetailParse = InDetailParse;

package/dist/Evaluator/Parser/InListParse.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INListParser = void 0;
+const BaseParse_1 = require("./BaseParse");
+const ValueFromObjParse_1 = require("./ValueFromObjParse");
+const ExpresionLogicService_1 = require("../ExpresionLogicService");
+class INListParser extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        super(valueExpression, funname);
+        this.Negate = false;
+        this.FieldSet = "";
+        this.aviableValues = [];
+        if (this.Expression == null) {
+            return;
+        }
+        if (!this.Expression.startsWith("(")) {
+            return;
+        }
+        var index = ExpresionLogicService_1.ExpresionLogicService.FindEnd(this.Expression);
+        var set = this.Expression.substring(1, index);
+        this.FieldSet = this.Expression.substring(index + 2);
+        this.aviableValues = set.split(",");
+        if ((funname === null || funname === void 0 ? void 0 : funname.toLowerCase()) == "notinlist(") {
+            this.Negate = true;
+        }
+    }
+    Evaluate(obj, critm, record, item) {
+        var val = new ValueFromObjParse_1.ValueFromObjParse(this.FieldSet, false);
+        var evalValue = val.Evaluate(obj, critm, record, item);
+        if (evalValue == null || this.aviableValues.length == 0) {
+            return false;
+        }
+        var cand = this.aviableValues.indexOf(evalValue.toString());
+        if (this.Negate) {
+            return cand == -1;
+        }
+        return cand != -1;
+    }
+}
+exports.INListParser = INListParser;

package/dist/Evaluator/Parser/LiteralValueParse.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteralValueParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+class LiteralValueParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression) {
+        super(valueExpression, null);
+    }
+    Evaluate(obj, critm, record, item) {
+        if (this.Expression == "null") {
+            return null;
+        }
+        if (this.Expression.startsWith("N.")) {
+            if (typeof this.Expression == "string") {
+                try {
+                    return parseFloat(this.Expression);
+                }
+                catch (ex) {
+                    throw "Value " + this.Expression + " can't be transformed to numeric!";
+                }
+            }
+        }
+        return this.Expression;
+    }
+}
+exports.LiteralValueParse = LiteralValueParse;

package/dist/Evaluator/Parser/LogicalOperatorParse.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicalOperatorParser = void 0;
+const BaseParse_1 = require("./BaseParse");
+class LogicalOperatorParser extends BaseParse_1.BaseParse {
+    constructor(valueExpression) {
+        super(valueExpression, null);
+    }
+    Evaluate(obj, critm, record, item) {
+        return this.Expression;
+    }
+}
+exports.LogicalOperatorParser = LogicalOperatorParser;

package/dist/Evaluator/Parser/OnlyExpressionParse.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnlyExpressionParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+const OperatorParse_1 = require("./OperatorParse");
+const LiteralValueParse_1 = require("./LiteralValueParse");
+const ValueFromObjParse_1 = require("./ValueFromObjParse");
+const ExpresionLogicService_1 = require("../ExpresionLogicService");
+class OnlyExpressionParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression) {
+        super(valueExpression, null);
+        this.subParse = [];
+        var list = [];
+        var currentLit = "";
+        while (valueExpression.length > 0) {
+            var br = false;
+            for (let i = 0; i < BaseParse_1.BaseParse.operators.length; i++) {
+                let o = BaseParse_1.BaseParse.operators[i];
+                if (valueExpression.startsWith(o)) {
+                    list.push(new OperatorParse_1.OperatorParser(valueExpression.substring(0, o.length)));
+                    valueExpression = valueExpression.substring(o.length);
+                    br = true;
+                    break;
+                    ;
+                }
+            }
+            if (br) {
+                continue;
+            }
+            if (["%", "(", ")"].indexOf(valueExpression.substring(0, 1)) == -1 && !ExpresionLogicService_1.ExpresionLogicService.StartsWithFunction(valueExpression)) {
+                currentLit += valueExpression.substring(0, 1);
+                valueExpression = valueExpression.substring(1);
+                continue;
+            }
+            if (currentLit != "") {
+                list.push(new LiteralValueParse_1.LiteralValueParse(currentLit));
+                currentLit = "";
+            }
+            if (valueExpression.startsWith("N.%")) {
+                var indexNext = valueExpression.substring(3).indexOf("%") + 1;
+                list.push(new ValueFromObjParse_1.ValueFromObjParse(valueExpression.substring(2, indexNext - 1), true));
+                valueExpression = valueExpression.substring(indexNext + 1);
+                continue;
+            }
+            if (valueExpression.startsWith("%")) {
+                var indexNext = valueExpression.substring(1).indexOf("%") + 1;
+                list.push(new ValueFromObjParse_1.ValueFromObjParse(valueExpression.substring(0, indexNext + 1), false));
+                valueExpression = valueExpression.substring(indexNext + 1);
+                continue;
+            }
+            var foundFun = false;
+            const keys = Object.keys(ExpresionLogicService_1.ExpresionLogicService._suportedFunctions);
+            for (let i = 0; i < keys.length; i++) {
+                let key = keys[i];
+                if (valueExpression.startsWith(key)) {
+                    if (currentLit != "") {
+                        list.push(new OnlyExpressionParse(currentLit));
+                        currentLit = "";
+                    }
+                    var index = ExpresionLogicService_1.ExpresionLogicService.FindEnd(valueExpression);
+                    if (index == -1) {
+                        throw "Unbalanced brackets!!!! Expression:" + valueExpression;
+                    }
+                    let instance = Reflect.construct(ExpresionLogicService_1.ExpresionLogicService._suportedFunctions[key], [valueExpression.substring(0, index + 1), key]);
+                    list.push(instance);
+                    if (index < valueExpression.length) {
+                        valueExpression = valueExpression.substring(index + 1);
+                    }
+                    else {
+                        valueExpression = "";
+                    }
+                    foundFun = true;
+                    break;
+                }
+            }
+            if (foundFun) {
+                continue;
+            }
+            var found = false;
+            for (let i = 0; i < OnlyExpressionParse._literalValues.length; i++) {
+                var val = OnlyExpressionParse._literalValues[i];
+                if (valueExpression.substring(0, 1) == val) {
+                    list.push(new LiteralValueParse_1.LiteralValueParse(val));
+                    valueExpression = valueExpression.substring(1);
+                    found = true;
+                    break;
+                }
+            }
+            if (found) {
+                continue;
+            }
+        }
+        if (currentLit != "") {
+            list.push(new LiteralValueParse_1.LiteralValueParse(currentLit));
+        }
+        this.subParse = list;
+    }
+    Evaluate(obj, critm, record, item) {
+        if (this.subParse.length == 1) {
+            return this.subParse[0].Evaluate(obj, critm, record, item);
+        }
+        return ExpresionLogicService_1.ExpresionLogicService.ConcatValues(this.subParse, obj, critm, record, item);
+    }
+}
+exports.OnlyExpressionParse = OnlyExpressionParse;
+OnlyExpressionParse._literalValues = ["(", ")"];

package/dist/Evaluator/Parser/OperatorParse.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorParser = void 0;
+const BaseParse_1 = require("./BaseParse");
+class OperatorParser extends BaseParse_1.BaseParse {
+    constructor(valueExpression) {
+        super(valueExpression, null);
+    }
+    Evaluate(obj, critm, record, item) {
+        return this.Expression;
+    }
+}
+exports.OperatorParser = OperatorParser;

package/dist/Evaluator/Parser/StartsParse.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartsParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+const OnlyExpressionParse_1 = require("./OnlyExpressionParse");
+class StartsParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        super(valueExpression, funname);
+        this.starts = null;
+        this.value = null;
+        var split = this.Expression.split(",");
+        if (split.length == 2) {
+            this.starts = new OnlyExpressionParse_1.OnlyExpressionParse(split[0]);
+            this.value = new OnlyExpressionParse_1.OnlyExpressionParse(split[1]);
+        }
+    }
+    Evaluate(obj, critm, record, item) {
+        var _a, _b;
+        var startsEvaluate = (_a = this.starts) === null || _a === void 0 ? void 0 : _a.Evaluate(obj, critm, record, item);
+        var valueEvaluate = (_b = this.value) === null || _b === void 0 ? void 0 : _b.Evaluate(obj, critm, record, item);
+        if (startsEvaluate == null || valueEvaluate == null) {
+            return false;
+        }
+        var evaluated = startsEvaluate.ToString();
+        var evaluatedValue = valueEvaluate.ToString();
+        var result = evaluatedValue.startsWith(evaluated);
+        return result;
+    }
+}
+exports.StartsParse = StartsParse;

package/dist/Evaluator/Parser/SubstrParse.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstrParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+const CommaParser_1 = require("./CommaParser");
+const ExpresionLogicService_1 = require("../ExpresionLogicService");
+class SubstrParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        super(valueExpression, funname);
+        this.starts = [];
+        this.value = [];
+        this.length = [];
+        var dd = ExpresionLogicService_1.ExpresionLogicService.GetExpressions(this.Expression, this);
+        var current = [];
+        if (dd == null) {
+            return;
+        }
+        for (let i = 0; i < dd.length; i++) {
+            current = this.logic(current, dd[i]);
+        }
+        this.logic(current, null);
+        if (this.value.length == 0 || this.starts.length == 0 || this.length.length == 0) {
+            throw "Can't parse if stategment " + valueExpression + "!";
+        }
+    }
+    Evaluate(obj, critm, record, item) {
+        var valueEval = ExpresionLogicService_1.ExpresionLogicService.ConcatValues(this.value, obj, critm, record, item);
+        if (valueEval == null) {
+            return null;
+        }
+        var val = valueEval.ToString();
+        let str = -1;
+        var startEval = ExpresionLogicService_1.ExpresionLogicService.ConcatValues(this.starts, obj, critm, record, item);
+        if (typeof startEval == "number") {
+            str = startEval;
+        }
+        else if (typeof startEval == "string") {
+            str = parseInt(startEval);
+        }
+        if (str == -1) {
+            throw "Substr start index can't be parsed! Value: " + startEval + "!";
+        }
+        else {
+            str--;
+        }
+        let len = -1;
+        var lengthEval = ExpresionLogicService_1.ExpresionLogicService.ConcatValues(this.length, obj, critm, record, item);
+        if (typeof lengthEval == "number") {
+            len = lengthEval;
+        }
+        else if (lengthEval == "string") {
+            len = parseInt(lengthEval);
+        }
+        if (len == -1) {
+            throw "Substr length index can't be parsed! Value: " + lengthEval + "!";
+        }
+        if (val.Length <= str) {
+            return null;
+        }
+        var tem = val.substring(str);
+        if (tem.Length <= len) {
+            return tem;
+        }
+        return tem.substring(0, len);
+    }
+    logic(list, c) {
+        if (c == null || c instanceof CommaParser_1.CommaParser) {
+            if (this.value.length == 0) {
+                this.value = list;
+            }
+            else if (this.starts.length == 0) {
+                this.starts = list;
+            }
+            else if (this.length.length == 0) {
+                this.length = list;
+            }
+            return [];
+        }
+        list.push(c);
+        return list;
+    }
+}
+exports.SubstrParse = SubstrParse;