js-gei 1.0.0

package/Evaluator/ExpresionLogicService.ts

@@ -0,0 +1,669 @@
+
+import { SchemaStruct } from '../Interfaces/SchemaStruct';
+import { InvoiceObj } from '../Structure/InvoiceObj';
+import { RecordSingle } from '../Structure/RecordSingle';
+import { BaseParse } from './Parser/BaseParse';
+import { OnlyExpressionParse } from './Parser/OnlyExpressionParse';
+import { LiteralValueParse } from './Parser/LiteralValueParse';
+import { ValueFromObjParse } from './Parser/ValueFromObjParse';
+import { CommaParser } from './Parser/CommaParser';
+import { OperatorParser } from './Parser/OperatorParse';
+import { LogicalOperatorParser } from './Parser/LogicalOperatorParse';
+import { AddLeadZerosParse } from "./Parser/AddLeadZerosParse";
+import { AppearParse } from "./Parser/AppearParse";
+import { IfParse } from "./Parser/IfParse";
+import { SumParse } from "./Parser/SumParse";
+
+import { CalcDateParse } from "./Parser/CalcDateParse";
+import { UpperLowerParse } from "./Parser/UpperLoverParse";
+import { INListParser } from "./Parser/InListParse";
+import { InDetailParse } from "./Parser/InDetailParse";
+import { StartsParse } from "./Parser/StartsParse";
+import { SubstrParse } from "./Parser/SubstrParse";
+import { CountParse } from "./Parser/CountParse";
+import { ExistParser } from "./Parser/ExistParse";
+import { EmptyParse } from "./Parser/EmptyParse";
+import { ConcatParse } from "./Parser/ConcatParse";
+import { CheckParse } from "./Parser/CheckParse";
+import { TrimParse } from "./Parser/TrimParse";
+import { ValueParse } from './Parser/ValueParse';
+
+export class ExpresionLogicService {
+
+  constructor() { }
+  public static _suportedFunctions:any =
+{
+    "sum(":SumParse,
+    "if(":IfParse,
+    "addleadzeros(":AddLeadZerosParse,
+    "appear(":AppearParse,
+    "calcdate(":CalcDateParse,
+    "upper(":UpperLowerParse,
+    "lower(":UpperLowerParse,
+    "inlist(":INListParser,
+    "notinlist(":INListParser,
+    "indetail(":InDetailParse,
+    "notindetail(":InDetailParse,
+    "starts(":StartsParse,
+    "substr(":SubstrParse,
+    "count(":CountParse,
+    "check(":CheckParse,
+    "concat(":ConcatParse,
+    "empty(":EmptyParse,
+    "exists(":ExistParser,
+    "notexists(":ExistParser,
+    "trim(":TrimParse,
+    "value(":ValueParse,
+};
+  public static  GetExpressions(
+    valueExpression:string,  parrent:BaseParse|null):BaseParse[]|null
+  {
+
+      let _exprtessions:any = [];
+      var cursor = 0;
+      var currentLit = "";
+      while (valueExpression.length > 0)
+      {
+          if (!this.HasFunctionInside(valueExpression) && valueExpression.indexOf(",")==-1)
+          {
+              _exprtessions.push(new 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(currentLit));
+                  currentLit = "";
+              }
+              _exprtessions.push(new 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(currentLit));
+                  currentLit = "";
+              }
+              var indexNext = valueExpression.substring(3).indexOf("%") + 1;
+              _exprtessions.push(new ValueFromObjParse(valueExpression.substring(2, indexNext+3), true));
+              valueExpression = valueExpression.substring(indexNext + 3);
+              continue;
+          }
+
+          if (valueExpression.substring(0, 1) == "%")
+          {
+            if (currentLit!="")
+              {
+                  _exprtessions.push(new LiteralValueParse(currentLit));
+                  currentLit = "";
+              }
+              var indexNext = valueExpression.substring(1).indexOf("%") + 1;
+              _exprtessions.push(new 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(currentLit));
+                  currentLit = "";
+              }
+              _exprtessions.push(new CommaParser(valueExpression.substring(0, 1),""));
+              if (1 < valueExpression.length)
+              {
+                  valueExpression = valueExpression.substring(1);
+              }
+              else
+              {
+                  valueExpression = "";
+              }
+
+              continue;
+          }
+          var br = false;
+          BaseParse.operators.forEach(o=>{
+            if (valueExpression.startsWith(o))
+              {
+                if (currentLit!="")
+                  {
+                      _exprtessions.push(new OnlyExpressionParse(currentLit)); currentLit = "";
+                  }
+                  _exprtessions.push(new OperatorParser(valueExpression.substring(0, o.length)));
+                  valueExpression = valueExpression.substring(o.length);
+                  br = true; return;
+              }
+          })
+
+          if (br)
+          {
+              continue;
+          }
+          for(let j=0;j<BaseParse.logicaloperators.length;j++)
+          {
+            let o=BaseParse.logicaloperators[j];
+            if (valueExpression.startsWith(o))
+              {
+                if (currentLit!="")
+                  {
+                      _exprtessions.push(new OnlyExpressionParse(currentLit)); currentLit = "";
+                  }
+                  _exprtessions.push(new 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(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(currentLit));
+           currentLit = "";
+      }
+      return _exprtessions;
+  }
+  public static  HasFunctionInside( valueExp:string|null):boolean
+  {
+      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;
+  }
+  public static  StartsWithFunction( valueExp:string):boolean
+  {
+    const valueExpTemp=valueExp.toLowerCase();
+    var founded=false;
+    Object.keys(ExpresionLogicService._suportedFunctions).forEach(element => {
+      if(valueExpTemp.startsWith(element))
+      {
+        founded= true;
+        return;
+      }
+    });
+
+      return founded;
+  }
+  public static FindEnd( expresion:string):number
+  {
+      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;
+  }
+  public static ConcatValues( t:BaseParse[],  obj:InvoiceObj,  critm:RecordSingle, record:any,  item:SchemaStruct)
+  {
+      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:SchemaStruct,value:any):any
+    {
+      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:string,item:SchemaStruct,  obj:InvoiceObj,  citm:RecordSingle, record:any, tryEvaluate:boolean ,  init:boolean):any
+  {
+    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;
+
+    }
+  }
+
+  public static  ParseExpressionAndReturnValue( valueExp:string|null,obj:InvoiceObj,item:SchemaStruct,citm:RecordSingle,level:number):string|null
+  {
+    if(valueExp==null)
+    {
+      return null;
+    }
+    let returned:BaseParse[]|null = null;
+    try
+    {
+        returned = ExpresionLogicService.GetExpressions(valueExp, null);
+
+    }
+    catch (ec)
+    {
+      debugger
+    }
+    if (returned == null)
+    {
+        return null;
+    }
+    if (!(returned[0] instanceof OnlyExpressionParse))
+    {
+
+    }
+    var record = citm.Record;
+    let sb:string = "";
+    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.getIsoDate(value);
+            }
+            else if (item.TypeDDD == "DateTime")
+            {
+                return BaseParse.getIsoDateTime(value);
+            }
+        }
+        else if (typeof value == "number")
+        {
+            return value.toString();
+        }
+        return value.toString(); ;
+    }
+    return ExpresionLogicService.ConcatValues(returned, obj, citm, record, item)?.toString();
+
+
+  }
+
+
+  public static  ValueExpresion( item:SchemaStruct,  valueExpression:string,  obj:InvoiceObj,  citm:RecordSingle)
+  {
+    if (valueExpression == "null")
+    {
+        return null;
+    }
+    if (!valueExpression.startsWith("%") && !valueExpression.endsWith("%"))
+    {
+        return valueExpression;
+    }
+
+    let tabelAndKey:string = "";
+    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 == citm?.Parent?.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;
+
+  }
+  private static  ReturnFromObject(record:any, key:string ):any
+  {
+    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()}
+  }
+}