@magic-xpa/engine 4.1100.0-dev4110.106 → 4.1100.0-dev4110.109

package/esm2020/src/data/FieldBase.mjs

@@ -0,0 +1,18 @@
+import { GuiFieldBase } from "@magic-xpa/gui";
+export class FieldBase extends GuiFieldBase {
+    constructor() {
+        super(...arguments);
+        this.IsEventHandlerField = false;
+    }
+    async updateDisplay() {
+        return Promise.resolve();
+    }
+    async compute(recompute) {
+        return Promise.resolve();
+    }
+    async setValueAndStartRecompute(val, isNullFld, recompute, setRecordUpdated, isArgUpdate, enforceVariableChange) {
+        return Promise.resolve();
+    }
+}
+FieldBase.CLEAR_FLAGS = true;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/data/FieldsTable.mjs

@@ -0,0 +1,103 @@
+import { List } from "@magic-xpa/mscorelib";
+import { XMLConstants, Logger } from "@magic-xpa/utils";
+import { FieldDef, FieldsTable as FieldsTableBase } from "@magic-xpa/gui";
+import { Field } from "./Field";
+class FieldsTable extends FieldsTableBase {
+    constructor() {
+        super();
+        this._rmIdx = 0;
+        this._rmSize = -1;
+        this._serverRcmpDone = false;
+    }
+    fillData(parser, dataview) {
+        if (arguments.length === 2)
+            super.fillData(parser, dataview);
+        else {
+            while (this.initFields(parser.getNextTag(), parser)) {
+            }
+        }
+    }
+    initFields(foundTagName, parser) {
+        if (foundTagName == null)
+            return false;
+        if (foundTagName === XMLConstants.MG_TAG_FLDH) {
+            let item = this.initField(parser);
+            this._fields.push(item);
+        }
+        else {
+            return false;
+        }
+        return true;
+    }
+    initField(parser, dataview) {
+        if (arguments.length === 2)
+            return this.initField_0(dataview, parser);
+        else
+            return this.initField_1(parser);
+    }
+    initField_0(dataview, parser) {
+        let field = new Field(dataview, this._fields.length);
+        field.fillData(parser);
+        return field;
+    }
+    initField_1(parser) {
+        let fieldDef = new FieldDef(this._fields.length);
+        fieldDef.fillData(parser);
+        return fieldDef;
+    }
+    getRMSize() {
+        if (this._rmSize === -1)
+            return this._fields.length;
+        return this._rmSize;
+    }
+    getRMIdx() {
+        return this._rmIdx;
+    }
+    setRMPos(rms, idx) {
+        if (rms < 0 && this._rmSize !== -1) {
+            Logger.Instance.WriteExceptionToLogWithMsg("in FieldsTable.setRMSize(): illegal record main size: " + rms);
+        }
+        else if (this._rmSize >= 0) {
+            Logger.Instance.WriteExceptionToLogWithMsg("in FieldsTable.setRMSize(): record main size already set !");
+        }
+        else {
+            this._rmSize = rms;
+            this._rmIdx = idx;
+        }
+    }
+    getType(id) {
+        return super.getField(id).getType();
+    }
+    invalidate(forceInvalidate, clearFlags) {
+        for (let i = 0; i < this._fields.length; i++) {
+            let currField = this._fields[i];
+            currField.invalidate(forceInvalidate, clearFlags);
+        }
+    }
+    takeValsFromRec() {
+        for (let i = 0; i < this._fields.length; i++) {
+            let currField = this._fields[i];
+            currField.takeValFromRec();
+        }
+    }
+    serverRcmpDone() {
+        return this._serverRcmpDone;
+    }
+    setServerRcmp(val) {
+        this._serverRcmpDone = val;
+    }
+    getLinkFields(lnkId) {
+        let list = new List();
+        this._fields.forEach(field => {
+            if (field.getDataviewHeaderId() === lnkId) {
+                list.push(field);
+            }
+        });
+        return list;
+    }
+    resetRecomp() {
+        this._fields.forEach(field => field.setRecompute(null));
+    }
+}
+export { FieldsTable as FieldsTableExt };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FieldsTable.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/data/FieldsTable.ts"],"names":[],"mappings":"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","sourcesContent":["/// <summary>\r\n///   data for <dvheader ...>...</dvheader>\r\n/// </summary>\r\nimport {List} from \"@magic-xpa/mscorelib\";\r\nimport {XMLConstants, StorageAttribute, Logger, XmlParser} from \"@magic-xpa/utils\";\r\nimport {FieldDef, GuiDataViewBase, FieldsTable as FieldsTableBase} from \"@magic-xpa/gui\";\r\nimport {Field} from \"./Field\";\r\nimport {DataView} from \"./DataView\";\r\n\r\n class FieldsTable  extends FieldsTableBase {\r\n  private _rmIdx: number = 0;\r\n  private _rmSize: number = -1;\r\n  private _serverRcmpDone: boolean = false;\r\n\r\n  constructor(){\r\n    super();\r\n  }\r\n  /// <summary>\r\n  ///   a different version of fill data in order to be used in table cache\r\n  /// </summary>\r\n  fillData(parser: XmlParser, dataview?: GuiDataViewBase): void {\r\n    if (arguments.length === 2)\r\n      super.fillData(parser, dataview);\r\n    else {\r\n      while (this.initFields(parser.getNextTag(), parser)) {\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary></summary>\r\n  /// <param name=\"foundTagName\"></param>\r\n  /// <returns></returns>\r\n  private initFields(foundTagName: string, parser: XmlParser): boolean {\r\n    if (foundTagName == null)\r\n      return false;\r\n\r\n    if (foundTagName === XMLConstants.MG_TAG_FLDH) {\r\n      let item: FieldDef = this.initField(parser);\r\n      this._fields.push(item);\r\n    }\r\n    else {\r\n      // ClientManager.Instance.WriteErrorToLog(\"in FieldsTable.initFields() only field tag are allowed to be parsed at this instance\");\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  initField(parser: XmlParser, dataview: GuiDataViewBase): FieldDef;\r\n  initField(parser: XmlParser): FieldDef;\r\n  initField(parser: XmlParser, dataview?: GuiDataViewBase): FieldDef {\r\n    if (arguments.length === 2)\r\n      return this.initField_0(dataview, parser);\r\n    else\r\n      return this.initField_1(parser);\r\n  }\r\n\r\n  /// <summary>\r\n  /// create a field and fill it by data\r\n  /// </summary>\r\n  /// <param name = \"dataview\"> Dataview </param>\r\n  /// <returns> the created filled field </returns>\r\n  private initField_0(dataview: GuiDataViewBase, parser: XmlParser): FieldDef {\r\n    let field: Field = new Field(<DataView>dataview, this._fields.length);\r\n    field.fillData(parser);\r\n    return field;\r\n  }\r\n\r\n/// <summary>\r\n  /// create a field and fill it by data\r\n  /// </summary>\r\n  /// <returns> the created filled field </returns>\r\n  private initField_1(parser: XmlParser): FieldDef {\r\n    let fieldDef: FieldDef = new FieldDef(this._fields.length);\r\n    fieldDef.fillData(parser);\r\n    return fieldDef;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the number of fields in the Record Main\r\n  /// </summary>\r\n  getRMSize(): number {\r\n    if (this._rmSize === -1)\r\n      return this._fields.length;\r\n    return this._rmSize;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   the index of the first field in the record main\r\n  /// </summary>\r\n  getRMIdx(): number {\r\n    return this._rmIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set Record Main size\r\n  /// </summary>\r\n  /// <param name = \"rms\">the new record main size</param>\r\n  /// <param name = \"idx\">the index of the first field in the record main</param>\r\n  setRMPos(rms: number, idx: number): void {\r\n    if (rms < 0 && this._rmSize !== -1) {\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in FieldsTable.setRMSize(): illegal record main size: \" + rms);\r\n    }\r\n    else if (this._rmSize >= 0) {\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in FieldsTable.setRMSize(): record main size already set !\");\r\n    }\r\n    else {\r\n      this._rmSize = rms;\r\n      this._rmIdx = idx;\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   get the type of field by its index\r\n  /// </summary>\r\n  /// <param name = \"id\">the id of the field</param>\r\n  /// <returns> type of the requested field</returns>\r\n  getType(id: number): StorageAttribute {\r\n    return super.getField(id).getType();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   invalidate some or all fields in the table\r\n  /// </summary>\r\n  /// <param name = \"forceInvalidate\">if true then force the invalidation of all the fields</param>\r\n  /// <param name=\"clearFlags\"></param>\r\n  invalidate(forceInvalidate: boolean, clearFlags: boolean): void {\r\n    for(let i = 0 ; i < this._fields.length ; i++)\r\n    {\r\n      let currField = this._fields[i];\r\n      (<Field>currField).invalidate(forceInvalidate, clearFlags);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   take the value of the fields from the current record\r\n  /// </summary>\r\n  takeValsFromRec(): void {\r\n    for(let i = 0 ; i < this._fields.length ; i++) {\r\n      let currField = this._fields[i];\r\n      (<Field>currField).takeValFromRec()\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return TRUE if we went to the server during a field's compute\r\n  /// </summary>\r\n  serverRcmpDone(): boolean {\r\n    return this._serverRcmpDone;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of the \"we went to the server for rcmp\" indication\r\n  /// </summary>\r\n  /// <param name = \"val\">new value</param>\r\n  setServerRcmp(val: boolean): void {\r\n    this._serverRcmpDone = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return a vector of all fields in the table that belongs to a given link\r\n  /// </summary>\r\n  /// <param name = \"lnkId\">the id of the link</param>\r\n  getLinkFields(lnkId: number): List<Field> {\r\n    let list: List<Field> = new List<Field>();\r\n\r\n    this._fields.forEach(field => {\r\n      if ((<Field>field).getDataviewHeaderId() === lnkId) {\r\n        list.push(<Field>field);\r\n      }\r\n    });\r\n    return list;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  resetRecomp(): void {\r\n    this._fields.forEach(field => (<Field>field).setRecompute(null));\r\n  }\r\n}\r\n\r\nexport  {FieldsTable as FieldsTableExt }\r\n"]}

package/esm2020/src/data/IRecordsTable.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSVJlY29yZHNUYWJsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2VuZ2luZS9zcmMvZGF0YS9JUmVjb3Jkc1RhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1JlY29yZH0gZnJvbSAnLi9SZWNvcmQnO1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBJUmVjb3Jkc1RhYmxlIHtcclxuICBHZXRTaXplKCk6IG51bWJlcjtcclxuXHJcbiAgR2V0UmVjQnlJZHgoaWR4OiBudW1iZXIpOiBSZWNvcmQ7XHJcblxyXG4gIFJlbW92ZUFsbCgpOiB2b2lkO1xyXG5cclxuICBnZXRSZWNJZHgoaWQ6IG51bWJlcik6IG51bWJlcjtcclxufVxyXG4iXX0=

package/esm2020/src/data/Key.mjs

@@ -0,0 +1,88 @@
+import { List, NString } from "@magic-xpa/mscorelib";
+import { Logger, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { ConstInterface } from "../ConstInterface";
+export class Key {
+    constructor(ownerTable) {
+        this.Columns = null;
+        this._table = null;
+        this._id = 0;
+        this._table = ownerTable;
+        this.Columns = new List();
+    }
+    FillData(parser) {
+        this.FillAttributes(parser);
+        while (this.InitInnerObjects(parser, parser.getNextTag())) {
+        }
+    }
+    FillAttributes(parser) {
+        let tokensVector;
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());
+        let tag;
+        let attribute;
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_ATTR_KEY) + ConstInterface.MG_ATTR_KEY.length);
+            tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            for (let j = 0; j < tokensVector.length; j += 2) {
+                attribute = (tokensVector.get_Item(j));
+                let valueStr = (tokensVector.get_Item(j + 1));
+                if (attribute === XMLConstants.MG_ATTR_ID)
+                    this._id = XmlParser.getInt(valueStr);
+                else if (attribute === XMLConstants.MG_ATTR_TYPE)
+                    Logger.Instance.WriteDevToLog("in Key.fillAttributes() obsolete attribute (TODO: remove from server)" + attribute);
+                else
+                    Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unrecognized attribute: '{0}'", attribute));
+            }
+            parser.setCurrIndex(++endContext);
+            return;
+        }
+        Logger.Instance.WriteExceptionToLogWithMsg("in Key.fillAttributes() out of string bounds");
+    }
+    InitElements(tokensVector) {
+        for (let j = 0; j < tokensVector.length; j = j + 2) {
+            let attribute = tokensVector.get_Item(j);
+            let valueStr = tokensVector.get_Item(j + 1);
+            switch (attribute) {
+                case XMLConstants.MG_ATTR_ID:
+                    this.Columns.push(this._table.FldsTab.getField(XmlParser.getInt(valueStr)));
+                    break;
+                case XMLConstants.MG_ATTR_SIZE:
+                    break;
+                case ConstInterface.MG_ATTR_DIR:
+                    break;
+                default:
+                    Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unrecognized attribute: '{0}'", attribute));
+                    break;
+            }
+        }
+    }
+    InitInnerObjects(parser, foundTagName) {
+        if (foundTagName === null)
+            return false;
+        if (foundTagName === ConstInterface.MG_TAG_COLUMN) {
+            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_COLUMN) + ConstInterface.MG_TAG_COLUMN.length);
+                let tokens = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+                this.InitElements(tokens);
+                parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
+            }
+            else
+                Logger.Instance.WriteExceptionToLogWithMsg("in Key.initInnerObjects() out of string bounds");
+        }
+        else if (foundTagName === '/' + ConstInterface.MG_ATTR_KEY) {
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        else {
+            Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in LinksTable.initInnerObjects(): " + foundTagName);
+            return false;
+        }
+        return true;
+    }
+    GetKeyId() {
+        return this._id;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Key.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/data/Key.ts"],"names":[],"mappings":"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","sourcesContent":["import {TableCache} from \"../rt/TableCache\";\r\nimport {List, NString} from \"@magic-xpa/mscorelib\";\r\nimport {FieldDef} from \"@magic-xpa/gui\";\r\nimport {Logger, XMLConstants, XmlParser} from \"@magic-xpa/utils\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\n\r\n/// <summary>\r\n///   represents a table key and all it segments\r\n/// </summary>\r\nexport class Key {\r\n  Columns: List<FieldDef> = null;  // a vector of Field object representing the fields of the table\r\n  private _table: TableCache = null;\r\n  private _id: number = 0;\r\n\r\n  constructor(ownerTable: TableCache) {\r\n    this._table = ownerTable;\r\n    this.Columns = new List<FieldDef>();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parses the data of this key\r\n  /// </summary>\r\n  FillData(parser: XmlParser): void {\r\n    // fills the attributes of the key tag itself\r\n    this.FillAttributes(parser);\r\n    // init the inner objects mainly the segments of the key - represented as columns xml tags\r\n    while (this.InitInnerObjects(parser, parser.getNextTag())) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parses the attributes of the key actually there are only two id and type (at the moment)\r\n  /// </summary>\r\n  private FillAttributes(parser: XmlParser): void {\r\n    let tokensVector: List<string>;\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());\r\n    let tag: String;\r\n    let attribute: String;\r\n\r\n    if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n      // last position of its tag\r\n      tag = parser.getXMLsubstring(endContext);\r\n\r\n      parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_ATTR_KEY) + ConstInterface.MG_ATTR_KEY.length);\r\n\r\n      tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);\r\n\r\n      // parse the key attributes\r\n      for (let j: number = 0; j < tokensVector.length; j += 2) {\r\n        attribute = (tokensVector.get_Item(j));\r\n        let valueStr: string = (tokensVector.get_Item(j + 1));\r\n\r\n        if (attribute === XMLConstants.MG_ATTR_ID)\r\n          this._id = XmlParser.getInt(valueStr);\r\n        else if (attribute === XMLConstants.MG_ATTR_TYPE)\r\n          Logger.Instance.WriteDevToLog(\"in Key.fillAttributes() obsolete attribute (TODO: remove from server)\" + attribute);\r\n        else\r\n          Logger.Instance.WriteExceptionToLogWithMsg(NString.Format(\"Unrecognized attribute: '{0}'\", attribute));\r\n      }\r\n      parser.setCurrIndex(++endContext);  // to delete \">\" too\r\n      return;\r\n    }\r\n    Logger.Instance.WriteExceptionToLogWithMsg(\"in Key.fillAttributes() out of string bounds\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///   used to parse each column xml tag attributes the column represents a segment in the key\r\n  /// </summary>\r\n  private InitElements(tokensVector: List<string>): void {\r\n\r\n    for (let j: number = 0; j < tokensVector.length; j = j + 2) {\r\n\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          this.Columns.push(this._table.FldsTab.getField(XmlParser.getInt(valueStr)));\r\n          break;\r\n        case XMLConstants.MG_ATTR_SIZE:\r\n          break;\r\n        case ConstInterface.MG_ATTR_DIR:\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  }\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    if (foundTagName === ConstInterface.MG_TAG_COLUMN) {\r\n      let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());\r\n\r\n      if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n\r\n        // last position of its tag\r\n        let tag: string = parser.getXMLsubstring(endContext);\r\n        parser.add2CurrIndex(tag.indexOf( ConstInterface.MG_TAG_COLUMN) + ConstInterface.MG_TAG_COLUMN.length);\r\n\r\n        let tokens: List<string> = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM)/*'\"'*/;\r\n        // parse each column\r\n        this.InitElements(tokens);\r\n        parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length); // to delete \"/>\" too\r\n      }\r\n      else\r\n        Logger.Instance.WriteExceptionToLogWithMsg(\"in Key.initInnerObjects() out of string bounds\");\r\n    }\r\n    else if (foundTagName === '/' + ConstInterface.MG_ATTR_KEY) {\r\n      parser.setCurrIndex2EndOfTag();\r\n      return false;\r\n    }\r\n    else {\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such tag in LinksTable.initInnerObjects(): \" + foundTagName);\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the key id\r\n  /// </summary>\r\n  GetKeyId(): number {\r\n    return this._id;\r\n  }\r\n}\r\n"]}