js-gei 1.1.0 → 1.1.2

package/src/Evaluator/Parser/CodeListCheckParse.ts

@@ -0,0 +1,50 @@
+import type { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+import { ValueFromObjParse } from "./ValueFromObjParse";
+
+export class CodeListCheckParse extends BaseParse {
+     public Table:string = ""
+     public Field:string = ""
+     public ValueExpress:string = ""
+ 
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    var split = this.Expression.split(",");
+    this.Table = split[0];
+    this.Field = split[1];
+    this.ValueExpress = split[2];
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    var express = new ValueFromObjParse(this.ValueExpress,false);
+    var val = express.Evaluate(obj, critm, record, item);
+   
+    if(val==null)
+    {
+        return null;
+    }
+     
+    try
+    {
+        if(obj.CodeListCache==null||obj.CodeListCache[this.Table]==null)
+        {
+            throw new Error("CodeListCheck parse - CodeList "+this.Table+" not found in cache!");
+        }
+        var tableLevel=obj.CodeListCache[this.Table];
+        var candidates=tableLevel.filter((rec:any)=>rec[this.Field]?.toString()==val?.toString());
+        if(candidates.length>0)
+        {
+            return true;
+        }
+    
+    }
+    catch (ex)
+    {
+        throw new Error("CodeListCheck parse - Error obtaining record from CodeList! Reason: " + ex);
+    }
+    return false;
+  }
+}

package/src/Evaluator/Parser/CommaParser.ts

@@ -1,5 +1,5 @@
 
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";
@@ -11,7 +11,7 @@ export class CommaParser extends BaseParse {
     super(valueExpression,funname);
   }
 
-  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+  public Evaluate(_obj: InvoiceObj, _critm: RecordSingle, _record: any, _item: SchemaStruct):any {
     return this.Expression;
   }
 }

package/src/Evaluator/Parser/ConcatParse.ts

@@ -1,4 +1,4 @@
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";

package/src/Evaluator/Parser/CountParse.ts

@@ -1,4 +1,4 @@
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";
@@ -11,7 +11,7 @@ export class CountParse extends BaseParse {
     this.Table=this.Expression;
   }
 
-  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+  public Evaluate(obj: InvoiceObj, _critm: RecordSingle, _record: any, _item: SchemaStruct):any {
     if(this.Table=="")
     {
       throw "Function count don't have defined table!";

package/src/Evaluator/Parser/DateTimeFormatParse.ts

@@ -1,4 +1,5 @@
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { format } from 'date-fns';
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { ExpresionLogicService } from "../ExpresionLogicService";
@@ -75,7 +76,7 @@ export class DateTimeFormat extends BaseParse {
             }
             formatDateTimeEval= formatEval.ToString();
         }
-        //todo
-        return null;
+
+        return format(sourceDateTime, formatDateTimeEval);
   }
 }

package/src/Evaluator/Parser/EmptyParse.ts

@@ -1,4 +1,4 @@
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";
@@ -6,10 +6,15 @@ import { OnlyExpressionParse } from "./OnlyExpressionParse";
 import { ExpresionLogicService } from "../ExpresionLogicService";
 
 export class EmptyParse extends BaseParse {
-  public valueExp:OnlyExpressionParse|null=null
+  public valueExp:OnlyExpressionParse|null=null;
+  private Negate:boolean=false;
   public constructor( valueExpression:string,funname:string)
   {
     super(valueExpression,funname);
+    if(funname.toLowerCase()=="nonempty(")
+    {
+      this.Negate=true;
+    }
     var dd = ExpresionLogicService.GetExpressions(this.Expression, this);
     if(dd==null)
     {
@@ -27,15 +32,25 @@ export class EmptyParse extends BaseParse {
 
   public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
     var value = this.valueExp?.Evaluate(obj, critm, record, item);
+    let result:boolean=false;
     if(value == null)
     {
-        return true;
+        result=true;
     }
-    if(typeof value =="string")
+    else
     {
-        var v=value as string;
-        return v == ""||v.trim()=="";
+      if(typeof value =="string")
+      {
+          var v=value as string;
+          result= v == ""||v.trim()=="";
+          
+      }
+      else if(typeof value =="number")
+      {
+          var vN=value as number;
+          result= vN == 0;
+      }
     }
-    return false;
+    return this.Negate ? !result : result;
   }
 }

package/src/Evaluator/Parser/ExistParse.ts

@@ -1,4 +1,4 @@
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";
@@ -30,7 +30,7 @@ export class ExistParser extends BaseParse {
         }
   }
 
-  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, _record: any, _item: SchemaStruct):any {
     if(this.Table==null)
     {
       throw "No table"

package/src/Evaluator/Parser/ExtractParse.ts

@@ -0,0 +1,89 @@
+import type{ 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 ExtractParse extends BaseParse {
+  private valueParse:BaseParse[]|null = null;
+ private regexParse:BaseParse[]|null = null;
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    let temp = ExpresionLogicService.GetExpressions(this.Expression, this);
+    if(temp==null)
+    {
+      throw new Error(`Error parsing Sum function: ${this.Expression}`);
+    }
+            var currentParse:BaseParse[]=[];
+            for(let i=0;i<temp.length;i++)
+            {
+                let t = temp[i];
+                if (t instanceof CommaParser)
+                {
+                    if(this.valueParse==null)
+                    {
+                        this.valueParse = currentParse;
+                        currentParse=[];
+                    }
+                    else if(this.regexParse==null)
+                    {
+                        throw new Error(`Clean function has too many parameters: ${this.Expression}`);
+                    }
+                    continue;
+                }
+                currentParse.push(t);
+            }
+            if (currentParse.length > 0)
+            {
+                if (this.valueParse == null)
+                {
+                    this.valueParse = currentParse;
+                }
+                else
+                {
+                    this.regexParse = currentParse;
+                }
+                currentParse = [];
+            }
+            if(this.regexParse==null||this.valueParse==null)
+            {
+              throw new Error(`Clean function has few parameters: ${this.Expression}`);
+            }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+
+    if(this.valueParse==null)
+    {
+      return;
+    }
+   let value:any = null;
+    if(this.valueParse.length==1)
+    {
+        value = this.valueParse[0].Evaluate(obj, critm,  record, item);
+    }
+    else
+    {
+        value=ExpresionLogicService.ConcatValues(this.valueParse, obj, critm, record, item);
+    }
+    if(this.regexParse==null)
+    {
+       return value;
+    }
+    var regex=ExpresionLogicService.ConcatValues(this.regexParse, obj, critm, record, item)?.ToString();
+
+    if(regex==null)
+    {
+      return value;
+    }
+    regex=regex+"/g";
+    var temp=value.match("/"+regex+"/g", "");
+    if(temp!=null&&temp.length>0)
+    {
+        return temp[0];
+    }
+    return null;
+  }
+}

package/src/Evaluator/Parser/FromCodeListParse.ts

@@ -0,0 +1,109 @@
+import { table } from "node:console";
+import type { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { ExpresionLogicService } from "../ExpresionLogicService";
+import { BaseParse } from "./BaseParse";
+import { CommaParser } from "./CommaParser";
+
+export class FromCodeListParse extends BaseParse {
+     private  codeListTableParse:BaseParse[]|null= null;
+    private codeListFieldParse:BaseParse[]|null = null;
+    private objectValueExpresionParse:BaseParse[]|null = null;
+    private codeListDestFieldParse:BaseParse[]|null = null;
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    var dd = ExpresionLogicService.GetExpressions(this.Expression, this);
+    var currentList:BaseParse[] = [];
+    for (let i = 0; i < (dd?.length??0); i++)
+    {
+        const d= dd![i];
+        if (d instanceof CommaParser)
+        {
+            if (this.codeListTableParse == null)
+            {
+                this.codeListTableParse = currentList;
+                currentList = [];
+                continue;
+            }
+            else if (this.codeListFieldParse == null)
+            {
+                this.codeListFieldParse = currentList;
+                currentList = [];
+                continue;
+            }
+            else if (this.objectValueExpresionParse == null)
+            {
+                this.objectValueExpresionParse = currentList;
+                currentList = []    ;
+                continue;
+            }
+            else
+            {
+                throw Error("FromCodeList parse - Too many parameters!");
+            }
+        }
+        currentList.push(d);
+    }
+    if (currentList.length > 0)
+    {
+        if (this.objectValueExpresionParse != null && this.codeListDestFieldParse == null)
+        {
+            this.codeListDestFieldParse = currentList;
+        }
+        else
+        {
+            throw new Error("FromCodeList parse - Too few parameters!");
+        }
+
+    }
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+   var codeListTable = ExpresionLogicService.ConcatValues(this.codeListTableParse, obj, critm, record, item);
+if (codeListTable?.toString()==null)
+{
+    throw Error("FromCodeList parse - CodeList table is null or empty!");
+}
+var codeListField = ExpresionLogicService.ConcatValues(this.codeListFieldParse, obj, critm, record, item);
+if (codeListField?.toString()==null)
+{
+    throw new Error("FromCodeList parse - codeList field is null or empty!");
+}
+var objectValueExpresion = ExpresionLogicService.ConcatValues(this.objectValueExpresionParse, obj, critm, record, item);
+if (objectValueExpresion?.toString()==null)
+{
+    // throw new Exception("FromCodeList parse - objectValueExpresion is null or empty!");
+}
+var codeListDestField = ExpresionLogicService.ConcatValues(this.codeListDestFieldParse, obj, critm, record, item);
+if (codeListDestField?.toString()==null)
+{
+    throw new Error("FromCodeList parse - codeListDestField is null or empty!");
+}
+
+try
+{
+    if(obj.CodeListCache==null||obj.CodeListCache[codeListTable.toString()]==null)
+    {
+        throw new Error("FromCodeList parse - CodeList "+codeListTable.toString()+" not found in cache!");
+    }
+    var tableLevel=obj.CodeListCache[codeListTable.toString()];
+    var candidates=tableLevel.filter((rec:any)=>rec[codeListField.toString()]?.toString()==objectValueExpresion?.toString());
+    if(candidates.length==0)
+    {
+        throw Error("FromCodeList parse - No records found in CodeList "+codeListTable.toString()+" for field "+codeListField.toString()+" and value "+objectValueExpresion?.toString());
+    }
+    if(candidates.length>1)
+    {
+        throw Error("FromCodeList parse - Multiple records found in CodeList "+codeListTable.toString()+" for field "+codeListField.toString()+" and value "+objectValueExpresion?.toString());
+    }
+    return candidates[0][codeListDestField.toString()]?.toString()??null;
+   
+}
+catch (ex)
+{
+    throw new Error("FromCodeList parse - Error obtaining record from CodeList! Reason: " + ex);
+}
+  }
+}

package/src/Evaluator/Parser/IfParse.ts

@@ -1,4 +1,4 @@
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";
@@ -57,7 +57,7 @@ export class IfParse extends BaseParse {
         condition.push(c.Expression);
         continue;
       }
-
+        result.push(c);
     }
     if(result.length>0)
     {
@@ -351,6 +351,7 @@ export class IfParse extends BaseParse {
   private evaluateCondition(result:boolean|null):boolean{
     if(result==null)
     {
+        debugger
       throw "Can't eval "+this.Expression+"!";
     }
     return result;

package/src/Evaluator/Parser/InDetailParse.ts

@@ -1,4 +1,4 @@
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";
@@ -54,23 +54,21 @@ export class InDetailParse extends BaseParse {
       }
   }
 
-  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
-   // var tableLevel = obj.FindTableLevel(this.Table, critm.Parent, critm);todo
+  public Evaluate(obj: InvoiceObj, _critm: RecordSingle, _record: any, _item: SchemaStruct):any {
+  
     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++)
+               for(var i=0;i<array.length;i++)
                {
-                 let single=tableLevel.Records.Records[i];
+                 let single=array[i];
                  if (single.Record[this.Field] == null)
                   {
                       continue;
@@ -86,9 +84,9 @@ export class InDetailParse extends BaseParse {
             }
             else
             {
-              for(var i=0;i<tableLevel.Records.Records.length;i++)
+              for(var i=0;i<array.length;i++)
                 {
-                  let single=tableLevel.Records.Records[i];
+                  let single=array[i];
                   if (single.Record[this.Field] == null)
                    {
                        continue;

package/src/Evaluator/Parser/InListParse.ts

@@ -1,4 +1,4 @@
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";

package/src/Evaluator/Parser/LenParse.ts

@@ -0,0 +1,39 @@
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { ExpresionLogicService } from "../ExpresionLogicService";
+import { BaseParse } from "./BaseParse";
+import { ValueFromObjParse } from "./ValueFromObjParse";
+
+export class LenParse 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?.length == 1)
+        {
+            var value = express[0].Evaluate(obj, critm, record, item);
+            
+            if (typeof(value)=="string")
+            {
+                return value.length;
+            }
+            throw Error("LEN function accepts only string parameters.");
+        }
+        else
+        {
+            var value = ExpresionLogicService.ConcatValues(express, obj, critm,record, item);
+        
+            if (typeof(value)=="string")
+            {
+                return value.length;
+            }
+            throw Error("LEN function accepts only string parameters.");
+        }
+    }
+}

package/src/Evaluator/Parser/LiteralValueParse.ts

@@ -1,4 +1,4 @@
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";
@@ -12,7 +12,7 @@ export class LiteralValueParse extends BaseParse {
 
   }
 
-  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+  public Evaluate(_obj: InvoiceObj, _critm: RecordSingle, _record: any, _item: SchemaStruct):any {
     if(this.Expression=="null")
       {
           return null;

package/src/Evaluator/Parser/LogicalOperatorParse.ts

@@ -1,4 +1,4 @@
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";
@@ -10,7 +10,7 @@ export class LogicalOperatorParser extends BaseParse {
       super(valueExpression,null);
     }
   
-    public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    public Evaluate(_obj: InvoiceObj, _critm: RecordSingle, _record: any, _item: SchemaStruct):any {
       return this.Expression;
     }
   }

package/src/Evaluator/Parser/MonthParse.ts

@@ -0,0 +1,41 @@
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+import { ValueFromObjParse } from "./ValueFromObjParse";
+
+export class MonthParse extends BaseParse {
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+     
+    var express = new ValueFromObjParse(this.Expression,false);
+    var value=express.Evaluate(obj,critm,record,item);
+   
+    var  temp:Date|null=null;
+    if (value instanceof Date)
+    {
+        temp = value;
+    }
+    else if (typeof(value)=="string")
+    {
+        
+        temp = new Date(value.toString());
+    }
+    if(temp==null)
+    {
+        throw new Error("Can't convert "+value+" isn't datetime!");
+    }
+    return this.GetMonth(temp.getMonth() + 1);
+  }
+  private GetMonth(value:number):string{
+    if(value>=10)
+    {
+        return value.toString();
+    }
+    return "0"+value.toString();
+  }
+}

package/src/Evaluator/Parser/NoEvalParse.ts

@@ -0,0 +1,17 @@
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { BaseParse } from "./BaseParse";
+
+
+export class NoEvalParse 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/src/Evaluator/Parser/OnlyExpressionParse.ts

@@ -1,5 +1,5 @@
 
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";

package/src/Evaluator/Parser/OperatorParse.ts

@@ -1,5 +1,5 @@
 
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";
@@ -11,7 +11,7 @@ export class OperatorParser extends BaseParse {
     super(valueExpression,null);
   }
 
-  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+  public Evaluate(_obj: InvoiceObj, _critm: RecordSingle, _record: any, _item: SchemaStruct):any {
     return this.Expression;
   }
 }

package/src/Evaluator/Parser/RegistryCheckParse.ts

@@ -0,0 +1,51 @@
+import type{ SchemaStruct } from "../../Interfaces/SchemaStruct";
+import { InvoiceObj } from "../../Structure/InvoiceObj";
+import { RecordSingle } from "../../Structure/RecordSingle";
+import { ExpresionLogicService } from "../ExpresionLogicService";
+import { BaseParse } from "./BaseParse";
+
+
+export class RegistryCheckParse extends BaseParse {
+  public Table:string="";
+  public FieldName:string="";
+  public Negate:boolean=false;
+
+  public constructor( valueExpression:string,funname:string)
+  {
+    super(valueExpression,funname);
+    
+  }
+
+  public Evaluate(obj: InvoiceObj, critm: RecordSingle, record: any, item: SchemaStruct):any {
+    if(item.ValidValuesRegistry==null)
+{
+    throw ("SchemaStruct "+item.Alias+" don't have valid values registry defined.");
+}
+var expressionString = this.Expression;
+if(expressionString==null||expressionString=="")
+{
+    expressionString = "%"+item.TableName+"."+item.FieldName+"%";
+}
+var express = ExpresionLogicService.GetExpressions(expressionString, this);
+var value = ExpresionLogicService.ConcatValues(express, obj, critm,  record, item);
+if(value==null)
+{
+    return null;
+}
+var candidate=item.ValidValuesRegistry.filter((x: { Name: string;Code:string; }) => 
+  x.Code.toLowerCase().includes(value.toLowerCase())
+);
+if(candidate!=null&&candidate.length>0)
+{
+    return candidate[0].Name;
+}
+candidate = candidate=item.ValidValuesRegistry.filter((x: { Name: string;Code:string; }) => 
+  x.Name.toLowerCase().includes(value.toLowerCase()));
+if (candidate != null&&candidate.length>0   )
+{
+    return candidate[0].Code;
+}
+//or let previus value?
+return null;
+  }
+}

package/src/Evaluator/Parser/StartsParse.ts

@@ -1,4 +1,4 @@
-import { SchemaStruct } from "../../Interfaces/SchemaStruct";
+import type { SchemaStruct } from "../../Interfaces/SchemaStruct";
 import { InvoiceObj } from "../../Structure/InvoiceObj";
 import { RecordSingle } from "../../Structure/RecordSingle";
 import { BaseParse } from "./BaseParse";