js-gei 1.0.0

package/Evaluator/Parser/OperatorParse.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 OperatorParser 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/StartsParse.ts

@@ -0,0 +1,36 @@
+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 StartsParse extends BaseParse {
+
+  public starts:OnlyExpressionParse|null=null;
+  public value:OnlyExpressionParse|null=null;
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    var split = this.Expression.split(",");
+    if (split.length == 2)
+    {
+        this.starts = new OnlyExpressionParse(split[0]);
+        this.value = new OnlyExpressionParse(split[1]);
+    }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    var startsEvaluate = this.starts?.Evaluate(obj,critm,record, item);
+    var valueEvaluate = this.value?.Evaluate(obj, critm, record, item);
+
+    if(startsEvaluate==null|| valueEvaluate==null)
+    {
+        return false;
+    }
+    var evaluated:string = startsEvaluate.ToString();
+    var evaluatedValue:string = valueEvaluate.ToString();
+
+    var result = evaluatedValue.startsWith(evaluated);
+    return result;
+  }
+}

package/Evaluator/Parser/SubstrParse.ts

@@ -0,0 +1,110 @@
+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 SubstrParse extends BaseParse {
+
+  public starts:BaseParse[]=[];
+  public value:BaseParse[]=[];
+  public length:BaseParse[]=[];
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    var dd = ExpresionLogicService.GetExpressions(this.Expression, this);
+    var current:BaseParse[] =[];
+    if(dd==null)
+    {
+      return;
+    }
+    for(let i=0;i<dd.length;i++)
+    {
+      current=this.logic(current, dd[i]);
+    }
+    this.logic(current, null);
+
+    if (this.value.length==0 || this.starts.length==0 || this.length.length==0)
+    {
+        throw "Can't parse if stategment "+valueExpression+"!";
+    }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    var valueEval = ExpresionLogicService.ConcatValues(this.value, obj, critm, record, item);
+    if(valueEval == null)
+    {
+        return null;
+    }
+    var val = valueEval.ToString();
+    let str = -1;
+    var startEval=ExpresionLogicService.ConcatValues(this.starts, obj, critm,  record, item);
+    if(typeof startEval =="number")
+    {
+        str = startEval;
+    }
+    else if(typeof startEval =="string")
+    {
+
+      str = parseInt(startEval);
+
+    }
+    if(str==-1)
+    {
+        throw "Substr start index can't be parsed! Value: "+startEval+"!";
+    }
+    else
+    {
+        str--;
+    }
+    let len = -1;
+    var lengthEval = ExpresionLogicService.ConcatValues(this.length, obj, critm, record, item);
+    if (typeof lengthEval =="number")
+    {
+        len = lengthEval;
+    }
+    else if (lengthEval =="string")
+    {
+        len=parseInt(lengthEval);
+    }
+    if (len == -1)
+    {
+        throw "Substr length index can't be parsed! Value: "+lengthEval+"!";
+    }
+
+    if (val.Length<=str)
+    {
+        return null;
+    }
+    var tem = val.substring(str);
+    if(tem.Length<=len)
+    {
+        return tem;
+    }
+    return tem.substring(0, len);
+  }
+  private logic(list:BaseParse[],  c:BaseParse|null):BaseParse[]
+{
+    if (c == null || c instanceof CommaParser)
+    {
+        if (this.value.length==0)
+        {
+            this.value = list;
+        }
+        else if (this.starts.length==0)
+        {
+            this.starts = list;
+        }
+        else if (this.length.length==0)
+        {
+            this.length = list;
+        }
+
+        return [];
+
+    }
+    list.push(c);
+    return list;
+}
+}

package/Evaluator/Parser/SumParse.ts

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

package/Evaluator/Parser/TrimParse.ts

@@ -0,0 +1,30 @@
+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 TrimParse extends BaseParse {
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    var express = ExpresionLogicService.GetExpressions(this.Expression,this);
+    if(express==null)
+    {
+      return null;
+    }
+  if (express.length == 1)
+  {
+      var value = express[0].Evaluate(obj, critm, record, item);
+      if (typeof value == "string")
+      {
+          return value.trim();
+      }
+      return value;
+  }
+  return express.length;
+  }
+}

package/Evaluator/Parser/UpperLoverParse.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 { ExpresionLogicService } from "../ExpresionLogicService";
+
+export class UpperLowerParse extends BaseParse {
+
+  public lower:boolean=true;
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    if(funname.toLowerCase()=="upper(")
+    {
+      this.lower=false;
+    }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    var express = ExpresionLogicService.GetExpressions(this.Expression,this);
+    if(express==null)
+    {
+      return null;
+    }
+   var value=ExpresionLogicService.ConcatValues(express,obj,critm,record,item);
+    if(value==null)
+    {
+      return null;
+
+    }
+    if(typeof value =="string")
+    {
+      if(this.lower)
+      {
+        return value.toLowerCase();
+      }
+      return value.toUpperCase();
+    }
+    return value;
+  }
+}

package/Evaluator/Parser/ValueFromObjParse.ts

@@ -0,0 +1,37 @@
+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 ValueFromObjParse extends BaseParse {
+
+  private Numeric:boolean=false;
+  public constructor(valueExpression: string, numeric: boolean) {
+    super(valueExpression, null);
+    this.Numeric=numeric;
+
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct): any {
+    var value =ExpresionLogicService.ValueExpresion(item, this.Expression, obj,critm);
+    if(value==null)
+    {
+        return null;
+    }
+    if(this.Numeric)
+    {
+
+        if(typeof value == "string")
+        {
+            return parseFloat(value);
+        }
+        if(typeof value =="number")
+        {
+            return value;
+        }
+        throw "Value is "+typeof value+" isn't number type!";
+    }
+    return value;
+  }
+}

package/Evaluator/Parser/ValueParse.ts

@@ -0,0 +1,61 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+
+export class ValueParse extends BaseParse {
+
+  private Table: string = "";
+  private FieldName: string = "";
+  private Position: string = "";
+  public constructor(valueExpression: string, numeric: boolean) {
+    super(valueExpression, null);
+    var outerSplit = this.Expression.split(",");
+    var position = "first";
+    if (outerSplit.length == 2) {
+      position = outerSplit[1];
+    }
+    var split = outerSplit[0].split(".");
+    this.Table = split[0];
+    this.FieldName = split[1];
+    this.Position = position;
+
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct): any {
+    var tablelevel = obj.FindTableLevel(this.Table);
+    if (tablelevel == null) {
+      return null;
+    }
+    let validRecord: any = null;
+    if (tablelevel.Record != null) {
+      validRecord = tablelevel.Record;
+    }
+    else if (tablelevel.Records != null) {
+      var rec = tablelevel.Records;
+      if (rec.Records.length == 0) {
+        return null;
+      }
+      if (this.Position.toLowerCase() == "first") {
+        validRecord = rec.Records[0].Record;
+      }
+      else if (this.Position.toLowerCase() == "first") {
+        validRecord = rec.Records[rec.Records.length - 1].Record;
+      }
+    }
+    if (validRecord == null) {
+      throw "Can't find valid record for " + this.Table + "!";
+    }
+    if (validRecord[this.FieldName] == null) {
+      throw "Value not defined for fieldname " + this.FieldName + "!";
+    }
+    var value = validRecord[this.FieldName];
+    if (value == null) {
+      return null;
+    }
+    if (typeof value == "number") {
+      return value;
+    }
+    return value.ToString();;
+  }
+}

package/HelperSessionStorage.ts

@@ -0,0 +1,13 @@
+class HelperSessionStorage{
+    static hasKey(key:string)
+    {
+      return this.getFromSessionStorage(key)!=null;
+    }
+    static getFromSessionStorage(key:string) {
+     return localStorage.getItem(key);
+  
+    }
+    static setToSessionStorage(key:string,value:any) {
+      localStorage.setItem(key,JSON.stringify( value));
+    }
+  }

package/Interfaces/SchemaStruct.ts

@@ -0,0 +1,28 @@
+export interface SchemaStruct {
+    TableName:string|null;
+    Version:string|null;
+    FieldName:string;
+    Type:string;
+    TypeDDD:string;
+    TypeNET:string;
+    CountryCode:string|null;
+    CreateNewInit:string|null;
+  
+    SourceTableField:string|null;
+    Source:string|null;
+  
+    GetValueFrom:string|null;
+  
+    Pattern:string|null;
+  
+    ValueExpression:string|null;
+  
+    CalcPhase:number|null;
+  
+    RoundTo:number|null;
+  
+    EvalOnlyIfEmpty:boolean;
+  
+  
+  }
+