js-gei 1.0.0

package/dist/Evaluator/ExpresionLogicService.js

@@ -0,0 +1,505 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpresionLogicService = void 0;
+const BaseParse_1 = require("./Parser/BaseParse");
+const OnlyExpressionParse_1 = require("./Parser/OnlyExpressionParse");
+const LiteralValueParse_1 = require("./Parser/LiteralValueParse");
+const ValueFromObjParse_1 = require("./Parser/ValueFromObjParse");
+const CommaParser_1 = require("./Parser/CommaParser");
+const OperatorParse_1 = require("./Parser/OperatorParse");
+const LogicalOperatorParse_1 = require("./Parser/LogicalOperatorParse");
+const AddLeadZerosParse_1 = require("./Parser/AddLeadZerosParse");
+const AppearParse_1 = require("./Parser/AppearParse");
+const IfParse_1 = require("./Parser/IfParse");
+const SumParse_1 = require("./Parser/SumParse");
+const CalcDateParse_1 = require("./Parser/CalcDateParse");
+const UpperLoverParse_1 = require("./Parser/UpperLoverParse");
+const InListParse_1 = require("./Parser/InListParse");
+const InDetailParse_1 = require("./Parser/InDetailParse");
+const StartsParse_1 = require("./Parser/StartsParse");
+const SubstrParse_1 = require("./Parser/SubstrParse");
+const CountParse_1 = require("./Parser/CountParse");
+const ExistParse_1 = require("./Parser/ExistParse");
+const EmptyParse_1 = require("./Parser/EmptyParse");
+const ConcatParse_1 = require("./Parser/ConcatParse");
+const CheckParse_1 = require("./Parser/CheckParse");
+const TrimParse_1 = require("./Parser/TrimParse");
+const ValueParse_1 = require("./Parser/ValueParse");
+class ExpresionLogicService {
+    constructor() { }
+    static GetExpressions(valueExpression, parrent) {
+        let _exprtessions = [];
+        var cursor = 0;
+        var currentLit = "";
+        while (valueExpression.length > 0) {
+            if (!this.HasFunctionInside(valueExpression) && valueExpression.indexOf(",") == -1) {
+                _exprtessions.push(new OnlyExpressionParse_1.OnlyExpressionParse(valueExpression));
+                break;
+            }
+            if (valueExpression.substring(cursor, cursor + 1) == "(") {
+                var index = this.FindEnd(valueExpression);
+                if (index == -1) {
+                    throw "Unbalanced brackets!!!! Expression:" + valueExpression;
+                }
+                if (currentLit != "") {
+                    _exprtessions.push(new LiteralValueParse_1.LiteralValueParse(currentLit));
+                    currentLit = "";
+                }
+                _exprtessions.push(new OnlyExpressionParse_1.OnlyExpressionParse(valueExpression.substring(0, index + 1)));
+                if (index < valueExpression.length) {
+                    valueExpression = valueExpression.substring(index + 1);
+                }
+                else {
+                    valueExpression = "";
+                }
+                continue;
+            }
+            if (valueExpression.startsWith("N.%")) {
+                if (currentLit != "") {
+                    _exprtessions.push(new LiteralValueParse_1.LiteralValueParse(currentLit));
+                    currentLit = "";
+                }
+                var indexNext = valueExpression.substring(3).indexOf("%") + 1;
+                _exprtessions.push(new ValueFromObjParse_1.ValueFromObjParse(valueExpression.substring(2, indexNext + 3), true));
+                valueExpression = valueExpression.substring(indexNext + 3);
+                continue;
+            }
+            if (valueExpression.substring(0, 1) == "%") {
+                if (currentLit != "") {
+                    _exprtessions.push(new LiteralValueParse_1.LiteralValueParse(currentLit));
+                    currentLit = "";
+                }
+                var indexNext = valueExpression.substring(1).indexOf("%") + 1;
+                _exprtessions.push(new ValueFromObjParse_1.ValueFromObjParse(valueExpression.substring(0, indexNext + 1), false));
+                valueExpression = valueExpression.substring(indexNext + 1);
+                continue;
+            }
+            if (valueExpression.substring(cursor, cursor + 1) == ",") {
+                if (currentLit != "") {
+                    _exprtessions.push(new OnlyExpressionParse_1.OnlyExpressionParse(currentLit));
+                    currentLit = "";
+                }
+                _exprtessions.push(new CommaParser_1.CommaParser(valueExpression.substring(0, 1), ""));
+                if (1 < valueExpression.length) {
+                    valueExpression = valueExpression.substring(1);
+                }
+                else {
+                    valueExpression = "";
+                }
+                continue;
+            }
+            var br = false;
+            BaseParse_1.BaseParse.operators.forEach(o => {
+                if (valueExpression.startsWith(o)) {
+                    if (currentLit != "") {
+                        _exprtessions.push(new OnlyExpressionParse_1.OnlyExpressionParse(currentLit));
+                        currentLit = "";
+                    }
+                    _exprtessions.push(new OperatorParse_1.OperatorParser(valueExpression.substring(0, o.length)));
+                    valueExpression = valueExpression.substring(o.length);
+                    br = true;
+                    return;
+                }
+            });
+            if (br) {
+                continue;
+            }
+            for (let j = 0; j < BaseParse_1.BaseParse.logicaloperators.length; j++) {
+                let o = BaseParse_1.BaseParse.logicaloperators[j];
+                if (valueExpression.startsWith(o)) {
+                    if (currentLit != "") {
+                        _exprtessions.push(new OnlyExpressionParse_1.OnlyExpressionParse(currentLit));
+                        currentLit = "";
+                    }
+                    _exprtessions.push(new LogicalOperatorParse_1.LogicalOperatorParser(valueExpression.substring(0, o.length)));
+                    valueExpression = valueExpression.substring(o.length);
+                    br = true;
+                    break;
+                }
+            }
+            if (br) {
+                continue;
+            }
+            var foundFun = false;
+            let valueExpTemp = valueExpression.toLowerCase();
+            var supKeys = Object.keys(ExpresionLogicService._suportedFunctions);
+            for (let j = 0; j < supKeys.length; j++) {
+                let key = supKeys[j];
+                if (valueExpTemp.startsWith(key)) {
+                    if (currentLit != "") {
+                        _exprtessions.push(new OnlyExpressionParse_1.OnlyExpressionParse(currentLit));
+                        currentLit = "";
+                    }
+                    var index = this.FindEnd(valueExpression);
+                    if (index == -1) {
+                        throw "Unbalanced brackets!!!! Expression:" + valueExpression;
+                    }
+                    let instance = Reflect.construct(ExpresionLogicService._suportedFunctions[key], [valueExpression.substring(0, index + 1), key]);
+                    _exprtessions.push(instance);
+                    if (index < valueExpression.length) {
+                        valueExpression = valueExpression.substring(index + 1);
+                    }
+                    else {
+                        valueExpression = "";
+                    }
+                    foundFun = true;
+                    break;
+                }
+            }
+            if (foundFun) {
+                continue;
+            }
+            currentLit += valueExpression.substring(0, 1);
+            valueExpression = valueExpression.substring(1);
+        }
+        if (currentLit != "") {
+            _exprtessions.push(new OnlyExpressionParse_1.OnlyExpressionParse(currentLit));
+            currentLit = "";
+        }
+        return _exprtessions;
+    }
+    static HasFunctionInside(valueExp) {
+        if (valueExp == null || valueExp == "") {
+            return false;
+        }
+        var founded = false;
+        const valueExpTemp = valueExp.toLowerCase();
+        Object.keys(ExpresionLogicService._suportedFunctions).forEach(element => {
+            if (valueExpTemp.indexOf(element) != -1) {
+                founded = true;
+                return;
+            }
+        });
+        return founded;
+    }
+    static StartsWithFunction(valueExp) {
+        const valueExpTemp = valueExp.toLowerCase();
+        var founded = false;
+        Object.keys(ExpresionLogicService._suportedFunctions).forEach(element => {
+            if (valueExpTemp.startsWith(element)) {
+                founded = true;
+                return;
+            }
+        });
+        return founded;
+    }
+    static FindEnd(expresion) {
+        var bC = 0;
+        var bO = 0;
+        for (var i = 0; i < expresion.length; i++) {
+            if (expresion.substring(i, i + 1) == "(") {
+                bO++;
+            }
+            else if (expresion.substring(i, i + 1) == ")") {
+                bC++;
+            }
+            if (bO > 0 && bO == bC) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    static ConcatValues(t, obj, critm, record, item) {
+        if (t.length == 1) {
+            return t[0].Evaluate(obj, critm, record, item);
+        }
+        let sb = "";
+        for (let i = 0; i < t.length; i++) {
+            let value = t[i].Evaluate(obj, critm, record, item);
+            if (typeof value == "number") {
+                sb += value.toString();
+            }
+            else if (value instanceof Date) {
+                sb += value.toISOString();
+            }
+            else {
+                sb += value;
+            }
+        }
+        return sb;
+    }
+    static CastToTypeNet(item, value) {
+        let outptValue = null;
+        if (value == null) {
+            return null;
+        }
+        switch (item.TypeNET) {
+            case "decimal":
+                {
+                    outptValue = parseFloat(value);
+                    break;
+                }
+            case "int":
+                {
+                    outptValue = parseInt(value);
+                    break;
+                    break;
+                }
+            case "bool":
+                {
+                    if (this.toString().toLowerCase() == "true") {
+                        outptValue == true;
+                    }
+                    else if (this.toString().toLowerCase() == "false") {
+                        outptValue == false;
+                    }
+                    else {
+                        outptValue = value;
+                    }
+                    break;
+                }
+            default:
+                {
+                    outptValue = value;
+                    break;
+                }
+        }
+        return outptValue;
+    }
+    static ParseAndFillExpression(valueExp, item, obj, citm, record, tryEvaluate, init) {
+        var value = ExpresionLogicService.ParseExpressionAndReturnValue(valueExp, obj, item, citm, 0);
+        console.log(item.FieldName + " " + item.ValueExpression + " " + value);
+        if (value != null) {
+            if ((tryEvaluate || item.TypeNET == "decimal" || item.TypeNET == "int")) {
+                try {
+                    if (value == "0/0") {
+                        citm.Record[item.FieldName] = 0;
+                        return 0;
+                    }
+                    if (value == "*(-1)") {
+                        return null;
+                    }
+                    var ret = eval(value);
+                    console.log(item.FieldName + " " + item.ValueExpression + " RET: " + value);
+                    return ret;
+                }
+                catch (ex) {
+                    if (init) {
+                        console.log(item.FieldName + " " + item.ValueExpression + " Err: " + 0);
+                        return 0;
+                    }
+                    else {
+                        var val = ExpresionLogicService.CastToTypeNet(item, value);
+                        console.log(item.FieldName + " " + item.ValueExpression + " Err: " + val);
+                        return val;
+                    }
+                }
+            }
+            else {
+                var val = ExpresionLogicService.CastToTypeNet(item, value);
+                console.log(item.FieldName + " " + item.ValueExpression + " Ret: " + val);
+                return val;
+            }
+        }
+        else {
+            console.log(item.FieldName + " " + item.ValueExpression + " Value: " + value);
+            return value;
+        }
+    }
+    static ParseExpressionAndReturnValue(valueExp, obj, item, citm, level) {
+        var _a;
+        if (valueExp == null) {
+            return null;
+        }
+        let returned = null;
+        try {
+            returned = ExpresionLogicService.GetExpressions(valueExp, null);
+        }
+        catch (ec) {
+            debugger;
+        }
+        if (returned == null) {
+            return null;
+        }
+        if (!(returned[0] instanceof OnlyExpressionParse_1.OnlyExpressionParse)) {
+        }
+        var record = citm.Record;
+        let sb = "";
+        if (returned.length == 1) {
+            var value = returned[0].Evaluate(obj, citm, record, item);
+            if (value == null) {
+                return null;
+            }
+            if (value instanceof Date) {
+                if (item.TypeDDD == "Date") {
+                    return BaseParse_1.BaseParse.getIsoDate(value);
+                }
+                else if (item.TypeDDD == "DateTime") {
+                    return BaseParse_1.BaseParse.getIsoDateTime(value);
+                }
+            }
+            else if (typeof value == "number") {
+                return value.toString();
+            }
+            return value.toString();
+            ;
+        }
+        return (_a = ExpresionLogicService.ConcatValues(returned, obj, citm, record, item)) === null || _a === void 0 ? void 0 : _a.toString();
+    }
+    static ValueExpresion(item, valueExpression, obj, citm) {
+        var _a;
+        if (valueExpression == "null") {
+            return null;
+        }
+        if (!valueExpression.startsWith("%") && !valueExpression.endsWith("%")) {
+            return valueExpression;
+        }
+        let tabelAndKey = "";
+        try {
+            tabelAndKey = valueExpression.substring(1, valueExpression.length - 1);
+        }
+        catch (ex) {
+            if (item != null) {
+                throw item.FieldName + " " + item.ValueExpression + " Expression:" + valueExpression + ex;
+            }
+            throw valueExpression + ex;
+        }
+        var split = tabelAndKey.split(".");
+        var prefix = split[0];
+        switch (prefix) {
+            /*case "V":
+                {
+                    return obj.GetValues(split[1]);
+                }
+    */
+            case "E":
+                {
+                    /*const tableName = split[1];
+                    const field = split[2];
+                    if (tableName.toLowerCase()=="eu_aorg")
+                    {
+                        return obj.service.aboutOrganisation[field];
+                    }
+                    else  if (tableName.toLowerCase()=="eu_scr")
+                    {
+                        return obj.service.aboutOrganisation["_countryRecord"][field];
+                    }
+                    else if (tableName.toLowerCase()=="session")
+                    {
+                      var startpath= obj.service.sessionInfo;
+    
+                        for (var i = 2; i < split.length; i++)
+                        {
+                            if(startpath[split[i]]!=null)
+                            {
+                              startpath=startpath[split[i]];
+                            }
+                            else
+                            {
+                              return null;
+                            }
+                        }
+                        return startpath;
+                    }
+    
+                    else
+                    {
+                        return "";
+                    }*/
+                }
+            case "S":
+                {
+                    /*if(obj.service.settings==null||obj.service.settings[split[1]]==null)
+                    {
+                      throw "Can't find setting for "+split[1];
+                    }
+                    var settingRecord=obj.service.settings[split[1]];
+                    return settingRecord["Value"];
+      */
+                }
+            default:
+                {
+                    if (split.length == 2) {
+                        var table = split[0];
+                        var key = split[1];
+                        if (table == ((_a = citm === null || citm === void 0 ? void 0 : citm.Parent) === null || _a === void 0 ? void 0 : _a.Tablename)) {
+                            var value1 = ExpresionLogicService.ReturnFromObject(citm.Record, key);
+                            if (value1["found"] === true) {
+                                return value1["return"];
+                            }
+                        }
+                        var tableLevel = obj.FindTableLevel(table);
+                        if (tableLevel != null) {
+                            if (tableLevel.Record != null) {
+                                var record = tableLevel.Record;
+                                var value1 = ExpresionLogicService.ReturnFromObject(record.Record, key);
+                                if (value1["found"] === true) {
+                                    return value1["return"];
+                                }
+                                if (value1["found"] === false && key == "InvIssueDate") {
+                                    return null;
+                                }
+                                if (value1["found"] === false && key.indexOf("__") != -1) {
+                                    var value2 = ExpresionLogicService.ReturnFromObject(record.Record, key);
+                                    if (value2["found"] === true) {
+                                        return value2["return"];
+                                    }
+                                }
+                                if (value2["found"] === false && key != "Mode") {
+                                    throw "Can't evaluate " + valueExpression + " key:" + item.FieldName + "";
+                                }
+                                return null;
+                            }
+                            else if (tableLevel.Records != null) {
+                                var records = tableLevel.Records;
+                                var candidates = records.Records.filter(x => x == citm);
+                                if (candidates.length > 0) {
+                                    var recordC = candidates[0];
+                                    var recordA = recordC.Record;
+                                    var value1 = ExpresionLogicService.ReturnFromObject(recordA, key);
+                                    if (value1["found"] === true) {
+                                        return value1["return"];
+                                    }
+                                    if (value1["found"] === false && key.indexOf("__") != -1) {
+                                        var value2 = ExpresionLogicService.ReturnFromObject(recordC.Record, key);
+                                        if (value2["found"] === true) {
+                                            return value2["return"];
+                                        }
+                                    }
+                                    throw "Can't evaluate " + valueExpression + " key:" + item.FieldName;
+                                }
+                            }
+                        }
+                    }
+                    break;
+                }
+        }
+        return null;
+    }
+    static ReturnFromObject(record, key) {
+        if (Object.keys(record).indexOf(key) == -1) {
+            return { "found": false, "return": null };
+        }
+        if (record[key] == null) {
+            return { "found": true, "return": null };
+        }
+        if (record[key] instanceof Date) {
+            return { "found": true, "return": record[key] };
+        }
+        return { "found": true, "return": record[key].toString() };
+    }
+}
+exports.ExpresionLogicService = ExpresionLogicService;
+ExpresionLogicService._suportedFunctions = {
+    "sum(": SumParse_1.SumParse,
+    "if(": IfParse_1.IfParse,
+    "addleadzeros(": AddLeadZerosParse_1.AddLeadZerosParse,
+    "appear(": AppearParse_1.AppearParse,
+    "calcdate(": CalcDateParse_1.CalcDateParse,
+    "upper(": UpperLoverParse_1.UpperLowerParse,
+    "lower(": UpperLoverParse_1.UpperLowerParse,
+    "inlist(": InListParse_1.INListParser,
+    "notinlist(": InListParse_1.INListParser,
+    "indetail(": InDetailParse_1.InDetailParse,
+    "notindetail(": InDetailParse_1.InDetailParse,
+    "starts(": StartsParse_1.StartsParse,
+    "substr(": SubstrParse_1.SubstrParse,
+    "count(": CountParse_1.CountParse,
+    "check(": CheckParse_1.CheckParse,
+    "concat(": ConcatParse_1.ConcatParse,
+    "empty(": EmptyParse_1.EmptyParse,
+    "exists(": ExistParse_1.ExistParser,
+    "notexists(": ExistParse_1.ExistParser,
+    "trim(": TrimParse_1.TrimParse,
+    "value(": ValueParse_1.ValueParse,
+};

package/dist/Evaluator/Parser/AddLeadZerosParse.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddLeadZerosParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+const CommaParser_1 = require("./CommaParser");
+const ExpresionLogicService_1 = require("../ExpresionLogicService");
+class AddLeadZerosParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        super(valueExpression, funname);
+        this.value = [];
+        this.numOfZeros = [];
+        var dd = ExpresionLogicService_1.ExpresionLogicService.GetExpressions(this.Expression, this);
+        if (dd == null) {
+            return;
+        }
+        var candidates = dd.filter(x => x instanceof CommaParser_1.CommaParser);
+        if (candidates.length == 0) {
+            throw "No comma in AddLeadZeros function";
+        }
+        let list = [];
+        dd.forEach(d => {
+            if (d instanceof CommaParser_1.CommaParser) {
+                this.value = list;
+                list = [];
+            }
+            else {
+                list.push(d);
+            }
+        });
+        this.numOfZeros = list;
+    }
+    Evaluate(obj, critm, record, item) {
+        var valueEval = ExpresionLogicService_1.ExpresionLogicService.ConcatValues(this.value, obj, critm, record, item);
+        var numOfZerosEval = ExpresionLogicService_1.ExpresionLogicService.ConcatValues(this.numOfZeros, obj, critm, record, item);
+        if (valueEval == null || numOfZerosEval == null) {
+            return null;
+        }
+        let length = -1;
+        if (typeof numOfZerosEval == "number") {
+            length = numOfZerosEval;
+        }
+        else if (typeof numOfZerosEval == "string") {
+            length = parseInt(numOfZerosEval);
+        }
+        if (length == -1) {
+            throw "AddLeadZeros function can't be evaluated! expression: " + this.Expression;
+        }
+        var str = valueEval.ToString();
+        while (str.Length < length) {
+            str = "0" + str;
+        }
+        return str;
+    }
+}
+exports.AddLeadZerosParse = AddLeadZerosParse;

package/dist/Evaluator/Parser/AppearParse.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppearParse = void 0;
+const BaseParse_1 = require("./BaseParse");
+class AppearParse extends BaseParse_1.BaseParse {
+    constructor(valueExpression, funname) {
+        super(valueExpression, funname);
+        this.FieldName = "";
+        var split = this.Expression.split(".");
+        this.Table = split[0];
+        if (split.length > 1) {
+            this.FieldName = split[1];
+        }
+    }
+    Evaluate(obj, critm, record, item) {
+        var tablelevel = obj.FindTableLevel(this.Table);
+        if (tablelevel == null) {
+            return false;
+        }
+        let list = [];
+        ;
+        if (tablelevel.Record != null) {
+            list.push(tablelevel.Record);
+        }
+        else if (tablelevel.Records != null) {
+            var rec = tablelevel.Records;
+            if (rec.Records.length == 0) {
+                return false;
+            }
+            rec.Records.forEach(element => {
+                list.push(element);
+            });
+        }
+        if (list.length == 0) {
+            return false;
+        }
+        if (this.FieldName == "") {
+            return true;
+        }
+        for (var i = 0; i < list.length; i++) {
+            if (list[i].Record[this.FieldName] != null) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.AppearParse = AppearParse;

package/dist/Evaluator/Parser/BaseParse.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseParse = void 0;
+class BaseParse {
+    constructor(expression, funName) {
+        this.Expression = "";
+        this.FunName = null;
+        if (funName == null || funName == "") {
+            this.Expression = expression;
+        }
+        else {
+            this.Expression = expression.substring(funName.length, expression.length - 1);
+            this.FunName = funName;
+        }
+    }
+    static getIsoDateWithTime(date, time) {
+        if (date == null) {
+            return null;
+        }
+        if (typeof date == "string") {
+            return date;
+        }
+        return date.getFullYear() + "-" +
+            this.formatToTwoNumber(date.getMonth() + 1) + "-" +
+            this.formatToTwoNumber(date.getDate()) + time;
+    }
+    static getIsoDateTime(date) {
+        if (date == null) {
+            return null;
+        }
+        if (typeof (date) == "string") {
+            return date;
+        }
+        return date.getFullYear() + "-" +
+            this.formatToTwoNumber(date.getMonth() + 1) + "-" +
+            this.formatToTwoNumber(date.getDate()) + "T" +
+            this.formatToTwoNumber(date.getHours()) + ":" +
+            this.formatToTwoNumber(date.getMinutes()) + ":" +
+            this.formatToTwoNumber(date.getSeconds());
+    }
+    static parseDateTime(datetime) {
+        return new Date(datetime);
+    }
+    static parseDate(datetime) {
+        return new Date(datetime);
+    }
+    static formatToTwoNumber(num) {
+        if (num < 10) {
+            return "0" + num;
+        }
+        return num.toString();
+    }
+    static getIsoDate(date) {
+        if (date == null) {
+            return null;
+        }
+        if (typeof date == "string") {
+            return date;
+        }
+        return date.getFullYear() + "-" +
+            this.formatToTwoNumber(date.getMonth() + 1) + "-" +
+            this.formatToTwoNumber(date.getDate()) + "T00:00:00";
+    }
+    static roundUp(num, r) {
+        let negative = false;
+        if (num < 0) {
+            negative = true;
+        }
+        else {
+            negative = false;
+        }
+        ;
+        if (negative) {
+            num = num - 10 ** -13;
+        }
+        else {
+            num = num + 10 ** -13;
+        }
+        num = Math.abs(num);
+        let temp1 = Math.round(num * Math.pow(10, r)) / (Math.pow(10, r));
+        if (negative) {
+            return (-1) * temp1;
+        }
+        return temp1;
+    }
+}
+exports.BaseParse = BaseParse;
+BaseParse.operators = ["<=", ">=", "!=", "<>", "==", "<", ">", "="];
+BaseParse.logicaloperators = ["&&", "||"];