js-gei 1.0.0

package/Evaluator/Parser/IfStategment.ts

@@ -0,0 +1,345 @@
+import { RecordSingle } from "../../Structure/RecordSingle";
+
+export class IfStategment {
+  private operators:string[] = [ "<=", ">=", "!=", "<>", "==", "<", ">","=" ];
+            public  LeftSide:string|null=null;;
+            public  RightSide:string|null=null;;
+            public  OneSide:string|null=null;;
+            public  Operator :string|null=null;;
+
+            // 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];
+            //     }
+            // }
+
+            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)
+                {
+                  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];
+                }
+            }
+
+            private CastToDecimal(side:string|null, citm:RecordSingle )
+            {
+
+                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;
+                }
+
+
+            }
+            private TryParse(exp:string|null)
+            {
+
+              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;
+              }
+            }
+            public Validate( citm:RecordSingle ):boolean
+            {
+                // if (this.OneSide!=null)
+                // {
+                //    var oneSide = citm.ValueExpresion(this.OneSide); ;
+                //     if (typeof oneSide === "boolean")
+                //     {
+                //       if(true)
+                //       {
+                //         // console.log("OneSide:"+oneSide);
+                //       }
+                //         return oneSide;
+                //     }
+
+                //     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 (
+                  (this.LeftSide?.startsWith("N.") || this.TryParse(citm.ValueExpresion(this.LeftSide))
+                    || this.LeftSide == "null") &&
+                    (this.RightSide?.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";
+
+
+            }
+}

package/Evaluator/Parser/InDetailParse.ts

@@ -0,0 +1,109 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+import { ExpresionLogicService } from "../ExpresionLogicService";
+
+export class InDetailParse extends BaseParse {
+
+  public Negate:boolean=false;
+  public TableAndField:string="";
+  public Table:string="";
+  public Field:string="";
+  public aviableValues:string[]=[];
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    if (this.Expression == null)
+      {
+          return;
+      }
+      if (!this.Expression.startsWith("("))
+      {
+          return;
+      }
+
+      var index = 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?.toLowerCase()=="notindetail(")
+      {
+          this.Negate = true;
+      }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+   // 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:any[] = 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:any[] = this.aviableValues.filter((x)=>x!=single.Record[this.Field].toString());
+                     if(cand.length>0)
+                     {
+                         return true;
+                     }
+                }
+                return false;
+
+            }
+        }
+
+  }
+}
+

package/Evaluator/Parser/InListParse.ts

@@ -0,0 +1,57 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+import { ValueFromObjParse } from "./ValueFromObjParse";
+import { ExpresionLogicService } from "../ExpresionLogicService";
+
+export class INListParser extends BaseParse {
+
+  public  Negate:boolean=false;
+  public  FieldSet:string=""
+
+  public  aviableValues:string[] = [];
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    if(this.Expression == null)
+      {
+          return;
+      }
+      if(!this.Expression.startsWith("("))
+      {
+          return;
+      }
+
+      var index = ExpresionLogicService.FindEnd(this.Expression);
+
+      var set = this.Expression.substring(1, index );
+
+      this.FieldSet = this.Expression.substring(index + 2);
+
+
+
+
+
+      this.aviableValues = set.split(",");
+      if(funname?.toLowerCase()=="notinlist(")
+      {
+        this.Negate = true;
+      }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    var val = new 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;
+  }
+}

package/Evaluator/Parser/LiteralValueParse.ts

@@ -0,0 +1,36 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+
+export class LiteralValueParse extends BaseParse {
+
+
+  public constructor( valueExpression:string)
+  {
+    super(valueExpression,null);
+
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    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;
+  }
+}

package/Evaluator/Parser/LogicalOperatorParse.ts

@@ -0,0 +1,16 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+
+export class LogicalOperatorParser extends BaseParse {
+
+    public constructor( valueExpression:string)
+    {
+      super(valueExpression,null);
+    }
+  
+    public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+      return this.Expression;
+    }
+  }

package/Evaluator/Parser/OnlyExpressionParse.ts

@@ -0,0 +1,137 @@
+
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+import { OperatorParser } from "./OperatorParse";
+import { LiteralValueParse } from "./LiteralValueParse";
+import { ValueFromObjParse } from "./ValueFromObjParse";
+import { ExpresionLogicService } from "../ExpresionLogicService";
+
+export class OnlyExpressionParse extends BaseParse {
+
+  private static  _literalValues:string[] = ["(", ")"] ;
+  public  subParse:BaseParse[] =[];
+  public constructor( valueExpression:string)
+  {
+    super(valueExpression,null);
+    var list:BaseParse[]=[];
+    var currentLit = "";
+   while(valueExpression.length>0)
+    {
+        var br = false;
+        for(let i=0;i<BaseParse.operators.length;i++)
+        {
+          let o=BaseParse.operators[i];
+          if (valueExpression.startsWith(o))
+            {
+                list.push(new 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.StartsWithFunction(valueExpression))
+        {
+            currentLit += valueExpression.substring(0, 1);
+            valueExpression = valueExpression.substring(1);
+            continue;
+        }
+
+        if(currentLit!="")
+        {
+            list.push(new LiteralValueParse(currentLit));
+            currentLit = "";
+        }
+        if (valueExpression.startsWith("N.%"))
+        {
+            var indexNext = valueExpression.substring(3).indexOf("%") + 1;
+            list.push(new 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(valueExpression.substring(0, indexNext + 1),false));
+            valueExpression = valueExpression.substring(indexNext + 1);
+            continue;
+        }
+        var foundFun = false;
+        const keys=Object.keys(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.FindEnd(valueExpression);
+                if (index == -1)
+                {
+                    throw "Unbalanced brackets!!!! Expression:"+valueExpression;
+                }
+                let instance=Reflect.construct(ExpresionLogicService._suportedFunctions[key],[valueExpression.substring(0, index + 1),key]);
+                list.push(instance as BaseParse );
+
+                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(val));
+                valueExpression = valueExpression.substring(1);
+                found = true;
+                break;
+            }
+        }
+
+        if(found)
+        {
+            continue;
+        }
+    }
+    if (currentLit!="")
+    {
+        list.push(new LiteralValueParse(currentLit));
+
+    }
+    this.subParse = list;
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    if(this.subParse.length==1)
+      {
+          return this.subParse[0].Evaluate(obj, critm, record, item);
+      }
+
+      return ExpresionLogicService.ConcatValues(this.subParse,obj,critm,record, item);
+  }
+}