js-gei 1.0.0

package/Evaluator/Parser/AddLeadZerosParse.ts

@@ -0,0 +1,70 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+import { CommaParser } from "./CommaParser";
+import { ExpresionLogicService } from "../ExpresionLogicService";
+
+
+export class AddLeadZerosParse extends BaseParse {
+
+    public  value:BaseParse[]=[];
+    public numOfZeros: BaseParse[]=[]
+    public constructor( valueExpression:string,funname:string)
+    {
+      super(valueExpression,funname);
+      var dd = ExpresionLogicService.GetExpressions(this.Expression, this);
+      if(dd==null)
+      {
+        return;
+      }
+      var candidates = dd.filter(x=>x instanceof CommaParser)
+      if(candidates.length==0)
+      {
+          throw "No comma in AddLeadZeros function";
+      }
+      let list:BaseParse[] = [];
+  
+      dd.forEach(d=>{
+        if(d instanceof CommaParser)
+          {
+              this.value = list; list=[];
+          }
+          else
+          {
+            list.push(d);
+          }
+  
+      })
+  
+      this.numOfZeros = list;
+    }
+  
+    public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+      var valueEval = ExpresionLogicService.ConcatValues(this.value, obj, critm, record, item);
+      var numOfZerosEval = ExpresionLogicService.ConcatValues(this.numOfZeros, obj, critm, record, item);
+      if(valueEval==null|| numOfZerosEval == null)
+      {
+          return null;
+      }
+      let length:number = -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;
+    }
+  }

package/Evaluator/Parser/AppearParse.ts

@@ -0,0 +1,67 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+
+
+export class AppearParse extends BaseParse {
+
+  public  Table:string;
+  public FieldName:string="";
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    var split=this.Expression.split("." );
+    this.Table = split[0];
+    if(split.length > 1)
+    {
+      this.FieldName = split[1];
+    }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    var tablelevel = obj.FindTableLevel(this.Table);
+    if(tablelevel == null)
+    {
+        return false;
+    }
+    let list:RecordSingle[]=[];;
+    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 ;
+
+  }
+}

package/Evaluator/Parser/BaseParse.ts

@@ -0,0 +1,93 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+
+
+export abstract class BaseParse {
+  public  static operators:string[] =[ "<=", ">=", "!=", "<>", "==", "<", ">", "=" ];
+public static logicaloperators:string[] = [ "&&", "||" ];
+
+public  Expression:string="";
+public  FunName:string|null= null;
+
+public  constructor(expression:string,  funName:string|null)
+{
+    if (funName==null||funName=="")
+    {
+        this.Expression = expression;
+
+    }
+    else
+    {
+      this.Expression = expression.substring(funName.length, expression.length-1);
+      this.FunName = funName;
+    }
+
+
+}
+public abstract Evaluate(obj:InvoiceObj,  critm:RecordSingle, record:any,  item:SchemaStruct):any;
+public static getIsoDateWithTime(date: Date, time: string): string | null {
+    if (date == null) {
+      return null;
+    }
+    if (typeof date == "string") {
+      return date;
+    }
+    return date.getFullYear() + "-" +
+      this.formatToTwoNumber(date.getMonth() + 1) + "-" +
+      this.formatToTwoNumber(date.getDate()) + time;
+  }
+  public static getIsoDateTime(date: 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());
+  }
+  public static parseDateTime(datetime: string) {
+    return new Date(datetime);
+  }
+  public static parseDate(datetime: string) {
+    return new Date(datetime);
+  }
+  public static formatToTwoNumber(num: number) {
+    if (num < 10) {
+      return "0" + num;
+    }
+    return num.toString();
+  }
+  public static getIsoDate(date: Date): string | null {
+    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";
+  }
+  public static roundUp(num: number, r: number) {
+    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;
+
+
+  }
+}
+

package/Evaluator/Parser/CalcDateParse.ts

@@ -0,0 +1,73 @@
+
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+import { OnlyExpressionParse } from "./OnlyExpressionParse";
+
+export class CalcDateParse extends BaseParse {
+  public  value :string="";
+  public offset:string="";
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    var split = this.Expression.split("," );
+    if (split.length == 2)
+    {
+        this.value = split[0];
+        this.offset = split[1];
+
+
+    }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    if(this.value==""||this.offset=="")
+      {
+          return null;
+      }
+      var valueEval = new OnlyExpressionParse(this.value);
+    var valueE = valueEval.Evaluate(obj, critm,  record, item);
+
+    var offsetEval = new OnlyExpressionParse(this.offset);
+    var offsetE = offsetEval.Evaluate(obj, critm,  record, item);
+    var  datetimeValue:Date|null = null;
+    var offsetInt:number|null = 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.getIsoDate(datetimeValue);
+        }
+        else if (item.TypeDDD == "DateTime")
+        {
+          return BaseParse.getIsoDateTime(datetimeValue);
+        }
+    }
+    else
+    {
+        debugger
+    }
+    return this.Expression;
+  }
+}
+
+

package/Evaluator/Parser/CheckParse.ts

@@ -0,0 +1,99 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+
+
+export class CheckParse extends BaseParse {
+  public  Detail :string="";
+  public Exp:string="";
+  public Parameter:string="";
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    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];
+    }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    var list:RecordSingle[] = [];
+        if (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(this.Parameter?.toLocaleLowerCase() =="one")
+        {
+            return false;
+        }
+        else if(this.Parameter?.toLocaleLowerCase() =="all")
+        {
+            return trueCounter == list.length;
+        }
+        else
+        {
+            throw "Check prameter isn't valid!Valid:One,All.Provided:"+this.Parameter;
+        }
+
+  }
+}
+

package/Evaluator/Parser/CommaParser.ts

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

package/Evaluator/Parser/ConcatParse.ts

@@ -0,0 +1,34 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+import { CommaParser } from "./CommaParser";
+import { ExpresionLogicService } from "../ExpresionLogicService";
+
+export class ConcatParse extends BaseParse {
+  public sections:BaseParse[]=[];
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    this.sections=ExpresionLogicService.GetExpressions(this.Expression, this)??[];
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    var builder = "";
+    for(var i=0;i<this.sections.length;i++)
+    {
+        let section:BaseParse=this.sections[i];
+        if(section instanceof CommaParser)
+        {
+          continue;
+        }
+        var value = section.Evaluate(obj, critm, record, item);
+        if(value != null)
+        {
+            builder+=value;
+        }
+    }
+
+        return builder;
+  }
+}

package/Evaluator/Parser/CountParse.ts

@@ -0,0 +1,26 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+
+export class CountParse extends BaseParse {
+  public Table:string=";"
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    this.Table=this.Expression;
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    if(this.Table=="")
+    {
+      throw "Function count don't have defined table!";
+    }
+    var tableLevel = obj.FindTableLevel(this.Table);
+        if (tableLevel == null)
+        {
+            return -1;
+        }
+        return tableLevel.Records?.Records.length;
+  }
+}

package/Evaluator/Parser/EmptyParse.ts

@@ -0,0 +1,41 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+import { OnlyExpressionParse } from "./OnlyExpressionParse";
+import { ExpresionLogicService } from "../ExpresionLogicService";
+
+export class EmptyParse extends BaseParse {
+  public valueExp:OnlyExpressionParse|null=null
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    var dd = ExpresionLogicService.GetExpressions(this.Expression, this);
+    if(dd==null)
+    {
+      return;
+    }
+    if(dd.length==1&&dd[0] instanceof OnlyExpressionParse)
+    {
+        this.valueExp = dd[0] as OnlyExpressionParse;
+    }
+    else
+    {
+        throw "Expression '"+this.Expression+"' isn't ValueFromObjParse";
+    }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    var value = this.valueExp?.Evaluate(obj, critm, record, item);
+    if(value == null)
+    {
+        return true;
+    }
+    if(typeof value =="string")
+    {
+        var v=value as string;
+        return v == ""||v.trim()=="";
+    }
+    return false;
+  }
+}

package/Evaluator/Parser/ExistParse.ts

@@ -0,0 +1,69 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+
+
+export class ExistParser extends BaseParse {
+  public Table:string="";
+  public FieldName:string="";
+  public Negate:boolean=false;
+
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    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 (this.Table?.startsWith("!"))
+        {
+            this.Table = this.Table.substring(1);
+            this.Negate = true;
+        }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    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:boolean=false;;
+    if(tableLevel==obj.rootLevel)
+    {
+        var rec = tableLevel.Record;
+        exist = 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!"+critm?.Parent?.Tablename;
+        }
+        exist = records.Records[index].Record[this.FieldName]!=null;
+    }
+    if(this.Negate)
+    {
+        exist = !exist;
+    }
+    return exist;
+  }
+}