@magic-xpa/engine 4.801.0-dev481.244 → 4.801.0-dev481.250

package/esm2020/src/exp/GlobalParamsTable.mjs

@@ -0,0 +1,85 @@
+import { NString } from "@magic-xpa/mscorelib";
+import { StorageAttribute, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { ExpVal, RecordUtils } from "@magic-xpa/gui";
+import { MirrorPrmMap } from "../util/PrmMap";
+import { ParamParseResult } from '../util/ParamParseResult';
+import { ConstInterface } from "../ConstInterface";
+import { Environment } from "../env/Environment";
+export class MirrorExpVal extends ExpVal {
+    constructor(val) {
+        if (arguments.length === 0) {
+            super();
+            this.constructor_2();
+            return;
+        }
+        super();
+        this.constructor_3(val);
+    }
+    constructor_2() {
+    }
+    constructor_3(val) {
+        super.Copy(val);
+    }
+    mirrorToXML() {
+        let toBase64 = (Environment.Instance.GetDebugLevel() <= 1);
+        let cellAttr = (this.Attr === StorageAttribute.BLOB_VECTOR ? this.VectorField.getCellsType() : StorageAttribute.SKIP);
+        let value = "";
+        value = RecordUtils.itemValToXML(super.ToMgVal(), this.Attr, cellAttr, toBase64);
+        return ConstInterface.MG_ATTR_PAR_ATTRS + "=\"" + this.Attr + "\" " + ConstInterface.MG_ATTR_LEN + "=" +
+            value.length + " " + ConstInterface.MG_ATTR_ENV_VALUE + "=\"" + value + "\"";
+    }
+    init(name, xmlParser) {
+        let valueOffset, attrOffset, lenOffset, valueLen, lenOffsetEnd, count;
+        let currType;
+        let isNull;
+        let paramAttr, paramValue, correctValue = null;
+        count = xmlParser.getXMLdata().indexOf(XMLConstants.TAG_TERM, xmlParser.getCurrIndex()) - xmlParser.getCurrIndex();
+        attrOffset = NString.IndexOf(xmlParser.getXMLdata(), ConstInterface.MG_ATTR_PAR_ATTRS, xmlParser.getCurrIndex(), count);
+        if (attrOffset !== -1) {
+            attrOffset += ConstInterface.MG_ATTR_PAR_ATTRS.length + 2;
+            paramAttr = xmlParser.getXMLdata().substr(attrOffset, 1);
+            lenOffset = xmlParser.getXMLdata().indexOf(ConstInterface.MG_ATTR_LEN, attrOffset);
+            lenOffset += ConstInterface.MG_ATTR_LEN.length + 1;
+            lenOffsetEnd = xmlParser.getXMLdata().indexOf(" ", lenOffset);
+            valueLen = XmlParser.getInt(xmlParser.getXMLdata().substr(lenOffset, lenOffsetEnd - lenOffset));
+            valueOffset = xmlParser.getXMLdata().indexOf(ConstInterface.MG_ATTR_ENV_VALUE, lenOffset);
+            valueOffset += ConstInterface.MG_ATTR_ENV_VALUE.length + 2;
+            paramValue = xmlParser.getXMLdata().substr(valueOffset, valueLen);
+            currType = paramAttr[0];
+            correctValue = RecordUtils.getString(paramValue, currType);
+            isNull = false;
+            xmlParser.setCurrIndex(valueOffset + valueLen);
+        }
+        else if (xmlParser.getXMLdata().indexOf(ConstInterface.MG_ATTR_ENV_REMOVED, xmlParser.getCurrIndex()) !== -1) {
+            return ParamParseResult.DELETE;
+        }
+        else {
+            currType = StorageAttribute.NONE;
+            isNull = true;
+        }
+        super.Init(currType, isNull, correctValue);
+        return ParamParseResult.TOUPPER;
+    }
+}
+export class GlobalParams extends MirrorPrmMap {
+    constructor() {
+        super(MirrorExpVal);
+        this.mirroredID = ConstInterface.MG_TAG_GLOBALPARAMSCHANGES;
+    }
+    set(s, v) {
+        if (v.IsNull || v.isEmptyString())
+            super.remove(s.trim().toUpperCase());
+        else
+            super.setValue(s.trim().toUpperCase(), new MirrorExpVal(v));
+    }
+    get(s) {
+        try {
+            return super.getvalue(s.trim().toUpperCase());
+        }
+        catch (err) {
+            return null;
+        }
+    }
+}
+GlobalParams.Instance = new GlobalParams();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GlobalParamsTable.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/exp/GlobalParamsTable.ts"],"names":[],"mappings":"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","sourcesContent":["import {NString} from \"@magic-xpa/mscorelib\";\r\nimport {StorageAttribute, XMLConstants, XmlParser} from \"@magic-xpa/utils\";\r\nimport { ExpVal, RecordUtils } from \"@magic-xpa/gui\";\r\nimport {IMirrorXML} from \"../util/IMirrorXML\";\r\nimport {MirrorPrmMap} from \"../util/PrmMap\";\r\nimport {ParamParseResult} from  '../util/ParamParseResult'\r\nimport {ConstInterface} from \"../ConstInterface\";\r\nimport { Environment } from \"../env/Environment\";\r\n\r\nexport class MirrorExpVal extends ExpVal implements IMirrorXML {\r\n  constructor();\r\n  constructor(val: ExpVal);\r\n  constructor(val?: ExpVal) {\r\n    if (arguments.length === 0) {\r\n      super();\r\n      this.constructor_2();\r\n      return;\r\n    }\r\n    super();\r\n    this.constructor_3(val);\r\n  }\r\n\r\n  private constructor_2(): void {\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  private constructor_3(val: ExpVal): void {\r\n    super.Copy(val);\r\n  }\r\n\r\n  public mirrorToXML(): string {\r\n    let toBase64: boolean = (Environment.Instance.GetDebugLevel() <= 1);\r\n\r\n    let cellAttr: StorageAttribute = (this.Attr === StorageAttribute.BLOB_VECTOR ? this.VectorField.getCellsType() : StorageAttribute.SKIP);\r\n\r\n    // Story 131961 : Do not serialize dotnet params\r\n    let value: string = \"\";\r\n    value = RecordUtils.itemValToXML(super.ToMgVal(), this.Attr, cellAttr, toBase64);\r\n\r\n    return ConstInterface.MG_ATTR_PAR_ATTRS + \"=\\\"\" + this.Attr + \"\\\" \" + ConstInterface.MG_ATTR_LEN + \"=\" +\r\n      value.length + \" \" + ConstInterface.MG_ATTR_ENV_VALUE + \"=\\\"\" + value + \"\\\"\";\r\n  }\r\n\r\n  /// <summary>\r\n  ///   initialize the object from the XML buffer\r\n  /// </summary>\r\n  /// <param name = \"xmlParser\"></param>\r\n  public init(name: String, xmlParser: XmlParser): ParamParseResult {\r\n    let valueOffset: number, attrOffset: number, lenOffset: number, valueLen: number, lenOffsetEnd: number,\r\n      count: number;\r\n    let currType: StorageAttribute;\r\n    let isNull: boolean;\r\n    let paramAttr: string, paramValue: string, correctValue: string = null;\r\n\r\n    // Look for parameter attributes. Xml parser's current index is set to end of Name.\r\n    // So look for attribute (i.e. \"attr\") from current index to the end of tag (i.e. \"/>\")\r\n    count = xmlParser.getXMLdata().indexOf(XMLConstants.TAG_TERM, xmlParser.getCurrIndex()) - xmlParser.getCurrIndex();\r\n    attrOffset = NString.IndexOf(xmlParser.getXMLdata(), ConstInterface.MG_ATTR_PAR_ATTRS, xmlParser.getCurrIndex(), count);\r\n    if (attrOffset !== -1) {\r\n      // add tag length and get the attribute\r\n      attrOffset += ConstInterface.MG_ATTR_PAR_ATTRS.length + 2;\r\n      paramAttr = xmlParser.getXMLdata().substr(attrOffset, 1);\r\n\r\n      // length of value\r\n      lenOffset = xmlParser.getXMLdata().indexOf(ConstInterface.MG_ATTR_LEN, attrOffset);\r\n      lenOffset += ConstInterface.MG_ATTR_LEN.length + 1;\r\n      lenOffsetEnd = xmlParser.getXMLdata().indexOf(\" \", lenOffset);\r\n      valueLen = XmlParser.getInt(xmlParser.getXMLdata().substr(lenOffset, lenOffsetEnd - lenOffset));\r\n\r\n      // param value\r\n      valueOffset = xmlParser.getXMLdata().indexOf(ConstInterface.MG_ATTR_ENV_VALUE, lenOffset);\r\n      valueOffset += ConstInterface.MG_ATTR_ENV_VALUE.length + 2;\r\n      paramValue = xmlParser.getXMLdata().substr(valueOffset, valueLen);\r\n\r\n      // get data for this object\r\n      currType = <StorageAttribute>paramAttr[0];\r\n      correctValue = RecordUtils.getString(paramValue, currType);\r\n      isNull = false;\r\n\r\n      // skip to after this param\r\n      xmlParser.setCurrIndex(valueOffset + valueLen);\r\n    }\r\n    else if (xmlParser.getXMLdata().indexOf(ConstInterface.MG_ATTR_ENV_REMOVED, xmlParser.getCurrIndex()) !== -1) {\r\n      return ParamParseResult.DELETE;\r\n    }\r\n    else {\r\n      currType = StorageAttribute.NONE;\r\n      isNull = true;\r\n    }\r\n\r\n    super.Init(currType, isNull, correctValue);\r\n\r\n    return ParamParseResult.TOUPPER;\r\n  }\r\n}\r\n\r\n/// <summary>\r\n///   manager for global parameters\r\n/// </summary>\r\nexport class GlobalParams extends MirrorPrmMap<MirrorExpVal> {\r\n\r\n  static Instance: GlobalParams = new GlobalParams();\r\n  /// <summary>\r\n  ///  CTOR\r\n  /// </summary>\r\n  private constructor() {\r\n    super(MirrorExpVal);\r\n    this.mirroredID = ConstInterface.MG_TAG_GLOBALPARAMSCHANGES;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   create a new MirrorExpVal and add it to the map\r\n  /// </summary>\r\n  /// <param name = \"s\"></param>\r\n  /// <param name = \"v\"></param>\r\n  public set(s: string, v: ExpVal): void {\r\n    if (v.IsNull || v.isEmptyString())\r\n      super.remove(s.trim().toUpperCase());\r\n    else\r\n      super.setValue(s.trim().toUpperCase(), new MirrorExpVal(v));\r\n  }\r\n\r\n  public get(s: string): MirrorExpVal {\r\n    try {\r\n      return super.getvalue(s.trim().toUpperCase());\r\n    }\r\n    catch (err) {\r\n      return null;\r\n    }\r\n\r\n  }\r\n}\r\n"]}

package/esm2020/src/exp/YesNoExp.mjs

@@ -0,0 +1,41 @@
+import { XmlParser, StorageAttribute } from "@magic-xpa/utils";
+import { DisplayConvertor } from "@magic-xpa/gui";
+export class YesNoExp {
+    constructor(defaultVal) {
+        this._exp = null;
+        this._val = false;
+        this._val = defaultVal;
+        this._exp = null;
+    }
+    setVal(task, strVal) {
+        switch (strVal[0]) {
+            case 'Y':
+                this._val = true;
+                break;
+            case 'N':
+                this._val = false;
+                break;
+            default:
+                let expId = XmlParser.getInt(strVal);
+                if (task != null)
+                    this._exp = task.getExpById(expId);
+                break;
+        }
+    }
+    async getVal() {
+        if (this._exp !== null)
+            return await DisplayConvertor.toBoolean(await this._exp.evaluateWithResultTypeAndLength(StorageAttribute.BOOLEAN, 0));
+        return this._val;
+    }
+    isServerExp() {
+        if (this._exp != null)
+            return this._exp.computedByServerOnly();
+        return false;
+    }
+    isClientExp() {
+        if (this._exp != null)
+            return this._exp.computedByClientOnly();
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/gui/FormsTable.mjs

@@ -0,0 +1,66 @@
+import { List } from "@magic-xpa/mscorelib";
+import { XMLConstants } from "@magic-xpa/utils";
+import { Manager, RuntimeContextBase } from "@magic-xpa/gui";
+import { RemoteTaskService } from "../tasks/RemoteTaskService";
+export class FormsTable {
+    constructor(task, parentForm) {
+        this._task = null;
+        this._parentForm = null;
+        this._formsStringXml = null;
+        this._task = task;
+        this._parentForm = parentForm;
+    }
+    get Count() {
+        return this._formsStringXml.length;
+    }
+    get_Item(formDisplayIndex) {
+        if (formDisplayIndex > 0 && formDisplayIndex <= this._formsStringXml.length)
+            return this._formsStringXml.get_Item(formDisplayIndex - 1);
+        return null;
+    }
+    async fillData() {
+        this._formsStringXml = new List();
+        let parser = Manager.GetCurrentRuntimeContext().Parser;
+        while (await this.initInnerObjects(parser.getNextTag())) {
+        }
+    }
+    InitFormFromXmlString(formDisplayIndex) {
+        let formStrXml = this.get_Item(1);
+        if (formDisplayIndex > 0 && formDisplayIndex <= this._formsStringXml.length)
+            formStrXml = this.get_Item(formDisplayIndex);
+        if (formStrXml !== null) {
+            RuntimeContextBase.Instance.Parser.push();
+            RuntimeContextBase.Instance.Parser.PrepareFormReadString(formStrXml);
+            this._task.FormInitData(this._parentForm);
+            RuntimeContextBase.Instance.Parser.pop();
+        }
+    }
+    async initInnerObjects(foundTagName) {
+        if (foundTagName === null)
+            return false;
+        let parser = Manager.GetCurrentRuntimeContext().Parser;
+        if (foundTagName === XMLConstants.MG_TAG_FORMS) {
+            parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+        }
+        else if (foundTagName === XMLConstants.MG_TAG_FORM) {
+            let formStringXml = RuntimeContextBase.Instance.Parser.ReadToEndOfCurrentElement();
+            this._formsStringXml.push(formStringXml);
+            return true;
+        }
+        else if (foundTagName === ('/' + XMLConstants.MG_TAG_FORM)) {
+            parser.setCurrIndex2EndOfTag();
+            return true;
+        }
+        else if (foundTagName === ('/' + XMLConstants.MG_TAG_FORMS)) {
+            await this.PrepareMainDisplayForConnectedTask();
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        return true;
+    }
+    async PrepareMainDisplayForConnectedTask() {
+        if (this._task.TaskService instanceof RemoteTaskService)
+            await this._task.PrepareTaskForm();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FormsTable.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/gui/FormsTable.ts"],"names":[],"mappings":"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","sourcesContent":["import {List} from \"@magic-xpa/mscorelib\";\r\nimport {XmlParser, XMLConstants} from \"@magic-xpa/utils\";\r\nimport {Manager, MgFormBase, RuntimeContextBase} from \"@magic-xpa/gui\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {RemoteTaskService} from \"../tasks/RemoteTaskService\";\r\n\r\n/// <summary>\r\n/// save all forms on task\r\n/// </summary>\r\nexport class FormsTable {\r\n  private _task: Task = null;\r\n  private _parentForm: MgFormBase = null;\r\n  _formsStringXml: List<string> = null;\r\n\r\n  /// <summary>\r\n  /// count of forms\r\n  /// </summary>\r\n  get Count(): number {\r\n    return this._formsStringXml.length;\r\n  }\r\n\r\n  /// <summary>\r\n  /// return the form by send the display index\r\n  /// </summary>\r\n  /// <param name=\"formDisplayIndex\"></param>\r\n  /// <returns></returns>\r\n  get_Item(formDisplayIndex: number): string {\r\n    if (formDisplayIndex > 0 && formDisplayIndex <= this._formsStringXml.length)\r\n      return this._formsStringXml.get_Item(formDisplayIndex - 1);\r\n\r\n    return null;\r\n  }\r\n\r\n  constructor(task: Task, parentForm: MgFormBase) {\r\n    this._task = task;\r\n    this._parentForm = parentForm;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse the form structure\r\n  /// </summary>\r\n  /// <param name = \"taskRef\">reference to the ownerTask of this form</param>\r\n  async fillData(): Promise<void> {\r\n    this._formsStringXml = new List();\r\n\r\n    let parser: XmlParser = Manager.GetCurrentRuntimeContext().Parser;\r\n\r\n    while (await this.initInnerObjects(parser.getNextTag())) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// init the form of the task\r\n  /// </summary>\r\n  /// <param name=\"formDisplayIndex\"></param>\r\n  InitFormFromXmlString(formDisplayIndex: number): void {\r\n    // while the form isn't exist the first form will be open. (it is the same in non offline task)\r\n    let formStrXml: string = this.get_Item(1);\r\n\r\n    if (formDisplayIndex > 0 && formDisplayIndex <= this._formsStringXml.length)\r\n      formStrXml = this.get_Item(formDisplayIndex);\r\n\r\n    if (formStrXml !== null) {\r\n      RuntimeContextBase.Instance.Parser.push(); // allow recursive parsing\r\n      RuntimeContextBase.Instance.Parser.PrepareFormReadString(formStrXml);\r\n\r\n      this._task.FormInitData(this._parentForm);\r\n      RuntimeContextBase.Instance.Parser.pop();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   To allocate and fill inner objects of the class\r\n  /// </summary>\r\n  /// <param name=\"foundTagName\"></param>\r\n  /// <returns></returns>\r\n  private async initInnerObjects(foundTagName: string): Promise<boolean> {\r\n    if (foundTagName === null)\r\n      return false;\r\n\r\n    let parser: XmlParser = Manager.GetCurrentRuntimeContext().Parser;\r\n    if (foundTagName === XMLConstants.MG_TAG_FORMS) {\r\n      parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1); // move Index to end of <dvheader> +1 for '>'\r\n    }\r\n    else if (foundTagName === XMLConstants.MG_TAG_FORM) {\r\n      let formStringXml: string = RuntimeContextBase.Instance.Parser.ReadToEndOfCurrentElement();\r\n      this._formsStringXml.push(formStringXml);\r\n      return true;\r\n    }\r\n    else if (foundTagName === ('/' + XMLConstants.MG_TAG_FORM)) {\r\n      parser.setCurrIndex2EndOfTag();\r\n      return true;\r\n    }\r\n    else if (foundTagName === ('/' + XMLConstants.MG_TAG_FORMS)) {\r\n      await this.PrepareMainDisplayForConnectedTask();\r\n\r\n      parser.setCurrIndex2EndOfTag();\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  /// for remote task we have all the information that we need to calculate the form display\r\n  /// </summary>\r\n  private async PrepareMainDisplayForConnectedTask(): Promise<void> {\r\n    if (this._task.TaskService instanceof RemoteTaskService)\r\n      await this._task.PrepareTaskForm();\r\n  }\r\n}\r\n"]}