@magic-xpa/engine 4.1100.0-dev4110.2 → 4.1100.0-dev4110.202

package/esm2022/src/rt/RemoteDataviewHeader.mjs

@@ -0,0 +1,108 @@
+import { List } from "@magic-xpa/mscorelib";
+import { StorageAttribute } from "@magic-xpa/utils";
+import { DisplayConvertor, PIC } from "@magic-xpa/gui";
+import { DataviewHeaderBase } from "./DataviewHeaderBase";
+import { TableCache } from "./TableCache";
+import { Record } from "../data/Record";
+import { ConstInterface } from "../ConstInterface";
+import { TableCacheManager } from "./TableCacheManager";
+import { AccessHelper } from "../AccessHelper";
+export class RemoteDataviewHeader extends DataviewHeaderBase {
+    _table = null;
+    _lastFetchRecPos = null;
+    constructor(task) {
+        super(task);
+    }
+    setAttribute(attribute, valueStr) {
+        switch (attribute) {
+            case ConstInterface.MG_ATTR_CACHED_TABLE:
+                if (valueStr != "") {
+                    if (TableCacheManager.Instance.TableExists(valueStr))
+                        this._table = TableCacheManager.Instance.GetTableById(valueStr);
+                    else {
+                        this._table = new TableCache(valueStr);
+                        TableCacheManager.Instance.InsertTable(this._table);
+                    }
+                }
+                break;
+            case ConstInterface.MG_ATTR_IDENT:
+                if (valueStr != "")
+                    this._table.SetTableIdent(valueStr);
+                break;
+            default:
+                super.setAttribute(attribute, valueStr);
+                break;
+        }
+    }
+    async getLinkedRecord(curRec) {
+        let lnkFlds = this._task.DataView.GetFieldsTab().getLinkFields(this._id);
+        let ret = false;
+        if (this._cond.getVal()) {
+            if (this.Loc == null) {
+                this.Loc = new List();
+                for (let i = 0; i < lnkFlds.length; i++) {
+                    let currLoc = lnkFlds.get_Item(i).Locate;
+                    if (currLoc != null) {
+                        this.Loc.push(currLoc);
+                        await currLoc.compute(false);
+                    }
+                }
+            }
+            else {
+                for (let i = 0; i < this.Loc.length; i++)
+                    await this.Loc.get_Item(i).compute(false);
+            }
+            await this._table.SortTable(this._keyIdx, this._dir);
+            let res = this._table.Fetch(this.Loc);
+            if (res == null)
+                await this.initRec(curRec, false);
+            else {
+                ret = true;
+                await this.copyLinkFldToRec(curRec, lnkFlds, res, true);
+            }
+        }
+        else
+            await this.initRec(curRec, false);
+        return ret;
+    }
+    async copyLinkFldToRec(curRec, linkFlds, tableRec, ret) {
+        this._lastFetchRecPos = tableRec.getDbPosVal();
+        for (let i = 0; i < linkFlds.length; i++) {
+            let curFld = linkFlds.get_Item(i);
+            curRec.setFieldValue(curFld.getId(), tableRec.GetFieldValue(curFld.CacheTableFldIdx), false);
+            curRec.clearFlag(curFld.getId(), Record.FLAG_INVALID);
+            curFld.invalidate(true, false);
+        }
+        await this.SetReturnValue(ret, true);
+    }
+    async initRec(currRec, ret) {
+        this._lastFetchRecPos = "#";
+        await this.InitLinkFields(currRec);
+        let retFld = this.ReturnField;
+        if (retFld != null) {
+            currRec.setFieldValue(retFld.getId(), (ret ? "1" : "0"), false);
+            retFld.invalidate(true, false);
+        }
+    }
+    getLastFetchedDbPos() {
+        return this._lastFetchRecPos;
+    }
+    async SetReturnValue(ret, recompute) {
+        let returnField = this.ReturnField;
+        if (returnField !== null) {
+            let enforceVariableChange = returnField.getTask() !== this.Task;
+            AccessHelper.eventsManager.pushNewExecStacks();
+            let result = ret ? "1" : "0";
+            if (returnField.getType() === StorageAttribute.NUMERIC)
+                result = DisplayConvertor.Instance.toNum(result, new PIC(returnField.getPicture(), StorageAttribute.NUMERIC, 0), 0);
+            await returnField.setValueAndStartRecompute(result, false, recompute, false, false, enforceVariableChange);
+            AccessHelper.eventsManager.popNewExecStacks();
+            if (!recompute)
+                returnField.setModified();
+            returnField.invalidate(true, false);
+            if (returnField.getTask() !== this.Task)
+                await returnField.updateDisplay();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RemoteDataviewHeader.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/RemoteDataviewHeader.ts"],"names":[],"mappings":"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","sourcesContent":["import {List} from \"@magic-xpa/mscorelib\";\r\nimport {StorageAttribute} from \"@magic-xpa/utils\";\r\nimport {DisplayConvertor, PIC} from \"@magic-xpa/gui\";\r\nimport {DataviewHeaderBase} from \"./DataviewHeaderBase\";\r\nimport {TableCache} from \"./TableCache\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {Record} from \"../data/Record\";\r\nimport {Field} from \"../data/Field\";\r\nimport {FieldsTableExt as FieldsTable} from \"../data/FieldsTable\";\r\nimport {Boundary} from \"./Boundary\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\nimport {TableCacheManager} from \"./TableCacheManager\";\r\nimport {AccessHelper} from \"../AccessHelper\";\r\n\r\n/// <summary>\r\n/// link to Remote table\r\n/// </summary>\r\nexport class RemoteDataviewHeader extends DataviewHeaderBase {\r\n  private _table: TableCache = null;\r\n  private _lastFetchRecPos: string = null; // the db pos of the last fetched record from the table cache\r\n\r\n  constructor(task: Task) {\r\n    super(task);\r\n  }\r\n\r\n  protected setAttribute(attribute: string, valueStr: string): void {\r\n    switch (attribute) {\r\n\r\n      case ConstInterface.MG_ATTR_CACHED_TABLE:\r\n        if (valueStr != \"\") {\r\n          if (TableCacheManager.Instance.TableExists(valueStr))\r\n            this._table = TableCacheManager.Instance.GetTableById(valueStr);\r\n          else {\r\n            this._table = new TableCache(valueStr);\r\n            TableCacheManager.Instance.InsertTable(this._table);\r\n          }\r\n        }\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_IDENT:\r\n        if (valueStr != \"\")\r\n          this._table.SetTableIdent(valueStr);\r\n        break;\r\n\r\n      default:\r\n        super.setAttribute(attribute, valueStr);\r\n        break;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   will return the linked record according to the link properties and the current record\r\n  ///   this method will change the current record fields values\r\n  /// </summary>\r\n  public async getLinkedRecord(curRec: Record): Promise<boolean> {\r\n    let lnkFlds = (<FieldsTable> this._task.DataView.GetFieldsTab()).getLinkFields(this._id);\r\n    let ret: boolean = false;\r\n\r\n    if (this._cond.getVal()) {\r\n\r\n      // build locate and range vectors\r\n      if (this.Loc == null) {\r\n        this.Loc = new List<Boundary>();\r\n        for (let i: number = 0; i < lnkFlds.length; i++) {\r\n          let currLoc: Boundary = lnkFlds.get_Item(i).Locate;\r\n          if (currLoc != null) {\r\n            this.Loc.push(currLoc);\r\n            await currLoc.compute(false);\r\n          }\r\n        }\r\n      }\r\n      else {\r\n        // compute the range and locate expressions anew\r\n        for (let i: number = 0; i < this.Loc.length; i++)\r\n          await this.Loc.get_Item(i).compute(false);\r\n      }\r\n      // sort the table (if the table was not loaded yet it will also load it\r\n      await this._table.SortTable(this._keyIdx, this._dir);\r\n      // perform the link\r\n      let res: Record = this._table.Fetch(this.Loc);\r\n      if (res == null)\r\n      // link faild\r\n        await this.initRec(curRec, false);\r\n      else {\r\n        ret = true;\r\n        await this.copyLinkFldToRec(curRec, lnkFlds, res, true);\r\n      }\r\n    }\r\n    // calculate init expressions if there are any or default values\r\n    else\r\n      await this.initRec(curRec,  false); // every scenario where the linked did not\r\n    // returned any record fro example here when\r\n    // the link condition is false then the link is\r\n    // considered to has failed and should return\r\n    // false as return value\r\n\r\n    return ret;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   if the link succeeded copies the values return from the linked table record\r\n  ///   to the current data view record\r\n  /// </summary>\r\n  private async copyLinkFldToRec(curRec: Record, linkFlds: List<Field>, tableRec: Record, ret: boolean): Promise<void> {\r\n    // if we got here it means that we have successfully fetch a record from the link\r\n    // set the lastFetchRecPos to be the pos of the fetched record\r\n    this._lastFetchRecPos = tableRec.getDbPosVal();\r\n\r\n    for (let i: number = 0; i < linkFlds.length; i++) {\r\n      let curFld: Field = linkFlds.get_Item(i);\r\n      curRec.setFieldValue(curFld.getId(), tableRec.GetFieldValue(curFld.CacheTableFldIdx), false);\r\n\r\n      // clear the invalid flag in case it was set\r\n      curRec.clearFlag(curFld.getId(), Record.FLAG_INVALID);\r\n      curFld.invalidate(true, false);\r\n    }\r\n    // set the ret value\r\n    await this.SetReturnValue(ret, true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   in case the link fails set the value to default or to the value of the init expression\r\n  /// </summary>\r\n  private async initRec(currRec: Record, ret: boolean): Promise<void> {\r\n    // if we are here it means that we tried to fetch a record but failed to find one therefor\r\n    // the lastFetchRecPos should be marked accordingly\r\n    this._lastFetchRecPos = \"#\";\r\n\r\n    await this.InitLinkFields(currRec);\r\n\r\n    // set the ret value\r\n    let retFld = this.ReturnField;\r\n    if (retFld != null) {\r\n      currRec.setFieldValue(retFld.getId(), (ret ? \"1\" : \"0\"), false);\r\n      retFld.invalidate(true, false);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the last fetch record db pos value\r\n  /// </summary>\r\n  public getLastFetchedDbPos(): string {\r\n    return this._lastFetchRecPos;\r\n  }\r\n\r\n  /// <summary>\r\n  /// update link result\r\n  /// </summary>\r\n  /// <param name=\"curRec\">current record</param>\r\n  /// <param name=\"ret\">link success</param>\r\n  async SetReturnValue( ret: boolean, recompute: boolean): Promise<void> {\r\n    let returnField: Field = this.ReturnField;\r\n\r\n    if (returnField !== null) {\r\n      let enforceVariableChange: boolean = returnField.getTask() !== this.Task;\r\n\r\n      // if we are fetching first chunk we didn't updated the executuion stack yet\r\n      AccessHelper.eventsManager.pushNewExecStacks();\r\n      // same as NonRecomputeVarChangeEvent on server fetch.cpp\r\n\r\n      // if the return field is numeric, then convert result value toNum() before passing to setValueAndStartRecompute().\r\n      let result: string = ret ? \"1\" : \"0\";\r\n      if (returnField.getType() === StorageAttribute.NUMERIC)\r\n        result = DisplayConvertor.Instance.toNum(result, new PIC(returnField.getPicture(), StorageAttribute.NUMERIC, 0), 0);\r\n\r\n      await returnField.setValueAndStartRecompute(result, false, recompute, false, false, enforceVariableChange);\r\n\r\n      AccessHelper.eventsManager.popNewExecStacks();\r\n\r\n      if (!recompute)\r\n        returnField.setModified();\r\n\r\n      returnField.invalidate(true, false);\r\n\r\n      // If field is from another task, need to update the display as well\r\n      if (returnField.getTask() !== this.Task)\r\n        await returnField.updateDisplay();\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/src/rt/ResultValue.mjs

@@ -0,0 +1,10 @@
+import { StorageAttribute } from "@magic-xpa/utils";
+export class ResultValue {
+    Value = null;
+    Type = StorageAttribute.NONE;
+    SetResultValue(result, type) {
+        this.Value = result;
+        this.Type = type;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVzdWx0VmFsdWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lbmdpbmUvc3JjL3J0L1Jlc3VsdFZhbHVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLGtCQUFrQixDQUFDO0FBS2xELE1BQU0sT0FBTyxXQUFXO0lBQ3RCLEtBQUssR0FBVyxJQUFJLENBQUM7SUFDckIsSUFBSSxHQUFxQixnQkFBZ0IsQ0FBQyxJQUFJLENBQUM7SUFPL0MsY0FBYyxDQUFDLE1BQWMsRUFBRSxJQUFzQjtRQUNuRCxJQUFJLENBQUMsS0FBSyxHQUFHLE1BQU0sQ0FBQztRQUNwQixJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztJQUNuQixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0lSZXN1bHRWYWx1ZX0gZnJvbSBcIi4vSVJlc3VsdFZhbHVlXCI7XHJcbmltcG9ydCB7U3RvcmFnZUF0dHJpYnV0ZX0gZnJvbSBcIkBtYWdpYy14cGEvdXRpbHNcIjtcclxuXHJcbi8vLyA8c3VtbWFyeT5cclxuLy8vIFRoaXMgY2xhc3MgaXMgaW50cm9kdWNlZCB0byByZWFkIHRoZSByZXN1bHQgZnJvbSBzZXJ2ZXIgZm9yIGFueSBvcGVyYXRpb24uXHJcbi8vLyA8L3N1bW1hcnk+XHJcbmV4cG9ydCBjbGFzcyBSZXN1bHRWYWx1ZSBpbXBsZW1lbnRzIElSZXN1bHRWYWx1ZSB7XHJcbiAgVmFsdWU6IHN0cmluZyA9IG51bGw7IC8vIHRoZSByZXN1bHQgcmV0dXJuZWQgYnkgdGhlIHNlcnZlclxyXG4gIFR5cGU6IFN0b3JhZ2VBdHRyaWJ1dGUgPSBTdG9yYWdlQXR0cmlidXRlLk5PTkU7IC8vIHRoZSB0eXBlIG9mIHRoZSByZXN1bHQgd2hpY2ggaXMgcmV0dXJuZWQgYnkgdGhlIHNlcnZlclxyXG5cclxuICAvLy8gPHN1bW1hcnk+XHJcbiAgLy8vICAgc2V0IHJlc3VsdCB2YWx1ZSBieSB0aGUgUmVzdWx0IGNvbW1hbmRcclxuICAvLy8gPC9zdW1tYXJ5PlxyXG4gIC8vLyA8cGFyYW0gbmFtZSA9IFwicmVzdWx0XCI+dGhlIHJlc3VsdCBjb21wdXRlZCBieSB0aGUgc2VydmVyIDwvcGFyYW0+XHJcbiAgLy8vIDxwYXJhbSBuYW1lID0gXCJ0eXBlXCI+dGhlIHR5cGUgb2YgdGhlIHJlc3VsdCB3aGljaCB3YXMgY29tcHV0ZWQgYnkgdGhlIHNlcnZlciA8L3BhcmFtPlxyXG4gIFNldFJlc3VsdFZhbHVlKHJlc3VsdDogc3RyaW5nLCB0eXBlOiBTdG9yYWdlQXR0cmlidXRlKTogdm9pZCB7XHJcbiAgICB0aGlzLlZhbHVlID0gcmVzdWx0O1xyXG4gICAgdGhpcy5UeXBlID0gdHlwZTtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/src/rt/TableCache.mjs

@@ -0,0 +1,177 @@
+import { List, NString } from "@magic-xpa/mscorelib";
+import { Key } from "../data/Key";
+import { FieldsTableExt as FieldsTable } from "../data/FieldsTable";
+import { Logger, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { RuntimeContextBase } from "@magic-xpa/gui";
+import { Record } from "../data/Record";
+import { HeapSort } from "../util/HeapSort";
+import { ConstInterface } from "../ConstInterface";
+import { TableCacheManager } from "./TableCacheManager";
+export class TableCache {
+    _keys = null;
+    _records = null;
+    _currSortDir = '\0';
+    _currSortKey = 0;
+    FldsTab = null;
+    _isLoaded = false;
+    _tableIdent = null;
+    _tableUId = null;
+    constructor(tableId) {
+        this._tableUId = tableId;
+        this._keys = new List();
+        this._records = new List();
+        this._isLoaded = false;
+    }
+    SetTableIdent(ident) {
+        if (this._tableIdent === null)
+            this._tableIdent = ident;
+        else if (this._tableIdent !== ident) {
+            Logger.Instance.WriteExceptionToLogWithMsg("in TableCache.setTableIdent() already set and table identifier  does not match");
+        }
+    }
+    FillData() {
+        let parser = RuntimeContextBase.Instance.Parser;
+        this.FillAttributes(parser);
+        while (this.InitInnerObjects(parser, parser.getNextTag())) {
+        }
+    }
+    FillAttributes(parser) {
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_CACHED_TABLE) + ConstInterface.MG_TAG_CACHED_TABLE.length);
+            let tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            for (let j = 0; j < tokensVector.length; j += 2) {
+                let attribute = (tokensVector.get_Item(j));
+                let valueStr = (tokensVector.get_Item(j + 1));
+                switch (attribute) {
+                    case XMLConstants.MG_ATTR_ID:
+                        if (this._tableUId.indexOf(valueStr) === -1) {
+                            this._tableUId = valueStr;
+                            Logger.Instance.WriteExceptionToLogWithMsg("in TableCache.fillAttributes() table unique id does not match");
+                        }
+                        break;
+                    case XMLConstants.MG_ATTR_NAME:
+                        break;
+                    case ConstInterface.MG_ATTR_IDENT:
+                        if (this._tableIdent !== valueStr) {
+                            this._tableIdent = valueStr;
+                            Logger.Instance.WriteExceptionToLogWithMsg("in TableCache.fillAttributes() table identifier id does not match");
+                        }
+                        break;
+                    default:
+                        Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unrecognized attribute: '{0}'", attribute));
+                        break;
+                }
+            }
+            parser.setCurrIndex(++endContext);
+            return;
+        }
+        Logger.Instance.WriteExceptionToLogWithMsg("in TableCache.fillAttributes() out of string bounds");
+    }
+    InitInnerObjects(parser, foundTagName) {
+        if (foundTagName == null)
+            return false;
+        switch (foundTagName) {
+            case XMLConstants.MG_TAG_FLDH:
+                this.FldsTab = new FieldsTable();
+                this.FldsTab.fillData(parser);
+                break;
+            case ConstInterface.MG_ATTR_KEY: {
+                let current = new Key(this);
+                current.FillData(parser);
+                this._keys.push(current);
+                break;
+            }
+            case ConstInterface.MG_TAG_RECORDS:
+                parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+                break;
+            case ConstInterface.MG_TAG_RECORDS_END:
+                parser.setCurrIndex2EndOfTag();
+                break;
+            case ConstInterface.MG_TAG_CACHED_TABLE_END:
+                parser.setCurrIndex2EndOfTag();
+                return false;
+            case ConstInterface.MG_TAG_REC: {
+                let current = new Record(this);
+                current.Initialize();
+                current.fillData(parser);
+                this._records.push(current);
+                break;
+            }
+        }
+        return true;
+    }
+    GetTableUniqueId() {
+        return this._tableUId;
+    }
+    GetTableCommonIdentifier() {
+        return this._tableIdent;
+    }
+    GetCurrSortKey() {
+        return this._currSortKey;
+    }
+    GetKeyById(keyId) {
+        for (let i = 0; i < this._keys.length; i = i + 1) {
+            if (this._keys.get_Item(i).GetKeyId() === keyId)
+                return this._keys.get_Item(i);
+        }
+        return null;
+    }
+    async Load() {
+        if (!this._isLoaded) {
+            await TableCacheManager.Instance.LoadTable(this._tableUId);
+            this._isLoaded = true;
+        }
+    }
+    async SortTable(sortKeyId, sortDir) {
+        if (!this._isLoaded)
+            await this.Load();
+        if (sortKeyId !== this._currSortKey || sortDir !== this._currSortDir) {
+            this._currSortDir = sortDir;
+            this._currSortKey = sortKeyId;
+            let recordsArr = this._records.ToArray();
+            HeapSort.sort(recordsArr);
+            if (this._currSortDir === 'D')
+                this.ReverseVector(recordsArr);
+            for (let i = 0; i < this._records.length; i = i + 1) {
+                this._records.set_Item(i, recordsArr[i]);
+            }
+        }
+    }
+    Fetch(loc) {
+        let checkLoc = loc.length > 0;
+        if (this._isLoaded) {
+            if (!checkLoc) {
+                return ((this._records.length !== 0) ? this._records.get_Item(0) : null);
+            }
+            for (let i = 0; i < this._records.length; i = i + 1) {
+                let currRec = this._records.get_Item(i);
+                if (TableCache.validateRec(currRec, loc)) {
+                    return currRec;
+                }
+            }
+        }
+        return null;
+    }
+    static validateRec(currRec, rangeCond) {
+        let result = true;
+        for (let i = 0; i < rangeCond.length; i = i + 1) {
+            let currCnd = rangeCond.get_Item(i);
+            if (!currCnd.checkRange(currRec.GetFieldValue(currCnd.getCacheTableFldId()), currRec.IsNull(currCnd.getCacheTableFldId()))) {
+                result = false;
+                break;
+            }
+        }
+        return result;
+    }
+    ReverseVector(array) {
+        let right = array.length - 1;
+        for (let left = 0; left < Math.floor((array.length - 1) / 2); left++, right--) {
+            let tmp = array[left];
+            array[left] = array[right];
+            array[right] = tmp;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TableCache.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/TableCache.ts"],"names":[],"mappings":"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","sourcesContent":["import {List, NString} from \"@magic-xpa/mscorelib\";\r\nimport {Key} from \"../data/Key\";\r\nimport {FieldsTableExt as FieldsTable } from \"../data/FieldsTable\";\r\nimport {Logger, XMLConstants, XmlParser} from \"@magic-xpa/utils\";\r\nimport {RuntimeContextBase} from \"@magic-xpa/gui\";\r\nimport {Record} from \"../data/Record\";\r\nimport {HeapSort} from \"../util/HeapSort\";\r\nimport {Boundary} from \"./Boundary\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\nimport { TableCacheManager } from \"./TableCacheManager\";\r\n\r\n/// <summary>\r\n///   resident table on client\r\n/// </summary>\r\nexport class TableCache {\r\n  private _keys: List<Key> = null;\r\n  private _records: List<Record> = null;\r\n  private _currSortDir: string = '\\0';\r\n  private _currSortKey: number = 0;\r\n\r\n  FldsTab: FieldsTable = null;\r\n\r\n  private _isLoaded: boolean = false;\r\n  private _tableIdent: string = null; // a table identifier this id if share between all instances of a resident table used to delete old instnces of a reloaded table;\r\n  private _tableUId: string = null; // the table unique id used to load the table - it is also the id of the data-island containing the table xml\r\n\r\n\r\n  /// <summary>\r\n  ///   constructs an empty table cache without loading the table\r\n  /// </summary>\r\n  constructor(tableId: string) {\r\n    this._tableUId = tableId;\r\n    this._keys = new List<Key>();\r\n    this._records = new List<Record>();\r\n    this._isLoaded = false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the table shared identifier will be called directly before the constructor and before parsing\r\n  /// </summary>\r\n  SetTableIdent(ident: string): void {\r\n    if (this._tableIdent === null)\r\n      this._tableIdent = ident;\r\n    else if (this._tableIdent !== ident) {\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in TableCache.setTableIdent() already set and table identifier  does not match\");\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parses the xml data of the table cache as part of the load process\r\n  /// </summary>\r\n  FillData(): void {\r\n    let parser: XmlParser = RuntimeContextBase.Instance.Parser;\r\n    this.FillAttributes(parser);\r\n    while (this.InitInnerObjects(parser, parser.getNextTag())) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parses the attributes of the cachedTable tag\r\n  /// </summary>\r\n  private FillAttributes(parser: XmlParser): void {\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());\r\n\r\n    if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n      // last position of its tag\r\n      let tag: string = parser.getXMLsubstring(endContext);\r\n      parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_CACHED_TABLE) + ConstInterface.MG_TAG_CACHED_TABLE.length);\r\n\r\n      let tokensVector: List<string> = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);\r\n\r\n      // parse the cachedTable attributes\r\n      for (let j: number = 0; j < tokensVector.length; j += 2) {\r\n        let attribute: string = (tokensVector.get_Item(j));\r\n        let valueStr: string = (tokensVector.get_Item(j + 1));\r\n\r\n        switch (attribute) {\r\n          case XMLConstants.MG_ATTR_ID:\r\n\r\n            // the id of the table is recived at the constructor and does not need to be parsed\r\n            // however issue a warnning if the parsed value is different than the current value\r\n            if (this._tableUId.indexOf(valueStr) === -1) {\r\n              this._tableUId = valueStr;\r\n              Logger.Instance.WriteExceptionToLogWithMsg(\"in TableCache.fillAttributes() table unique id does not match\");\r\n            }\r\n            break;\r\n\r\n          case XMLConstants.MG_ATTR_NAME:\r\n            break;\r\n\r\n          case ConstInterface.MG_ATTR_IDENT:\r\n            if (this._tableIdent !== valueStr) {\r\n              this._tableIdent = valueStr;\r\n              Logger.Instance.WriteExceptionToLogWithMsg(\"in TableCache.fillAttributes() table identifier id does not match\");\r\n            }\r\n            break;\r\n          default:\r\n            Logger.Instance.WriteExceptionToLogWithMsg(NString.Format(\"Unrecognized attribute: '{0}'\", attribute));\r\n            break;\r\n        }\r\n      }\r\n      parser.setCurrIndex(++endContext);  // to delete \">\" too\r\n      return;\r\n    }\r\n    Logger.Instance.WriteExceptionToLogWithMsg(\"in TableCache.fillAttributes() out of string bounds\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///   allocates and initialize inner object according to the found xml data\r\n  /// </summary>\r\n  private InitInnerObjects(parser: XmlParser, foundTagName: String): boolean {\r\n    if (foundTagName == null)\r\n      return false;\r\n\r\n    switch (foundTagName) {\r\n      case XMLConstants.MG_TAG_FLDH:\r\n        this.FldsTab = new FieldsTable();\r\n        this.FldsTab.fillData(parser);\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_KEY: {\r\n        let current = new Key(this);\r\n        current.FillData(parser);\r\n        this._keys.push(current);\r\n        break;\r\n      }\r\n\r\n      case ConstInterface.MG_TAG_RECORDS:\r\n        parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);\r\n        // end of outer tad and its \">\"\r\n        break;\r\n      case ConstInterface.MG_TAG_RECORDS_END:\r\n        parser.setCurrIndex2EndOfTag();\r\n        break;\r\n      case ConstInterface.MG_TAG_CACHED_TABLE_END:\r\n        parser.setCurrIndex2EndOfTag();\r\n        return false;\r\n      case ConstInterface.MG_TAG_REC: {\r\n        let current = new Record(this);\r\n        current.Initialize();\r\n        current.fillData(parser);\r\n        this._records.push(current);\r\n        break;\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the unique id of the current cached table\r\n  /// </summary>\r\n  GetTableUniqueId(): string {\r\n    return this._tableUId;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the table common identifier\r\n  /// </summary>\r\n  GetTableCommonIdentifier(): string {\r\n    return this._tableIdent;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the key by whic we are currently sorting (or currently sorted) the table\r\n  /// </summary>\r\n  GetCurrSortKey(): number {\r\n    return this._currSortKey;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the key by id\r\n  /// </summary>\r\n  GetKeyById(keyId: number): Key {\r\n    for (let i: number = 0; i < this._keys.length; i = i + 1) {\r\n      if (this._keys.get_Item(i).GetKeyId() === keyId)\r\n        return this._keys.get_Item(i);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   loads a table from the dataIsland according to is unique id\r\n  /// </summary>\r\n  private async Load(): Promise<void> {\r\n    if (!this._isLoaded) {\r\n      await TableCacheManager.Instance.LoadTable(this._tableUId);\r\n      this._isLoaded = true;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sort the current table\r\n  /// </summary>\r\n  /// <param name=\"sortKeyId\">the id of the key to sort by </param>\r\n  /// <param name=\"sortDir\"></param>\r\n  async SortTable(sortKeyId: number, sortDir: string): Promise<void> {\r\n    if (!this._isLoaded)\r\n      await this.Load();\r\n\r\n    // if the table is already sorted the way we want it\r\n    if (sortKeyId !== this._currSortKey || sortDir !== this._currSortDir) {\r\n      this._currSortDir = sortDir;\r\n      this._currSortKey = sortKeyId;\r\n\r\n      let recordsArr: Record[] = this._records.ToArray();\r\n      HeapSort.sort(recordsArr);\r\n\r\n      if (this._currSortDir === 'D')\r\n        this.ReverseVector(recordsArr);\r\n\r\n      for (let i: number = 0; i < this._records.length; i = i + 1) {\r\n        this._records.set_Item(i, recordsArr[i]);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   executes the the link operation we assume the table is already sorted by the correct key and direction\r\n  ///   the method returns the requested record according the locates\r\n  /// </summary>\r\n  Fetch(loc: List<Boundary>): Record {\r\n\r\n    // if there are not any locate expression then either we return the ffirst record that accepts\r\n    // al the range condition or we return the first record in the table according to the current sort\r\n    let checkLoc: boolean = loc.length > 0;\r\n\r\n    if (this._isLoaded) {\r\n      // should be loaded at sort time the time must be already sorted at this stage\r\n      if (!checkLoc) {\r\n        // if there are no locates return the first record\r\n        return ((this._records.length !== 0) ? this._records.get_Item(0) : null);\r\n      }\r\n\r\n      // find the first record that agrees with the locates ant return it\r\n      for (let i: number = 0; i < this._records.length; i = i + 1) {\r\n        let currRec: Record = this._records.get_Item(i);\r\n\r\n        // check if this record agrees with all the locate conditions\r\n        if (TableCache.validateRec(currRec, loc)) {\r\n          return currRec;\r\n        }\r\n      }\r\n    }\r\n    // if we got here then either the table was not loaded and sorted or we did not find any record\r\n    // that agrees with the locate expressions - in either case return null\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   validate a record data against a series of locate expressions\r\n  /// </summary>\r\n  private static validateRec(currRec: Record, rangeCond: List<Boundary>): boolean {\r\n    let result: boolean = true;\r\n\r\n    // go over all the conditions\r\n    for (let i: number = 0; i < rangeCond.length; i = i + 1) {\r\n      let currCnd: Boundary = rangeCond.get_Item(i);\r\n      // if there is at least one filed that does not agree all the record dies not agree\r\n      if (!currCnd.checkRange(currRec.GetFieldValue(currCnd.getCacheTableFldId()), currRec.IsNull(currCnd.getCacheTableFldId()))) {\r\n        result = false;\r\n        break;\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"array\"></param>\r\n  protected ReverseVector(array: Object[]): void {\r\n    let right: number = array.length - 1;\r\n    for (let left: number = 0; left < Math.floor((array.length - 1) / 2); left++ , right--) {\r\n      let tmp: Object = array[left];\r\n      array[left] = array[right];\r\n      array[right] = tmp;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/src/rt/TableCacheManager.mjs

@@ -0,0 +1,67 @@
+import { Misc } from '@magic-xpa/utils';
+import { ApplicationException, Exception, Hashtable, List } from '@magic-xpa/mscorelib';
+import { RuntimeContextBase } from '@magic-xpa/gui';
+import { RemoteCommandsProcessor } from '../remote/RemoteCommandsProcessor';
+export class TableCacheManager {
+    _tables = null;
+    static Instance = new TableCacheManager();
+    constructor() {
+        this._tables = new Hashtable();
+    }
+    GetTableById(tableUId) {
+        return this._tables.get_Item(tableUId);
+    }
+    TableExists(tableUId) {
+        let result = true;
+        if (this.GetTableById(tableUId) === null)
+            result = false;
+        return result;
+    }
+    InsertTable(table) {
+        let result = false;
+        if (!this.TableExists(table.GetTableUniqueId())) {
+            this._tables.set_Item(table.GetTableUniqueId(), table);
+            result = true;
+        }
+        return result;
+    }
+    async LoadTable(tableUId) {
+        let server = RemoteCommandsProcessor.GetInstance();
+        if (this.TableExists(tableUId)) {
+            let current = this._tables.get_Item(tableUId);
+            try {
+                let residentTableContentStr = await server.GetContent(tableUId, true);
+                try {
+                    RuntimeContextBase.Instance.Parser.loadTableCacheData(residentTableContentStr);
+                }
+                catch (innerException) {
+                    if (innerException instanceof Exception) {
+                        throw new ApplicationException("Unable to parse resident table " + tableUId + ", due to unsupported encoding.", innerException);
+                    }
+                    else
+                        throw innerException;
+                }
+            }
+            catch (throwable) {
+                if (throwable instanceof Exception) {
+                    Misc.WriteStackTrace(throwable);
+                }
+                else
+                    throw throwable;
+            }
+            current.FillData();
+            let deletedUids = new List();
+            let enumerator = this._tables.Values;
+            while (enumerator.MoveNext()) {
+                let tbl = enumerator.Current;
+                let currIdent = tbl.GetTableCommonIdentifier();
+                if (currIdent === current.GetTableCommonIdentifier() && tbl.GetTableUniqueId() !== tableUId)
+                    deletedUids.push(tbl.GetTableUniqueId());
+            }
+            for (let i = 0; i < deletedUids.length; i = i + 1) {
+                this._tables.Remove(deletedUids.get_Item(i));
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TableCacheManager.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/TableCacheManager.ts"],"names":[],"mappings":"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","sourcesContent":["import { Misc } from '@magic-xpa/utils';\r\nimport { ApplicationException, Array_Enumerator, Exception, Hashtable, List } from '@magic-xpa/mscorelib';\r\nimport { RuntimeContextBase } from '@magic-xpa/gui';\r\nimport { TableCache } from './TableCache';\r\nimport { CommandsProcessorBase } from '../CommandsProcessorBase';\r\nimport { RemoteCommandsProcessor } from '../remote/RemoteCommandsProcessor';\r\n\r\n/// <summary>\r\n///   handles the loading and managing of all cache tables in the context\r\n/// </summary>\r\nexport class TableCacheManager {\r\n  private _tables: Hashtable<string, TableCache> = null;\r\n\r\n  static Instance: TableCacheManager = new TableCacheManager();\r\n\r\n  private constructor() {\r\n    this._tables = new Hashtable<string, TableCache>();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the tableCache object  according to its unique id or null if does not exist in the manager\r\n  /// </summary>\r\n  GetTableById(tableUId: string): TableCache {\r\n    return <TableCache>this._tables.get_Item(tableUId);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   checks if a given table exists in the manager\r\n  /// </summary>\r\n  TableExists(tableUId: string): boolean {\r\n    let result: boolean = true;\r\n\r\n    if (this.GetTableById(tableUId) === null)\r\n      result = false;\r\n\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   inserts a table into the manager is not already exists\r\n  ///   returns true is insert succeeded false otherwise\r\n  /// </summary>\r\n  InsertTable(table: TableCache): boolean {\r\n    let result: boolean = false;\r\n\r\n    if (!this.TableExists(table.GetTableUniqueId())) {\r\n      this._tables.set_Item(table.GetTableUniqueId(), table);\r\n      result = true;\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   loads a new table start the table parsing process\r\n  ///   delete any old instances of the same table (even if they other unique ids\r\n  /// </summary>\r\n  async LoadTable(tableUId: string): Promise<void> {\r\n    let server: CommandsProcessorBase = RemoteCommandsProcessor.GetInstance();\r\n\r\n    // the table must exist in the hashTable at this stage else it is an error\r\n    if (this.TableExists(tableUId)) {\r\n      // get the table\r\n      let current: TableCache = <TableCache>this._tables.get_Item(tableUId);\r\n      try {\r\n        let residentTableContentStr: string = await server.GetContent(tableUId, true);\r\n        try {\r\n          RuntimeContextBase.Instance.Parser.loadTableCacheData(residentTableContentStr);\r\n        }\r\n        catch (innerException) {\r\n          if (innerException instanceof Exception) {\r\n            throw new ApplicationException(\"Unable to parse resident table \" + tableUId + \", due to unsupported encoding.\", innerException);\r\n          }\r\n          else\r\n            throw innerException;\r\n        }\r\n      }\r\n      catch (throwable) {\r\n        if (throwable instanceof Exception) {\r\n          Misc.WriteStackTrace(throwable);\r\n        }\r\n        else\r\n          throw throwable;\r\n      }\r\n\r\n      // start parsing\r\n      current.FillData();\r\n\r\n      // delete old tables\r\n      let deletedUids: List<string> = new List<string>();\r\n      let enumerator: Array_Enumerator<TableCache> = this._tables.Values;\r\n      while (enumerator.MoveNext()) {\r\n        let tbl: TableCache = <TableCache>enumerator.Current;\r\n        let currIdent: string = tbl.GetTableCommonIdentifier();\r\n        if (currIdent === current.GetTableCommonIdentifier() && tbl.GetTableUniqueId() !== tableUId)\r\n          deletedUids.push(tbl.GetTableUniqueId());\r\n      }\r\n      // delete\r\n      for (let i: number = 0; i < deletedUids.length; i = i + 1) {\r\n        this._tables.Remove(deletedUids.get_Item(i));\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/src/rt/Transaction.mjs

@@ -0,0 +1,53 @@
+import { ConstInterface } from "../ConstInterface";
+export class Transaction {
+    _transId = null;
+    _afterTransRetry = ConstInterface.RECOVERY_NONE;
+    _transBegin = '\0';
+    Opened = false;
+    OwnerTask = null;
+    constructor(task, setTransId) {
+        this.OwnerTask = task;
+        this._transId = setTransId;
+        this._transBegin = ConstInterface.TRANS_TASK_PREFIX;
+    }
+    isOwner(task) {
+        return task === this.OwnerTask;
+    }
+    close() {
+        this.Opened = false;
+    }
+    open() {
+        this.Opened = true;
+    }
+    isOpened() {
+        return this.Opened;
+    }
+    setAfterRetry(val) {
+        this._afterTransRetry = val;
+    }
+    getAfterRetry(recovery) {
+        if (arguments.length === 0) {
+            return this.getAfterRetry_0();
+        }
+        return this.getAfterRetry_1(recovery);
+    }
+    getAfterRetry_0() {
+        return this._afterTransRetry !== ConstInterface.RECOVERY_NONE;
+    }
+    getAfterRetry_1(recovery) {
+        return this._afterTransRetry === recovery;
+    }
+    getLevel() {
+        return this._transBegin;
+    }
+    setTransBegin(val) {
+        this._transBegin = val;
+    }
+    getTransId() {
+        return this._transId;
+    }
+    setOwnerTask(task) {
+        this.OwnerTask = task;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/security/UserDetails.mjs

@@ -0,0 +1,71 @@
+import { NString } from '@magic-xpa/mscorelib';
+import { Logger, XMLConstants, XmlParser } from '@magic-xpa/utils';
+import { ConstInterface } from '../ConstInterface';
+import { Commands } from '@magic-xpa/gui';
+export class UserDetails {
+    static _instance = null;
+    UserName = null;
+    UserID = null;
+    UserInfo = null;
+    Password = null;
+    IsLoggedIn = false;
+    setIsLoggedIn(value) {
+        this.IsLoggedIn = value;
+    }
+    getIsLoggedIn() {
+        return this.IsLoggedIn;
+    }
+    setUserID(userId) {
+        this.UserID = userId;
+        if (this.UserID.length == 0 || this.UserID === NString.Empty) {
+            this.setIsLoggedIn(false);
+        }
+        else
+            this.setIsLoggedIn(true);
+    }
+    static get Instance() {
+        if (UserDetails._instance === null)
+            UserDetails._instance = new UserDetails();
+        return UserDetails._instance;
+    }
+    constructor() {
+        this.UserName = NString.Empty;
+        this.UserInfo = NString.Empty;
+        this.IsLoggedIn = false;
+        this.setUserID(NString.Empty);
+    }
+    fillData(parser) {
+        let tokensVector;
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_USER_DETAILS) + ConstInterface.MG_TAG_USER_DETAILS.length);
+            tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            this.initElements(tokensVector);
+            parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
+        }
+        else
+            Logger.Instance.WriteExceptionToLogWithMsg("in UserDetails.fillData(): out of bounds");
+    }
+    initElements(tokensVector) {
+        let attribute, valueStr;
+        let isSuccess = true;
+        let j;
+        for (j = 0; j < tokensVector.length; j += 2) {
+            attribute = tokensVector.get_Item(j);
+            valueStr = tokensVector.get_Item(j + 1);
+            switch (attribute) {
+                case ConstInterface.MG_TAG_IS_LOGGED_IN:
+                    this.setIsLoggedIn(valueStr[0] === '1');
+                    Commands.addIsLoggedIn(this.getIsLoggedIn());
+                    break;
+                default:
+                    Logger.Instance.WriteExceptionToLogWithMsg("in UserDetails.initElements(): unknown attribute: " + attribute);
+                    isSuccess = false;
+                    break;
+            }
+        }
+        return isSuccess;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UserDetails.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/security/UserDetails.ts"],"names":[],"mappings":"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","sourcesContent":["import { List, NString } from '@magic-xpa/mscorelib';\r\nimport { Logger, XMLConstants, XmlParser } from '@magic-xpa/utils';\r\nimport { ConstInterface } from '../ConstInterface';\r\nimport { Commands } from '@magic-xpa/gui';\r\n\r\n// This class is used to manage the user details on the client side.\r\n// The user details are sent from the server.\r\n// @dynamic\r\nexport class UserDetails {\r\n  private static _instance: UserDetails  = null;\r\n  UserName: string = null;  // user name obtained from the server.\r\n  UserID: string = null; // userID obtained from the server\r\n  UserInfo: string = null; // user info obtained from the server\r\n  Password: string = null; // Password obtained from server.\r\n  IsLoggedIn: boolean= false;\r\n\r\n  private setIsLoggedIn(value: boolean) {\r\n    this.IsLoggedIn = value;\r\n  }\r\n\r\n  getIsLoggedIn() {\r\n    return this.IsLoggedIn;\r\n  }\r\n\r\n  private setUserID(userId : string)\r\n  {\r\n    this.UserID = userId;\r\n    if ( this.UserID.length == 0 || this.UserID === NString.Empty){\r\n      this.setIsLoggedIn(false);\r\n    }\r\n    else\r\n      this.setIsLoggedIn(true);\r\n  }\r\n  static get Instance(): UserDetails {\r\n    if (UserDetails._instance === null)\r\n      UserDetails._instance = new UserDetails();\r\n    return UserDetails._instance;\r\n  }\r\n\r\n  /// <summary>Private CTOR as part of making this class a singleton/// </summary>\r\n  constructor() {\r\n    this.UserName = NString.Empty;\r\n    this.UserInfo = NString.Empty;\r\n    this.IsLoggedIn = false;\r\n    this.setUserID(NString.Empty);\r\n  }\r\n\r\n  /// <summary>\r\n  /// This function gets the xml tag containing user info.\r\n  /// </summary>\r\n  public fillData(parser: XmlParser): void {\r\n    //let parser: XmlParser = ClientManager.Instance.RuntimeCtx.Parser;\r\n    let tokensVector: List<string>;\r\n\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());\r\n    if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n      // last position of its tag\r\n      let tag: String = parser.getXMLsubstring(endContext);\r\n      parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_USER_DETAILS) + ConstInterface.MG_TAG_USER_DETAILS.length);\r\n      tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);\r\n      this.initElements(tokensVector);\r\n      parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length); // to delete \">\" too\r\n    }\r\n    else\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in UserDetails.fillData(): out of bounds\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"tokensVector\"></param>\r\n  /// <returns></returns>\r\n  private initElements(tokensVector: List<String>): boolean {\r\n    let attribute: String, valueStr;\r\n    let isSuccess: boolean = true;\r\n    let j: number;\r\n\r\n    for (j = 0; j < tokensVector.length; j += 2) {\r\n      attribute = (<String>tokensVector.get_Item(j));\r\n      valueStr = (<String>tokensVector.get_Item(j + 1));\r\n\r\n      switch (attribute) {\r\n        case ConstInterface.MG_TAG_IS_LOGGED_IN:\r\n          this.setIsLoggedIn(valueStr[0] === '1');\r\n          Commands.addIsLoggedIn(this.getIsLoggedIn());\r\n          //this.setIsLoggedIn(XmlParser.getBoolean(valueStr));\r\n          break;\r\n        // case ConstInterface.MG_TAG_USERNAME:\r\n        //   this.UserName = valueStr;\r\n        //   break;\r\n        // case ConstInterface.MG_ATTR_USERID:\r\n        //   valueStr = StrUtil.rtrim(valueStr);\r\n        //   this.setUserID(valueStr);\r\n        //   //ClientManager.Instance.setUsername(this.UserID);\r\n        //   break;\r\n        // case ConstInterface.MG_ATTR_USERINFO:\r\n        //   this.UserInfo = valueStr;\r\n        //   break;\r\n        // case ConstInterface.MG_TAG_PASSWORD:\r\n        //   this.Password = valueStr;\r\n        //   let passwordDecoded: Uint8Array = Base64.decodeToByte(this.Password);\r\n        //   let encryptedPassword: string = Encoding.UTF8.GetString(passwordDecoded, 0, passwordDecoded.length);\r\n        //   let decryptedPassword: string = Scrambler.UnScramble(encryptedPassword, 0, encryptedPassword.length - 1);\r\n        //   // At server side spaces are added at the end if the length of password is less than 4 characters.\r\n        //   // Remove these extra spaces before setting the password.\r\n        //   decryptedPassword = StrUtil.rtrim(decryptedPassword);\r\n        //   // if the password is empty set a password containing one \" \", as for userId, where if no userId\r\n        //   // then a \" \" set to userId.\r\n        //   if (NString.IsNullOrEmpty(decryptedPassword))\r\n        //     decryptedPassword = \" \";\r\n        //   //ClientManager.Instance.setPassword(decryptedPassword);\r\n        //   break;\r\n        default:\r\n          Logger.Instance.WriteExceptionToLogWithMsg(\"in UserDetails.initElements(): unknown attribute: \" + attribute);\r\n          isSuccess = false;\r\n          break;\r\n      }\r\n    }\r\n    return isSuccess;\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/src/tasks/IMGDataCollection.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,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