js-gei 1.0.0

package/Evaluator/Parser/IfParse.ts

@@ -0,0 +1,388 @@
+import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+import { CommaParser } from "./CommaParser";
+import { LogicalOperatorParser } from "./LogicalOperatorParse";
+import { OperatorParser } from "./OperatorParse";
+import { ExpresionLogicService } from "../ExpresionLogicService";
+
+export class IfParse extends BaseParse {
+
+  public conditionParse:BaseParse[]=[];
+  public conditionTrueParse:BaseParse[]=[];
+  public conditionFalseParse:BaseParse[]=[];
+
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    var dd = ExpresionLogicService.GetExpressions(this.Expression, this);
+    if(dd==null)
+    {
+      return;
+    }
+        var current:BaseParse[]= [];
+        for(let i=0;i<dd.length;i++)
+        {
+          current=this.logic(current,dd[i]);
+        }
+
+        this.logic(current, null);
+        if(this.conditionParse.length==0|| this.conditionTrueParse.length==0|| this.conditionFalseParse.length==0)
+        {
+            throw "Can't parse if stategment "+valueExpression+"!";
+        }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    var candidates= this.conditionParse.filter(x => x instanceof LogicalOperatorParser);
+    var finishResult:boolean|null = false;
+    if(candidates.length==0)
+    {
+        finishResult = this.validateExpression(obj, critm, record, item, this.conditionParse);
+
+    }
+    else{
+    let condition:any[] = [];
+    let result:BaseParse[] = [];
+
+    for(let i=0;i< this.conditionParse.length;i++)
+    {
+      let c= this.conditionParse[i];
+      if(c instanceof LogicalOperatorParser)
+      {
+        var res = this.validateExpression(obj, critm, record, item, result);
+        result=[];
+        condition.push(res);
+        condition.push(c.Expression);
+        continue;
+      }
+
+    }
+    if(result.length>0)
+    {
+      var res = this.validateExpression(obj, critm, record, item, result);
+      condition.push(res);
+    }
+
+    finishResult = condition[0];
+    for(var i=1;i<condition.length;i+=2)
+    {
+        var c=condition[i];
+        switch(c)
+        {
+            case "&&":
+                {
+                    finishResult = finishResult && condition[i + 1];
+
+                    break;
+                }
+            case "||":
+                {
+                    finishResult = finishResult || condition[i + 1];
+
+                    break;
+                }
+        }
+    }
+  }
+    finish:
+    if (finishResult == true)
+    {
+
+        return ExpresionLogicService.ConcatValues(this.conditionTrueParse, obj, critm, record, item);
+    }
+
+    return ExpresionLogicService.ConcatValues(this.conditionFalseParse, obj, critm, record, item);
+
+  }
+  private  logic(list:BaseParse[], c:BaseParse|null)
+  {
+      if (c==null||c instanceof CommaParser)
+      {
+          if(this.conditionParse.length==0)
+          {
+            this.conditionParse = list;
+          }
+          else if (this.conditionTrueParse.length==0)
+          {
+            this.conditionTrueParse = list;
+          }
+          else if (this.conditionFalseParse.length==0)
+          {
+            this.conditionFalseParse = list;
+          }
+
+          return [];
+      }
+      list.push(c);
+      return list;
+  }
+  private  validateExpression( obj:InvoiceObj,  critm:RecordSingle, record:any,  item:SchemaStruct,  oneCondition:BaseParse[]):boolean|null
+  {
+
+      let result:boolean|null = null;
+      var candidates = oneCondition.filter(x => x instanceof OperatorParser);
+      if (candidates.length==0)
+      {
+          if (oneCondition.length == 1)
+          {
+              var evaluated = oneCondition[0].Evaluate(obj, critm, record, item);
+              if (typeof evaluated == "boolean")
+              {
+                  result = evaluated;
+                  //goto evaluatedCond;
+              }
+              /*if (evaluated == null&&(obj.currentInvoiceMode==InvoiceObj.InvoiceMode.GetInit|| obj.currentInvoiceMode == InvoiceObj.InvoiceMode.GetInitNFE))
+              {
+                  result = false; goto evaluatedCond;
+              }*/
+              if(evaluated == null &&item.TypeNET=="bool")
+              {
+                  result = false; //goto evaluatedCond;
+              }
+              if (typeof evaluated == "string")
+              {
+                  var temp = evaluated;
+                  if (temp.trim().toLowerCase()=="false")
+                  {
+                      result = false;
+                      //goto evaluatedCond;
+                  }
+                  if (temp.trim().toLowerCase()=="true")
+                  {
+                      result = true;
+                      //goto evaluatedCond;
+                  }
+                  //goto evaluatedCond;
+              }
+          }
+      }
+      else
+      {
+          let leftSideL:BaseParse[] = [];
+          let rightSideL:BaseParse[] = [];
+          var current = leftSideL;
+          for(let i=0;i<oneCondition.length;i++)
+          {
+            if(oneCondition[i] instanceof OperatorParser)
+            {
+              current = rightSideL; continue;
+            }
+            current.push(oneCondition[i]);
+          }
+
+          var leftEval = ExpresionLogicService.ConcatValues(leftSideL, obj, critm, record, item);
+          var rightEval = ExpresionLogicService.ConcatValues(rightSideL, obj, critm, record, item);
+          if (leftEval == null || rightEval == null)
+          {
+              switch (candidates[0].Expression)
+              {
+                  case "=":
+                  case "==":
+                      {
+                          result = leftEval == rightEval;
+                          return this.evaluateCondition(result);
+                      }
+                  case "!=":
+                  case "<>":
+                      {
+                          result = leftEval != rightEval;
+                          return this.evaluateCondition(result);
+                      }
+              }
+          }
+
+          if (typeof leftEval == "number" && typeof rightEval == "number")
+          {
+              var leftSide = leftEval;
+              var rightSide = rightEval;
+              switch (candidates[0].Expression)
+              {
+                  case ">=":
+                      {
+                          result = leftSide >= rightSide;
+                          return this.evaluateCondition(result);
+                      }
+                  case "<=":
+                      {
+                          result = leftSide <= rightSide;
+                          return this.evaluateCondition(result);
+                      }
+                  case "!=":
+                  case "<>":
+                      {
+                          result = leftSide != rightSide;
+                          return this.evaluateCondition(result);
+                      }
+                  case "<":
+                      {
+                          result = leftSide < rightSide;
+                          return this.evaluateCondition(result);
+                      }
+                  case ">":
+                      {
+                          result = leftSide > rightSide;
+                          return this.evaluateCondition(result);
+                      }
+                  case "==":
+                  case "=":
+                      {
+                          result = leftSide == rightSide;
+                          return this.evaluateCondition(result);
+                      }
+                  default:
+                      {
+                          throw "Operator "+candidates[0].Expression+" not supported on condition decimal and decimal";
+                      }
+              }
+          }
+          if (typeof leftEval =="string" && typeof rightEval =="string")
+          {
+
+              if((leftEval.toLowerCase()=="false"||leftEval.toLowerCase()=="true")&&
+                  (rightEval.toLowerCase()=="false"||rightEval.toLowerCase()=="true"))
+              {
+                  let lSide=Boolean(leftEval);
+                  let rside=Boolean(rightEval);
+                  switch (candidates[0].Expression)
+                  {
+
+                      case "!=":
+                      case "<>":
+                          {
+                              result = lSide != rside;
+                              return this.evaluateCondition(result);
+                          }
+
+                      case "==":
+                      case "=":
+                          {
+                              result = lSide == rside;
+                              return this.evaluateCondition(result);
+                          }
+                      default:
+                          {
+                              throw "Operator "+candidates[0].Expression+" not supported on condition bool and bool";
+                          }
+                  }
+              }
+
+
+
+
+
+
+
+
+
+              result = this.StringCompare(leftEval, rightEval, candidates[0].Expression);
+              return this.evaluateCondition(result);
+          }
+          if(leftEval instanceof Date &&typeof rightEval == "string")
+          {
+              var leftSideD = BaseParse.getIsoDateTime(leftEval);
+
+              result = this.StringCompare(leftSideD, rightEval, candidates[0].Expression);
+              return this.evaluateCondition(result);
+          }
+          if (typeof leftEval == "string" && rightEval instanceof Date)
+          {
+
+
+              var rightSideD = BaseParse.getIsoDateTime(rightEval);
+              result = this.StringCompare(leftEval, rightSideD, candidates[0].Expression);
+              return this.evaluateCondition(result);
+
+          }
+          if (leftEval instanceof Date && rightEval instanceof Date)
+          {
+
+              switch (candidates[0].Expression)
+              {
+
+                  case ">=":
+                      {
+                          result = leftEval >= rightEval;
+                          return this.evaluateCondition(result);
+                      }
+                  case "<=":
+                      {
+                          result = leftEval <= rightEval;
+                          return this.evaluateCondition(result);
+                      }
+                  case "!=":
+                  case "<>":
+                      {
+                          result = leftEval != rightEval;
+                          return this.evaluateCondition(result);
+                      }
+                  case "<":
+                      {
+                          result = leftEval < rightEval;
+                          return this.evaluateCondition(result);
+                      }
+                  case ">":
+                      {
+                          result = leftEval > rightEval;
+                          return this.evaluateCondition(result);
+                      }
+                  case "==":
+                  case "=":
+                      {
+                          result = leftEval == rightEval;
+                          return this.evaluateCondition(result);
+                      }
+                          default:
+                      {
+                          throw "Operator "+candidates[0].Expression+" not supported on condition string";
+                      }
+              }
+          }
+      }
+      return this.evaluateCondition(result);
+
+
+
+
+
+
+  }
+  private evaluateCondition(result:boolean|null):boolean{
+    if(result==null)
+    {
+      throw "Can't eval "+this.Expression+"!";
+    }
+    return result;
+  }
+  private  StringCompare(leftSide:string|null,rightSide:string|null,oper:string):boolean
+  {
+      switch (oper)
+      {
+
+          case "!=":
+          case "<>":
+              {
+                  return  leftSide != rightSide;
+
+              }
+
+          case "==":
+          case "=":
+              {
+                  return leftSide == rightSide;
+
+              }
+          default:
+              {
+                  throw "Operator "+oper+" not supported on condition string";
+              }
+      }
+  }
+}
+
+
+
+
+
+