js-gei 1.0.0

package/Structure/RecordSingle.ts

@@ -0,0 +1,1076 @@
+
+
+import { SchemaStruct } from "../Interfaces/SchemaStruct";
+import { IfStategment } from "../Evaluator/Parser/IfStategment";
+import { TableLevel } from "./TableLevel";
+
+import { BaseParse } from "../Evaluator/Parser/BaseParse";
+import { ExpresionLogicService } from "../Evaluator/ExpresionLogicService";
+
+export class RecordSingle {
+  public Details: TableLevel[] | null = null;
+  Parent: TableLevel | null;
+  TableObjectInfo: any;
+  Record: any;
+  byLevelSources: string[] = [
+    "MAPPEDINV",
+
+    "INVOICE",
+
+    "MAPPEDSYS",
+    "SYSTEM"
+
+  ];
+  public constructor(
+    obj: any, def: any, objectInfo: any, parent: TableLevel | null) {
+
+    this.Parent = parent;
+    if (this.Parent?.Tablename == "EU_Invoices") {
+      if(!obj["DeliveryType"])
+      {
+        obj["DeliveryType"] = "Domestic";
+      }
+      if(!obj["InvTotalVatAmountCC"] )
+      {
+        obj["InvTotalVatAmountCC"] = 0;
+      }
+      //obj["BuyerRegNum"] = "BuyerRegNumValue";
+     /* if(this.Parent.Root?.service.aboutOrganisation["InvDateOpen"]==true)
+      {
+        if(obj["InvIssueDate"]==null)
+        {
+          let date = new Date();
+          obj["InvIssueDate"]=BaseParse.getIsoDateTime(date);
+        }
+        else
+        {
+          obj["InvIssueDate"]=obj["InvIssueDate"]
+        }
+      }
+      else
+      {
+
+        if(obj["Step"]<35&&(this.Parent.Root?.service.aboutOrganisation["InvDateOpen"]==false||this.Parent.Root?.service.aboutOrganisation["InvDateOpen"]==null))
+        {
+          let date = new Date();
+          obj["InvIssueDate"]=BaseParse.getIsoDateTime(date);
+        }
+        else
+        {
+          obj["InvIssueDate"]=obj["InvIssueDate"]
+        }
+
+      }*/
+
+
+    }
+    else if (this.Parent?.Tablename == "EU_Invoices_Items") {
+      if (this.Parent.Root?.GetMasterRecord()?.Record.InvSaleTypeSC__Code == "Retailsale") {
+        // obj["ItemRetailPriceInp"] = obj["ItemRetailPrice"]??0.0;
+      }
+    }
+
+    const dateCurrent=new Date();
+    if (this.Parent?.Tablename != null) {
+      const tablePart = objectInfo[this.Parent?.Tablename];
+      if (tablePart != null) {
+        const keys = Object.keys(tablePart);
+        for (let i = 0; i < keys.length; i++) {
+          const key = keys[i];
+          if (key == "InvDueDate") {
+           if(obj[key]!=null)
+           {
+             obj[key]=BaseParse.parseDate(obj[key]);
+           }
+           else
+           {
+            let copy=new Date(dateCurrent.valueOf());
+            copy.setDate(copy.getDate() + 15);
+            obj["InvDueDate"] = copy;
+           }
+            continue;
+          }
+          if (tablePart[key].TypeDDD == "Date" || tablePart[key].TypeDDD == "DateTime") {
+            if (obj[key] == null&&[""].indexOf(key)!=-1) {
+              let copy=new Date(dateCurrent.valueOf());
+              obj[key] = copy;
+            }
+            else if (obj[key] != null){
+              if(tablePart[key].TypeDDD == "Date")
+              {
+                obj[key] = BaseParse.parseDate(obj[key]);
+              }
+              else if(tablePart[key].TypeDDD == "DateTime")
+              {
+                obj[key] = BaseParse.parseDateTime(obj[key]);
+              }
+            }
+          }
+        }
+      }
+
+    }
+    if (this.Parent?.Tablename == "EU_Invoices") {
+     
+
+    }
+    if (obj["_details"] != null) {
+      this.Details = [];
+      for (let key in obj["_details"]) {
+        
+          this.Details.push(new TableLevel(key, obj["_details"][key], def["_details"][key], objectInfo, this.Parent?.Root ?? null));
+        
+
+      }
+      delete obj["_details"]
+    }
+
+    this.Record = obj;
+    if (parent != null) {
+      this.TableObjectInfo = objectInfo[parent.Tablename];
+    }
+  }
+  public GetObject(): object {
+    var obj = JSON.parse(JSON.stringify(this.Record));
+
+    if (this.Details != null) {
+      let details = JSON.parse("{}");
+      for (let i = 0; i < this.Details.length; i++) {
+        let det = this.Details[i].GetObject();
+        if (det == null) {
+          continue;
+        }
+
+        details[this.Details[i].Tablename] = det;
+      }
+      obj["_details"] = details;
+    }
+    return obj;
+  }
+  TranslateObj(obj:any){
+    if (this.Details != null) {
+      for (let i = 0; i < this.Details.length; i++) {
+        this.Details[i].TranslateObj(obj);
+
+      }
+    }
+    var keys=Object.keys(this.Record);
+    var keysTr=Object.keys(obj);
+    var keysFilter=keys.filter(x=>keysTr.indexOf(x)!=-1);
+    if(keysFilter.length>0)
+      {
+        keysFilter.forEach(x=>{
+          var value=obj[x].data[this.Record[obj[x].key]];
+          if(value!=null)
+            {
+
+              this.Record[x]=obj[x].data[this.Record[obj[x].key]]
+            }
+
+        });
+      }
+
+  }
+  public Inicialize(skippedLevels: string[]) {
+
+    if (this.Details != null) {
+      for (let i = 0; i < this.Details.length; i++) {
+        this.Details[i].Inicialize(skippedLevels);
+      }
+
+    }
+    if (this.Parent?.Tablename != null && skippedLevels.indexOf(this.Parent?.Tablename) != -1) {
+      return;
+    }
+    if(this.Parent?.Tablename=="EU_Invoices_Items")
+    {
+      const nonNullFields=["Quantity","LineAllowPercent"];
+      if (this.Parent.Root?.GetMasterRecord()?.Record.InvSaleTypeSC__Code == "Retailsale") {
+        nonNullFields.push("ItemRetailPriceInp");
+      }
+      else
+      {
+        nonNullFields.push("ItemNetPrice");
+      }
+      for(let i=0;i<nonNullFields.length;i++)
+      {
+        if(this.Record[nonNullFields[i]]==null)
+        {
+          this.Record[nonNullFields[i]]=0;
+        }
+      }
+
+    }
+    let map = new Map<string, any[]>();
+    for (let key in this.TableObjectInfo) {
+      const source = this.TableObjectInfo[key].Source;
+      if (this.byLevelSources.indexOf(source) == -1) {
+        continue;
+      }
+      if (!map.has(source)) {
+        map.set(source, []);
+      }
+      map.get(source)?.push(this.TableObjectInfo[key])
+
+
+      /*if ((this.TableObjectInfo[key].Source == "SYSTEM"||this.TableObjectInfo[key].Source == "MAPPEDINV") && this.TableObjectInfo[key].GetValueFrom == "Expression" && this.TableObjectInfo[key].CalcPhase != null) {
+         array.push(this.TableObjectInfo[key]);
+       }*/
+    }
+    // console.log(map)
+    if (map.size == 0) {
+      return;
+    }
+    for (let x = 0; x < this.byLevelSources.length; x++) {
+      const key = this.byLevelSources[x];
+      if (!map.has(key)) {
+        continue;
+      }
+      // console.log(key);
+      const array = map.get(key);
+      if (array == null) {
+        continue;
+      }
+      var sortedArray: SchemaStruct[] = array.sort((n1, n2) => {
+        if (n1.CalcPhase > n2.CalcPhase) {
+          return 1;
+        }
+
+        if (n1.CalcPhase < n2.CalcPhase) {
+          return -1;
+        }
+
+        return 0;
+      });
+      // console.log(sortedArray)
+      for (var i = 0; i < sortedArray.length; i++) {
+        let item = sortedArray[i];
+        if(item.CreateNewInit == "Suggested")
+        {
+          if(item.FieldName=="ItemClassCode"||item.FieldName=="ItemClassCodeSchID")
+          {
+            if(this.Record[item.FieldName]!=null)
+            {
+              continue;
+            }
+
+          }
+          else
+          {
+            continue;
+          }
+
+        }
+        if (item.CreateNewInit == "Fixed") {
+          continue;
+        }
+        if (item.Type != "decimal" && item.Type != "integer" && item.Type != "boolean"&&item.Type != "string") {
+        //if (item.Type != "decimal" && item.Type != "integer" && item.Type != "boolean") {
+          continue;
+        }
+        if(item.EvalOnlyIfEmpty===true&&this.Record[item.FieldName]!=null)
+        {
+          continue;
+        }
+        // console.log('item: ' + JSON.stringify(item))
+        switch (item.GetValueFrom) {
+
+          case "Expression":
+            {
+              try{
+                if(item.ValueExpression==null)
+                {
+                  continue;
+                }
+              let ex = this.ParseExpressionAndReturnValue(item.ValueExpression ?? "",item);
+                console.log("Parsed:"+ex)
+              if (ex == null) {
+                this.Record[item.FieldName] = null;
+                continue;
+              }
+              if(typeof ex != "string")
+              {
+                this.Record[item.FieldName]=ex;
+                continue;
+              }
+              // console.log(ex);
+              try {
+                switch (ex.toUpperCase()) {
+                  case "FALSE":
+                    {
+                      this.Record[item.FieldName] = false;
+                      continue;
+                    }
+                  case "TRUE":
+                    {
+                      this.Record[item.FieldName] = true;
+                      continue;
+                    }
+                }
+                if (item.Type == "decimal" || item.Type == "integer" || item.Type == "boolean") {
+
+                let evaluated = eval(ex ?? "");
+
+                if (evaluated != "") {
+                  if (item.RoundTo != null) {
+                    evaluated = BaseParse.roundUp(evaluated, item.RoundTo);
+                  }
+                }
+
+                this.Record[item.FieldName] = evaluated;
+              }
+              else
+              {
+                this.Record[item.FieldName] = ex;
+              }
+                // console.log(eval(ex ?? ""));
+              }
+              catch (e) {
+                console.error(e);
+              }
+            }catch(ee)
+            {
+               console.log(ee);
+            }
+              break;
+            }
+          case "Mappings":
+            {
+
+              if (this.Record[item.FieldName] == null) {
+                continue;
+              }
+              if (this.Parent?.Root?.mappings[item.FieldName] == null) {
+                console.error("Can't find mapping for " + item.FieldName);
+                continue;
+              }
+              const array = this.Parent?.Root?.mappings[item.FieldName];
+              for (let m = 0; m < array.length; m++) {
+                const map = array[m];
+                let valid = false;
+                if (map["value"] != null && map["value"] == this.Record[item.FieldName]) {
+                  valid = true;
+                }
+                else if (map["value"] == null) {
+                  valid = true;
+                }
+                if (valid == false) {
+                  continue;
+                }
+                const destField = map.map["DestField"];
+                const destvalue = map.map["DestValue"];
+                let ex = this.ParseExpressionAndReturnValue(destvalue,item);
+                console.log("ParsedMap:"+ex)
+
+                try {
+                  if(typeof ex != "string")
+                    {
+                      this.Record[destField]=ex;
+                      continue;
+                    }
+                  switch ((ex ?? "").toUpperCase()) {
+                    case "FALSE":
+                      {
+                        this.Record[destField] = false;
+                        continue;
+                      }
+                    case "TRUE":
+                      {
+                        this.Record[destField] = true;
+                        continue;
+                      }
+                  }
+                  let evaluated = eval(ex ?? "");
+                  if (evaluated != "") {
+                    if (item.RoundTo != null) {
+                      evaluated = BaseParse.roundUp(evaluated, item.RoundTo);
+                    }
+                  }
+
+                  this.Record[destField] = evaluated;
+                  // console.log("Mapped:" + destField + " Value:" + ex + "Evaluated:" + evaluated)
+                }
+                catch (e) {
+                  console.error(e);
+                }
+
+                break;
+              }
+              break;
+            }
+        }
+      }
+    }
+
+
+
+
+    //todo here need to start initin like on server
+  }
+  public ParseExpressionAndReturnValue(valueExp: string,schemaitem:SchemaStruct) {
+  
+    return this.ParseExpressionAndReturnValueNew(valueExp,schemaitem);
+  }
+  public ParseExpressionAndReturnValueNew(valueExp: string,schemaitem:SchemaStruct) {
+    if(this.Parent?.Root==null)
+    {
+
+      return null;
+    }
+
+    var val= ExpresionLogicService.ParseAndFillExpression(valueExp,schemaitem,this.Parent.Root,this,this.Record,false,false);
+
+    return val;
+
+
+
+  }
+  public ParseExpressionAndReturnValueOld(valueExp: string,schemaitem:SchemaStruct) {
+    if (valueExp.indexOf("%") == -1) {
+      if (valueExp == "null") {
+        return null;
+      }
+      if (valueExp.indexOf("SUM(") == -1 && valueExp.indexOf("IF(") == -1&& valueExp.indexOf("COUNT(") == -1&&valueExp.indexOf("indetail(") == -1) {
+        return valueExp;
+
+      }
+
+    }
+
+    let valueExpression = valueExp;
+    const listCommands: string[] = [];
+    let currentCommand: string = ""
+    while (valueExpression.length > 0) {
+      if (valueExpression.startsWith("%")) {
+        listCommands.push(currentCommand); currentCommand = "%"; valueExpression = valueExpression.substring(1);
+        currentCommand += valueExpression.substring(0, valueExpression.indexOf("%") + 1); valueExpression = valueExpression.substring(valueExpression.indexOf("%") + 1);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        continue;
+      }
+      if (valueExpression.startsWith("N.%")) {
+        listCommands.push(currentCommand); currentCommand = "%"; valueExpression = valueExpression.substring(3);
+        currentCommand += valueExpression.substring(0, valueExpression.indexOf("%") + 1); valueExpression = valueExpression.substring(valueExpression.indexOf("%") + 1);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        continue;
+      }
+      if (valueExpression.startsWith("(")) {
+        var end = this.FindEnd(valueExpression);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        currentCommand += valueExpression.substring(0, end + 1); valueExpression = valueExpression.substring(end + 1);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        continue;
+      }
+      if (valueExpression.startsWith("IF(")) {
+        var end = this.FindEnd(valueExpression);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        currentCommand += valueExpression.substring(0, end + 1); valueExpression = valueExpression.substring(end + 1);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        continue;
+      }
+      if (valueExpression.startsWith("IF (")) {
+        var end = this.FindEnd(valueExpression);
+        listCommands.push(currentCommand); currentCommand = "";
+        currentCommand += valueExpression.substring(0, end + 1); valueExpression = valueExpression.substring(end + 1);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        continue;
+      }
+      if (valueExpression.startsWith("SUM(")) {
+        var end = this.FindEnd(valueExpression);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        currentCommand += valueExpression.substring(0, end + 1); valueExpression = valueExpression.substring(end + 1);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        continue;
+      }
+      if (valueExpression.startsWith("COUNT(")) {
+        var end = this.FindEnd(valueExpression);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        currentCommand += valueExpression.substring(0, end + 1); valueExpression = valueExpression.substring(end + 1);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        continue;
+      }
+      if (valueExpression.toUpperCase().startsWith("INDETAIL(")) {
+        var end = this.FindEnd(valueExpression);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        currentCommand += valueExpression.substring(0, end + 1); valueExpression = valueExpression.substring(end + 1);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        continue;
+      }
+      if (valueExpression.startsWith("TRIM(")) {
+        var end = this.FindEnd(valueExpression);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        currentCommand += valueExpression.substring(0, end + 1); valueExpression = valueExpression.substring(end + 1);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        continue;
+      }
+      if (valueExpression.startsWith("CALCDATE(")) {
+        var end = this.FindEnd(valueExpression);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        currentCommand += valueExpression.substring(0, end + 1); valueExpression = valueExpression.substring(end + 1);
+
+        listCommands.push(currentCommand); currentCommand = "";
+        continue;
+      }
+      currentCommand += valueExpression.substring(0, 1);
+      valueExpression = valueExpression.substring(1);
+
+    }
+    if (currentCommand != "") {
+      listCommands.push(currentCommand);
+    }
+    // console.log(listCommands);
+    let builder = "";
+    for (let i = 0; i < listCommands.length; i++) {
+      let l = listCommands[i];
+
+      if (l.startsWith("%") && l.endsWith("%")) {
+        var value = this.ValueExpresion(l);
+
+        if (value != null) {
+          builder += value;
+        }
+        else
+        {
+          builder+="null";
+
+        }
+        //TODO what is Null??
+      }
+      else if (l.startsWith("(")) {
+        var cur = l.substring(1, l.length - 1);
+        builder += "(" + this.ParseExpressionAndReturnValue(cur,schemaitem) + ")";
+      }
+      else if (l.startsWith("IF(") || l.startsWith("IF (")) {
+        let ifStat = "";
+        if (l.startsWith("IF(")) {
+          ifStat = l.substring(3, l.length - 1);
+        }
+        else {
+          ifStat = l.substring(4, l.length - 1);
+        }
+
+        var split = ifStat.split(",");
+        if (split.length != 3) {
+          ifStat=this.ParseExpressionAndReturnValue(ifStat,schemaitem)??"";
+          split = ifStat.split(",");
+          if(split.length != 3)
+          {
+          continue;
+          }
+        }
+        var ifStategment = new IfStategment(split[0]);
+        let value = null;
+        if (ifStategment.Validate(this)) {
+          value = this.ParseExpressionAndReturnValue(split[1],schemaitem);
+        }
+        else {
+          value = this.ParseExpressionAndReturnValue(split[2],schemaitem);
+        }
+        if (value == null) {
+          builder += "null";
+        }
+        else {
+          builder += value;
+        }
+      }
+      else if (l.startsWith("CALCDATE(")) {
+        var tAndF = l.substring(9, l.length - 1);
+        /*const split=tAndF.split(",");
+        let datePart=this.ParseExpressionAndReturnValue(split[0],schemaitem);
+        const offsetany:any=this.ParseExpressionAndReturnValue(split[1],schemaitem);
+        let date1=new Date();
+        if(datePart instanceof Date)
+        {
+          date1=datePart;
+        }
+
+        let offset:number=0;
+        if(offsetany)
+        {
+          offset=parseInt(offsetany);
+        }
+        let date:Date=new Date(date1);
+        date.setDate(date.getDate()+offset);
+
+        return this.getIsoDateTime(date);*/
+
+      }
+      else if (l.startsWith("SUM(")) {
+        var tAndF = l.substring(4, l.length - 1);
+        builder += this.Parent?.Root?.SumByKey(tAndF);
+      }
+      else if (l.toUpperCase().startsWith("INDETAIL(")) {
+        try{
+        var tAndF = l.substring(9, l.length - 1);
+        console.log("tAndF:"+tAndF)
+        var index=this.FindEnd(tAndF);
+        var valStirng=tAndF.substring(1,index);
+        console.log("valStirng:"+tAndF)
+        var values=valStirng.split(",");
+
+        var tableAndField=tAndF.substring(index+2);
+        console.log("tableAndField:"+tableAndField)
+        var split=tableAndField.split(".");
+        var table=split[0];
+        var field=split[1];
+        var level=this.Parent?.Root?.FindTableLevel(table);
+        if(level==null)
+        {
+          return "false";
+        }
+        if(level.Records==null)
+        {
+          return "false";
+        }
+        for(var x=0;x<level.Records.Records.length;x++)
+        {
+          if(values.indexOf(level.Records.Records[x].Record[field])!=-1)
+          {
+            return "true";
+          }
+        }
+        return "false";
+      }
+      catch(exc)
+      {
+        console.error(exc);return "false";
+      }
+
+
+      }
+      else if (l.startsWith("TRIM(")) {
+        try{
+          var tAndF = l.substring(5, l.length - 1);
+          var value=this.ValueExpresion(tAndF);
+          if(value!=null)
+          {
+            value=value.trim();
+          }
+          builder += value;
+        }
+        catch(EX)
+        {
+
+        }
+
+      }
+      else if (l.startsWith("COUNT(")) {
+        var table = l.substring(6, l.length - 1);
+        var level=this.Parent?.Root?.FindTableLevel(table);
+        if(level==null)
+        {
+          builder+="-1";
+        }
+        else
+        {
+          builder+=level.Records?.Records.length;
+        }
+
+      }
+      else {
+        builder += l;
+      }
+    }
+    if (builder == "" || builder == null) {
+      if (builder.trim() == "null") {
+        return null;
+      }
+
+    }
+
+    return builder;
+  }
+  private valueToType(value:string)
+  {
+    if(value==null||value=="null")
+    {
+      return null;
+    }
+    if(typeof value !== "string")
+    {
+      return value;
+    }
+    if(value.toLocaleLowerCase()=="true")
+    {
+      return true;
+    }
+    if(value.toLocaleLowerCase()=="false")
+    {
+      return false;
+    }
+    if(!isNaN(parseFloat(value)))
+    {
+      return parseFloat(value);
+    }
+    return value;
+  }
+  public ValueExpresion(exp: string | null) {
+    if (exp == null) {
+      return null;
+    }
+    if (!exp.startsWith("%") || !exp.endsWith("%")) {
+      return this.valueToType(exp);
+    }
+    let tabelAndKey = exp.substring(1, exp.length - 1);
+
+    let split = tabelAndKey.split(".");
+
+            var prefix = split[0];
+            switch (prefix)
+            {
+                case "V":
+                    {
+                      console.warn("V not supported!")
+                        return null;
+
+                    }
+
+                case "E":
+                    {
+                        const tableName = split[1];
+                        const field = split[2];
+                        if (tableName=="EU_AOrg")
+                        {
+                           // return this.Parent?.Root?.service.aboutOrganisation[field];
+                        }
+                        else if (tableName=="EU_SCR")
+                        {
+                          //return this.Parent?.Root?.service.aboutOrganisation[field];
+
+                        }
+                        else if (tableName=="Session")
+                        {
+                          /*var instance= this.Parent?.Root?.service.sessionInfo;
+                            var path = "";
+                            for (var i = 2; i < split.length; i++)
+                            {
+                                instance=instance[split[i]]
+                                if(!instance)
+                                {
+                                  return null;
+                                }
+                            }
+                            return this.valueToType(instance);*/
+                        }
+
+                        else
+                        {
+                          console.warn("Other E not supported!")
+                          return null;
+                        }
+
+                    }
+                case "S":
+                    {
+                      console.warn("S not supported!")
+                      return null;
+
+                    }
+                default:
+                    {
+                        if (split.length == 2)
+                        {
+                          const table = split[0];
+                          if (table == this.Parent?.Tablename) {
+                            return this.Record[split[1]];
+                          }
+                          else {
+                            let tableLevel = this.Parent?.Root?.FindTableLevel(table);
+                            if (tableLevel != null) {
+                              if (tableLevel.Record != null) {
+                                if (tableLevel?.Record != null) {
+                                  return this.valueToType( tableLevel?.Record.Record[split[1]]);
+                                }
+                              }
+                            }
+                          }
+                        }
+                        break;
+                    }
+            }
+
+    return null;
+  }
+  private FindEnd(expresion: string) {
+    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 getSaveObject(objectInfoUIEdit: any) {
+    const result: any = {};
+    if (this.Details != null) {
+      const details: any = {};
+      for (let i = 0; i < this.Details.length; i++) {
+        const obj = this.Details[i].getSaveObject(objectInfoUIEdit);
+        if (obj == null) {
+          continue;
+        }
+        details[this.Details[i].Tablename] = obj;
+      }
+      if (Object.keys(details).length > 0) {
+        result["_details"] = details;
+      }
+    }
+
+    if (this.Parent?.Tablename == null) {
+      return null;
+    }
+
+    const tablePart = objectInfoUIEdit[this.Parent?.Tablename]
+    const keys = Object.keys(tablePart);
+    for (let i = 0; i < keys.length; i++) {
+
+      const key = keys[i];
+
+
+      /*if ("InvIssueDate"==key&&this.Parent?.Tablename == "EU_Invoices") {
+        if(this.Parent.Root?.service.aboutOrganisation["InvDateOpen"]==null||
+        this.Parent.Root?.service.aboutOrganisation["InvDateOpen"]==false)
+       {
+
+            let date = new Date();
+            result[key]=BaseParse.getIsoDateTime(date);
+        }
+        else
+        {
+          result[key]=BaseParse.getIsoDateTime(this.Record[key]);
+        }
+        continue;
+      }*/
+      const type = tablePart[key].TypeDDD;
+      // console.log('type: ' + type);
+      switch (type) {
+        case "Date": {
+          result[key] = BaseParse.getIsoDate(this.Record[key]);
+          break;
+        }
+        case "DateTime": {
+
+          result[key] = BaseParse.getIsoDateTime(this.Record[key]);
+          break;
+        }
+        default: {
+          result[key] = this.Record[key];
+          break;
+        }
+      }
+
+    }
+    if (this.Record["Id"] != null) {
+      result["Id"] = this.Record["Id"];
+    }
+    if (this.Parent?.Tablename == "EU_Invoices") {
+
+     /* result["InvTotalVatAmountCCInp"]=this.Record["InvTotalVatAmountCC"];
+      result["InvAmountInclVatInp"]=this.Record["InvAmountInclVat"];
+      if(this.Parent.Root?.service.BuyerRefArray!=null)
+      {
+        const savedTags=[];
+       if(this.Record["__AdditonalRef"].length>0)
+       {
+         for(let x=0;x<this.Record["__AdditonalRef"].length;x++)
+         {
+           const addRef=this.Record["__AdditonalRef"][x];
+        for(let i=0;i<this.Parent.Root?.service.BuyerRefArray.length;i++)
+        {
+          const item=this.Parent.Root?.service.BuyerRefArray[i];
+          if(addRef.key==item.Tag&&addRef.value!=null)
+          {
+
+            result[item.WriteToField]=addRef.value;
+            savedTags.push(item.Tag);
+          }
+
+        }
+      }
+       }
+
+       for(let i=0;i<this.Parent.Root?.service.BuyerRefArray.length;i++)
+       {
+        const item=this.Parent.Root?.service.BuyerRefArray[i];
+         if(savedTags.indexOf(item.Tag)==-1)
+         {
+           result[item.WriteToField]=null;
+         }
+       }
+
+    }*/
+    //result["DeliveryDateActual"]=result["InvEndDate"];
+    }
+    if (Object.keys(result).length > 0) {
+      return result;
+    }
+    return null;
+  }
+  public getFullObject(objectInfo: any) {
+    const result: any = {};
+    if (this.Details != null) {
+      const details: any = {};
+      for (let i = 0; i < this.Details.length; i++) {
+        const obj = this.Details[i].getSaveObject(objectInfo);
+        if (obj == null) {
+          continue;
+        }
+        details[this.Details[i].Tablename] = obj;
+      }
+      if (Object.keys(details).length > 0) {
+        result["_details"] = details;
+      }
+    }
+
+    if (this.Parent?.Tablename == null) {
+      return null;
+    }
+
+    const tablePart = objectInfo[this.Parent?.Tablename]
+    const keys = Object.keys(tablePart);
+    for (let i = 0; i < keys.length; i++) {
+
+      const key = keys[i];
+
+
+      /*if ("InvIssueDate"==key&&this.Parent?.Tablename == "EU_Invoices") {
+        if(this.Parent.Root?.service.aboutOrganisation["InvDateOpen"]==null||
+        this.Parent.Root?.service.aboutOrganisation["InvDateOpen"]==false)
+       {
+
+            let date = new Date();
+            result[key]=BaseParse.getIsoDateTime(date);
+        }
+        else
+        {
+          result[key]=BaseParse.getIsoDateTime(this.Record[key]);
+        }
+        continue;
+      }*/
+      const type = tablePart[key].TypeDDD;
+      // console.log('type: ' + type);
+      switch (type) {
+        case "Date": {
+          result[key] = BaseParse.getIsoDate(this.Record[key]);
+          break;
+        }
+        case "DateTime": {
+
+          result[key] = BaseParse.getIsoDateTime(this.Record[key]);
+          break;
+        }
+        default: {
+          result[key] = this.Record[key];
+          break;
+        }
+      }
+
+    }
+    if (this.Record["Id"] != null) {
+      result["Id"] = this.Record["Id"];
+    }
+    if (this.Parent?.Tablename == "EU_Invoices") {
+
+      result["InvTotalVatAmountCCInp"]=this.Record["InvTotalVatAmountCC"];
+      result["InvAmountInclVatInp"]=this.Record["InvAmountInclVat"];
+      /*if(this.Parent.Root?.service.BuyerRefArray!=null)
+      {
+        const savedTags=[];
+       if(this.Record["__AdditonalRef"].length>0)
+       {
+         for(let x=0;x<this.Record["__AdditonalRef"].length;x++)
+         {
+           const addRef=this.Record["__AdditonalRef"][x];
+        for(let i=0;i<this.Parent.Root?.service.BuyerRefArray.length;i++)
+        {
+          const item=this.Parent.Root?.service.BuyerRefArray[i];
+          if(addRef.key==item.Tag&&addRef.value!=null)
+          {
+
+            result[item.WriteToField]=addRef.value;
+            savedTags.push(item.Tag);
+          }
+
+        }
+      }
+       }
+
+       for(let i=0;i<this.Parent.Root?.service.BuyerRefArray.length;i++)
+       {
+        const item=this.Parent.Root?.service.BuyerRefArray[i];
+         if(savedTags.indexOf(item.Tag)==-1)
+         {
+           result[item.WriteToField]=null;
+         }
+       }
+
+    }*/
+    //result["DeliveryDateActual"]=result["InvEndDate"];
+    }
+    if (Object.keys(result).length > 0) {
+      return result;
+    }
+    return null;
+  }
+
+  public Validate() {
+    if (this.TableObjectInfo == null) {
+      return null;
+    }
+    const detailsErrors = [];
+    const validateDetailsErrors = [];
+
+    if (this.Details != null) {
+      for (let i = 0; i < this.Details.length; i++) {
+        let err = this.Details[i].Validate();
+        if (err != null) {
+          detailsErrors.push(err.combineErrors);
+          validateDetailsErrors.push(...err.validateErrors);
+          // console.log('err record single validateDetailsErrors:' + JSON.stringify(validateDetailsErrors));
+        }
+      }
+    }
+
+    const keys = Object.keys(this.TableObjectInfo);
+    const missingKeys: string[] = []
+
+    for (let i = 0; i < keys.length; i++) {
+      let item = this.TableObjectInfo[keys[i]];
+
+      // console.log('item["Mandatory"]' + JSON.stringify(item));
+      if (item["Mandatory"] == true && (this.Record[keys[i]] === null || (item.Type ==='string' && this.Record[keys[i]]===''))) {
+
+        missingKeys.push(keys[i]);
+      }
+    }
+    if (missingKeys.length == 0 && detailsErrors.length == 0) {
+
+      return null;
+    }
+    return { "missingKeys": missingKeys.join(", "), "details": detailsErrors.length == 0 ? null : detailsErrors, "validateDetailsErrors": validateDetailsErrors[0]};
+
+  }
+}