js-gei 1.0.0

package/dist/Evaluator/Parser/CalcDateParse.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalcDateParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+const OnlyExpressionParse_1 = require("./OnlyExpressionParse");
+class CalcDateParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        super(valueExpression, funname);
+        this.value = "";
+        this.offset = "";
+        var split = this.Expression.split(",");
+        if (split.length == 2) {
+            this.value = split[0];
+            this.offset = split[1];
+        }
+    }
+    Evaluate(obj, critm, record, item) {
+        if (this.value == "" || this.offset == "") {
+            return null;
+        }
+        var valueEval = new OnlyExpressionParse_1.OnlyExpressionParse(this.value);
+        var valueE = valueEval.Evaluate(obj, critm, record, item);
+        var offsetEval = new OnlyExpressionParse_1.OnlyExpressionParse(this.offset);
+        var offsetE = offsetEval.Evaluate(obj, critm, record, item);
+        var datetimeValue = null;
+        var offsetInt = null;
+        if (valueE.constructor.name == "Date") {
+            datetimeValue = valueE;
+        }
+        else if (typeof valueE == "string") {
+            datetimeValue = new Date(valueE);
+        }
+        if (typeof offsetE == "number") {
+            offsetInt = offsetE;
+        }
+        else if (typeof offsetE == "string") {
+            offsetInt = parseInt(offsetE);
+        }
+        if (offsetInt != null && datetimeValue != null) {
+            datetimeValue.setDate(datetimeValue.getDate() + offsetInt);
+            if (item.TypeDDD == "Date") {
+                return BaseParse_1.BaseParse.getIsoDate(datetimeValue);
+            }
+            else if (item.TypeDDD == "DateTime") {
+                return BaseParse_1.BaseParse.getIsoDateTime(datetimeValue);
+            }
+        }
+        else {
+            debugger;
+        }
+        return this.Expression;
+    }
+}
+exports.CalcDateParse = CalcDateParse;

package/dist/Evaluator/Parser/CheckParse.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckParse = void 0;
+const InvoiceObj_1 = require("../../Structure/InvoiceObj");
+const BaseParse_1 = require("./BaseParse");
+class CheckParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        super(valueExpression, funname);
+        this.Detail = "";
+        this.Exp = "";
+        this.Parameter = "";
+        var split = this.Expression.split(",");
+        if (split.length == 2) {
+            var split = this.Expression.split(",");
+            if (split.length != 3) {
+                throw "Check have more or less parameters that 3";
+            }
+            this.Detail = split[0];
+            this.Exp = split[1];
+            this.Parameter = split[2];
+        }
+    }
+    Evaluate(obj, critm, record, item) {
+        var _a, _b;
+        var list = [];
+        if (InvoiceObj_1.InvoiceObj.isMultiple(this.Detail)) {
+            /*var tableLevels = obj.(Detail);
+            if (tableLevels == null||tableLevels.Count==0)
+            {
+                throw new Exception($"Can't find level {Detail}");
+            }
+            foreach(var tab in tableLevels)
+            {
+                var array = tab.Records as RecordLevelArray;
+                foreach(var rec in array.Records)
+                {
+                    list.Add(rec);
+                }
+            } */
+        }
+        else {
+            var tableLevel = obj.FindTableLevel(this.Detail);
+            if (tableLevel == null) {
+                throw "Can't find level {Detail}";
+            }
+            if (tableLevel.Record != null) {
+                throw "Table level isn't detail!";
+            }
+            if (tableLevel.Records == null) {
+                throw "Table level doesn't have records!";
+            }
+            var array = tableLevel.Records.Records;
+            for (var i = 0; i < array.length; i++) {
+                list.push(array[i]);
+            }
+        }
+        var trueCounter = 0;
+        for (var i = 0; i < list.length; i++) {
+            /*var result = ExpressionLogic.ParseExpressionAndReturnValue("IF("+this.Exp+",true,false)", obj, item, rec, 0);
+            if(result=="true")
+            {
+                trueCounter++;
+                if(this.Parameter?.toLocaleLowerCase() =="one")
+                {
+                    return true;
+                }
+            }TODO*/
+        }
+        if (((_a = this.Parameter) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase()) == "one") {
+            return false;
+        }
+        else if (((_b = this.Parameter) === null || _b === void 0 ? void 0 : _b.toLocaleLowerCase()) == "all") {
+            return trueCounter == list.length;
+        }
+        else {
+            throw "Check prameter isn't valid!Valid:One,All.Provided:" + this.Parameter;
+        }
+    }
+}
+exports.CheckParse = CheckParse;

package/dist/Evaluator/Parser/CommaParser.js

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

package/dist/Evaluator/Parser/ConcatParse.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConcatParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+const CommaParser_1 = require("./CommaParser");
+const ExpresionLogicService_1 = require("../ExpresionLogicService");
+class ConcatParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        var _a;
+        super(valueExpression, funname);
+        this.sections = [];
+        this.sections = (_a = ExpresionLogicService_1.ExpresionLogicService.GetExpressions(this.Expression, this)) !== null && _a !== void 0 ? _a : [];
+    }
+    Evaluate(obj, critm, record, item) {
+        var builder = "";
+        for (var i = 0; i < this.sections.length; i++) {
+            let section = this.sections[i];
+            if (section instanceof CommaParser_1.CommaParser) {
+                continue;
+            }
+            var value = section.Evaluate(obj, critm, record, item);
+            if (value != null) {
+                builder += value;
+            }
+        }
+        return builder;
+    }
+}
+exports.ConcatParse = ConcatParse;

package/dist/Evaluator/Parser/CountParse.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+class CountParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        super(valueExpression, funname);
+        this.Table = ";";
+        this.Table = this.Expression;
+    }
+    Evaluate(obj, critm, record, item) {
+        var _a;
+        if (this.Table == "") {
+            throw "Function count don't have defined table!";
+        }
+        var tableLevel = obj.FindTableLevel(this.Table);
+        if (tableLevel == null) {
+            return -1;
+        }
+        return (_a = tableLevel.Records) === null || _a === void 0 ? void 0 : _a.Records.length;
+    }
+}
+exports.CountParse = CountParse;

package/dist/Evaluator/Parser/EmptyParse.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+const OnlyExpressionParse_1 = require("./OnlyExpressionParse");
+const ExpresionLogicService_1 = require("../ExpresionLogicService");
+class EmptyParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        super(valueExpression, funname);
+        this.valueExp = null;
+        var dd = ExpresionLogicService_1.ExpresionLogicService.GetExpressions(this.Expression, this);
+        if (dd == null) {
+            return;
+        }
+        if (dd.length == 1 && dd[0] instanceof OnlyExpressionParse_1.OnlyExpressionParse) {
+            this.valueExp = dd[0];
+        }
+        else {
+            throw "Expression '" + this.Expression + "' isn't ValueFromObjParse";
+        }
+    }
+    Evaluate(obj, critm, record, item) {
+        var _a;
+        var value = (_a = this.valueExp) === null || _a === void 0 ? void 0 : _a.Evaluate(obj, critm, record, item);
+        if (value == null) {
+            return true;
+        }
+        if (typeof value == "string") {
+            var v = value;
+            return v == "" || v.trim() == "";
+        }
+        return false;
+    }
+}
+exports.EmptyParse = EmptyParse;

package/dist/Evaluator/Parser/ExistParse.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExistParser = void 0;
+const BaseParse_1 = require("./BaseParse");
+class ExistParser extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        var _a;
+        super(valueExpression, funname);
+        this.Table = "";
+        this.FieldName = "";
+        this.Negate = false;
+        if (funname.toLowerCase() == "notexists(") {
+            this.Negate = true;
+        }
+        var split = this.Expression.split(".");
+        if (split.length != 2) {
+        }
+        this.Table = split[0];
+        this.FieldName = split[1];
+        if ((_a = this.Table) === null || _a === void 0 ? void 0 : _a.startsWith("!")) {
+            this.Table = this.Table.substring(1);
+            this.Negate = true;
+        }
+    }
+    Evaluate(obj, critm, record, item) {
+        var _a;
+        if (this.Table == null) {
+            throw "No table";
+        }
+        var tableLevel = obj.FindTableLevel(this.Table);
+        if (tableLevel == null) {
+            throw "Table level  " + this.Table + " don't exist in object!";
+        }
+        let exist = false;
+        ;
+        if (tableLevel == obj.rootLevel) {
+            var rec = tableLevel.Record;
+            exist = (rec === null || rec === void 0 ? void 0 : rec.Record.Record[this.FieldName]) != null;
+        }
+        else {
+            var records = tableLevel.Records;
+            if (records == null) {
+                throw "Table level  " + this.Table + " don't have active records!";
+            }
+            var index = records.Records.indexOf(critm);
+            if (index == -1) {
+                throw "Table level  " + this.Table + " not the same as record!" + ((_a = critm === null || critm === void 0 ? void 0 : critm.Parent) === null || _a === void 0 ? void 0 : _a.Tablename);
+            }
+            exist = records.Records[index].Record[this.FieldName] != null;
+        }
+        if (this.Negate) {
+            exist = !exist;
+        }
+        return exist;
+    }
+}
+exports.ExistParser = ExistParser;

package/dist/Evaluator/Parser/IfParse.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IfParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+const CommaParser_1 = require("./CommaParser");
+const LogicalOperatorParse_1 = require("./LogicalOperatorParse");
+const OperatorParse_1 = require("./OperatorParse");
+const ExpresionLogicService_1 = require("../ExpresionLogicService");
+class IfParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        super(valueExpression, funname);
+        this.conditionParse = [];
+        this.conditionTrueParse = [];
+        this.conditionFalseParse = [];
+        var dd = ExpresionLogicService_1.ExpresionLogicService.GetExpressions(this.Expression, this);
+        if (dd == null) {
+            return;
+        }
+        var current = [];
+        for (let i = 0; i < dd.length; i++) {
+            current = this.logic(current, dd[i]);
+        }
+        this.logic(current, null);
+        if (this.conditionParse.length == 0 || this.conditionTrueParse.length == 0 || this.conditionFalseParse.length == 0) {
+            throw "Can't parse if stategment " + valueExpression + "!";
+        }
+    }
+    Evaluate(obj, critm, record, item) {
+        var candidates = this.conditionParse.filter(x => x instanceof LogicalOperatorParse_1.LogicalOperatorParser);
+        var finishResult = false;
+        if (candidates.length == 0) {
+            finishResult = this.validateExpression(obj, critm, record, item, this.conditionParse);
+        }
+        else {
+            let condition = [];
+            let result = [];
+            for (let i = 0; i < this.conditionParse.length; i++) {
+                let c = this.conditionParse[i];
+                if (c instanceof LogicalOperatorParse_1.LogicalOperatorParser) {
+                    var res = this.validateExpression(obj, critm, record, item, result);
+                    result = [];
+                    condition.push(res);
+                    condition.push(c.Expression);
+                    continue;
+                }
+            }
+            if (result.length > 0) {
+                var res = this.validateExpression(obj, critm, record, item, result);
+                condition.push(res);
+            }
+            finishResult = condition[0];
+            for (var i = 1; i < condition.length; i += 2) {
+                var c = condition[i];
+                switch (c) {
+                    case "&&":
+                        {
+                            finishResult = finishResult && condition[i + 1];
+                            break;
+                        }
+                    case "||":
+                        {
+                            finishResult = finishResult || condition[i + 1];
+                            break;
+                        }
+                }
+            }
+        }
+        finish: if (finishResult == true) {
+            return ExpresionLogicService_1.ExpresionLogicService.ConcatValues(this.conditionTrueParse, obj, critm, record, item);
+        }
+        return ExpresionLogicService_1.ExpresionLogicService.ConcatValues(this.conditionFalseParse, obj, critm, record, item);
+    }
+    logic(list, c) {
+        if (c == null || c instanceof CommaParser_1.CommaParser) {
+            if (this.conditionParse.length == 0) {
+                this.conditionParse = list;
+            }
+            else if (this.conditionTrueParse.length == 0) {
+                this.conditionTrueParse = list;
+            }
+            else if (this.conditionFalseParse.length == 0) {
+                this.conditionFalseParse = list;
+            }
+            return [];
+        }
+        list.push(c);
+        return list;
+    }
+    validateExpression(obj, critm, record, item, oneCondition) {
+        let result = null;
+        var candidates = oneCondition.filter(x => x instanceof OperatorParse_1.OperatorParser);
+        if (candidates.length == 0) {
+            if (oneCondition.length == 1) {
+                var evaluated = oneCondition[0].Evaluate(obj, critm, record, item);
+                if (typeof evaluated == "boolean") {
+                    result = evaluated;
+                    //goto evaluatedCond;
+                }
+                /*if (evaluated == null&&(obj.currentInvoiceMode==InvoiceObj.InvoiceMode.GetInit|| obj.currentInvoiceMode == InvoiceObj.InvoiceMode.GetInitNFE))
+                {
+                    result = false; goto evaluatedCond;
+                }*/
+                if (evaluated == null && item.TypeNET == "bool") {
+                    result = false; //goto evaluatedCond;
+                }
+                if (typeof evaluated == "string") {
+                    var temp = evaluated;
+                    if (temp.trim().toLowerCase() == "false") {
+                        result = false;
+                        //goto evaluatedCond;
+                    }
+                    if (temp.trim().toLowerCase() == "true") {
+                        result = true;
+                        //goto evaluatedCond;
+                    }
+                    //goto evaluatedCond;
+                }
+            }
+        }
+        else {
+            let leftSideL = [];
+            let rightSideL = [];
+            var current = leftSideL;
+            for (let i = 0; i < oneCondition.length; i++) {
+                if (oneCondition[i] instanceof OperatorParse_1.OperatorParser) {
+                    current = rightSideL;
+                    continue;
+                }
+                current.push(oneCondition[i]);
+            }
+            var leftEval = ExpresionLogicService_1.ExpresionLogicService.ConcatValues(leftSideL, obj, critm, record, item);
+            var rightEval = ExpresionLogicService_1.ExpresionLogicService.ConcatValues(rightSideL, obj, critm, record, item);
+            if (leftEval == null || rightEval == null) {
+                switch (candidates[0].Expression) {
+                    case "=":
+                    case "==":
+                        {
+                            result = leftEval == rightEval;
+                            return this.evaluateCondition(result);
+                        }
+                    case "!=":
+                    case "<>":
+                        {
+                            result = leftEval != rightEval;
+                            return this.evaluateCondition(result);
+                        }
+                }
+            }
+            if (typeof leftEval == "number" && typeof rightEval == "number") {
+                var leftSide = leftEval;
+                var rightSide = rightEval;
+                switch (candidates[0].Expression) {
+                    case ">=":
+                        {
+                            result = leftSide >= rightSide;
+                            return this.evaluateCondition(result);
+                        }
+                    case "<=":
+                        {
+                            result = leftSide <= rightSide;
+                            return this.evaluateCondition(result);
+                        }
+                    case "!=":
+                    case "<>":
+                        {
+                            result = leftSide != rightSide;
+                            return this.evaluateCondition(result);
+                        }
+                    case "<":
+                        {
+                            result = leftSide < rightSide;
+                            return this.evaluateCondition(result);
+                        }
+                    case ">":
+                        {
+                            result = leftSide > rightSide;
+                            return this.evaluateCondition(result);
+                        }
+                    case "==":
+                    case "=":
+                        {
+                            result = leftSide == rightSide;
+                            return this.evaluateCondition(result);
+                        }
+                    default:
+                        {
+                            throw "Operator " + candidates[0].Expression + " not supported on condition decimal and decimal";
+                        }
+                }
+            }
+            if (typeof leftEval == "string" && typeof rightEval == "string") {
+                if ((leftEval.toLowerCase() == "false" || leftEval.toLowerCase() == "true") &&
+                    (rightEval.toLowerCase() == "false" || rightEval.toLowerCase() == "true")) {
+                    let lSide = Boolean(leftEval);
+                    let rside = Boolean(rightEval);
+                    switch (candidates[0].Expression) {
+                        case "!=":
+                        case "<>":
+                            {
+                                result = lSide != rside;
+                                return this.evaluateCondition(result);
+                            }
+                        case "==":
+                        case "=":
+                            {
+                                result = lSide == rside;
+                                return this.evaluateCondition(result);
+                            }
+                        default:
+                            {
+                                throw "Operator " + candidates[0].Expression + " not supported on condition bool and bool";
+                            }
+                    }
+                }
+                result = this.StringCompare(leftEval, rightEval, candidates[0].Expression);
+                return this.evaluateCondition(result);
+            }
+            if (leftEval instanceof Date && typeof rightEval == "string") {
+                var leftSideD = BaseParse_1.BaseParse.getIsoDateTime(leftEval);
+                result = this.StringCompare(leftSideD, rightEval, candidates[0].Expression);
+                return this.evaluateCondition(result);
+            }
+            if (typeof leftEval == "string" && rightEval instanceof Date) {
+                var rightSideD = BaseParse_1.BaseParse.getIsoDateTime(rightEval);
+                result = this.StringCompare(leftEval, rightSideD, candidates[0].Expression);
+                return this.evaluateCondition(result);
+            }
+            if (leftEval instanceof Date && rightEval instanceof Date) {
+                switch (candidates[0].Expression) {
+                    case ">=":
+                        {
+                            result = leftEval >= rightEval;
+                            return this.evaluateCondition(result);
+                        }
+                    case "<=":
+                        {
+                            result = leftEval <= rightEval;
+                            return this.evaluateCondition(result);
+                        }
+                    case "!=":
+                    case "<>":
+                        {
+                            result = leftEval != rightEval;
+                            return this.evaluateCondition(result);
+                        }
+                    case "<":
+                        {
+                            result = leftEval < rightEval;
+                            return this.evaluateCondition(result);
+                        }
+                    case ">":
+                        {
+                            result = leftEval > rightEval;
+                            return this.evaluateCondition(result);
+                        }
+                    case "==":
+                    case "=":
+                        {
+                            result = leftEval == rightEval;
+                            return this.evaluateCondition(result);
+                        }
+                    default:
+                        {
+                            throw "Operator " + candidates[0].Expression + " not supported on condition string";
+                        }
+                }
+            }
+        }
+        return this.evaluateCondition(result);
+    }
+    evaluateCondition(result) {
+        if (result == null) {
+            throw "Can't eval " + this.Expression + "!";
+        }
+        return result;
+    }
+    StringCompare(leftSide, rightSide, oper) {
+        switch (oper) {
+            case "!=":
+            case "<>":
+                {
+                    return leftSide != rightSide;
+                }
+            case "==":
+            case "=":
+                {
+                    return leftSide == rightSide;
+                }
+            default:
+                {
+                    throw "Operator " + oper + " not supported on condition string";
+                }
+        }
+    }
+}
+exports.IfParse = IfParse;