@magic-xpa/gui 4.1100.0-dev4110.106 → 4.1100.0-dev4110.108

package/esm2020/src/management/data/DcValuesBuilderBase.mjs

@@ -0,0 +1,96 @@
+import { DcValues } from './DcValues';
+import { List, NNumber, NumberStyles, StringBuilder } from '@magic-xpa/mscorelib';
+import { Base64, StorageAttribute } from '@magic-xpa/utils';
+import { RecordUtils } from './RecordUtils';
+import { GuiEnvironment } from '../../GuiEnvironment';
+export class DcValuesBuilderBase {
+    CreateDcValues() {
+        return new DcValues(false);
+    }
+    SetId(dcValues, newId) {
+        dcValues.SetID(newId);
+    }
+    SetType(dcValues, type) {
+        dcValues.setType(type);
+    }
+    SetDisplayValues(dcValues, displayValues) {
+        dcValues.SetDisplayValues(displayValues);
+    }
+    SetLinkValues(dcValues, linkValues) {
+        dcValues.SetLinkValues(linkValues);
+    }
+    SetNullFlags(dcValues, nullFlagsStringOrNullFlags) {
+        if (arguments.length === 2 && (dcValues === null || dcValues instanceof DcValues) && (nullFlagsStringOrNullFlags === null || nullFlagsStringOrNullFlags.constructor === String)) {
+            this.SetNullFlags_0(dcValues, nullFlagsStringOrNullFlags);
+            return;
+        }
+        this.SetNullFlags_1(dcValues, nullFlagsStringOrNullFlags);
+    }
+    SetNullFlags_0(dcValues, nullFlagsString) {
+        let nullFlags = this.ParseNullFlags(nullFlagsString);
+        dcValues.setNullFlags(nullFlags);
+    }
+    SetNullFlags_1(dcValues, nullFlags) {
+        dcValues.setNullFlags(nullFlags);
+    }
+    ParseValues(valueStr, dataType, useHex) {
+        let snumber;
+        let tmpValue = null;
+        let buffer = new List();
+        let len;
+        let nextIdx;
+        let endIdx;
+        let suffixBuf = null;
+        switch (dataType) {
+            case StorageAttribute.NUMERIC:
+            case StorageAttribute.DATE:
+            case StorageAttribute.TIME:
+                if (useHex)
+                    len = GuiEnvironment.Environment.GetSignificantNumSize() * 2;
+                else
+                    len = Math.floor((GuiEnvironment.Environment.GetSignificantNumSize() + 2) / 3) * 4;
+                break;
+            case StorageAttribute.BOOLEAN:
+                len = 1;
+                break;
+            default:
+                len = 0;
+                break;
+        }
+        nextIdx = 0;
+        while (nextIdx < valueStr.length) {
+            if (dataType === StorageAttribute.ALPHA || dataType === StorageAttribute.UNICODE ||
+                dataType === StorageAttribute.BLOB || dataType === StorageAttribute.BLOB_VECTOR) {
+                snumber = valueStr.substr(nextIdx, 4);
+                len = NNumber.Parse(snumber, NumberStyles.HexNumber);
+                nextIdx += 4;
+            }
+            if (len >= 0x8000) {
+                suffixBuf = new StringBuilder();
+                len -= 0x8000;
+                nextIdx += RecordUtils.getSpannedField(valueStr, len, nextIdx, dataType, suffixBuf, useHex);
+                buffer.push(suffixBuf.ToString());
+            }
+            else {
+                endIdx = nextIdx + len;
+                if (useHex)
+                    tmpValue = valueStr.substr(nextIdx, (endIdx) - (nextIdx));
+                else
+                    tmpValue = Base64.decodeToHex(valueStr.substr(nextIdx, (endIdx) - (nextIdx)));
+                buffer.push(tmpValue);
+                nextIdx = endIdx;
+            }
+        }
+        return buffer.ToArray();
+    }
+    ParseNullFlags(nullFlagsString) {
+        let array = new Array(nullFlagsString.length);
+        for (let i = 0; i < nullFlagsString.length; i = i + 1) {
+            array[i] = (nullFlagsString.charAt(i) !== '0');
+        }
+        return array;
+    }
+    constructor() {
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DcValuesBuilderBase.js","sourceRoot":"","sources":["../../../../../../../projects/gui/src/management/data/DcValuesBuilderBase.ts"],"names":[],"mappings":"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","sourcesContent":["import {DcValues} from './DcValues';\r\nimport {List, NNumber, NumberStyles, StringBuilder} from '@magic-xpa/mscorelib';\r\nimport {Base64, StorageAttribute} from '@magic-xpa/utils';\r\nimport {RecordUtils} from './RecordUtils';\r\nimport {GuiEnvironment} from '../../GuiEnvironment';\r\n\r\n/// <summary>\r\n/// Base class for DcValues builder. The class is abstract and, thus, must be inherited.\r\n/// The inheriting class, which will usually be in another package, will not be able to modify\r\n/// a DcValues object directly, since all its setter methods are 'internal'. This class will\r\n/// provide the setter methods for the inheriting builder.\r\n/// <para>Here's a usage example:\r\n/// <example>\r\n/// class MyConcreteBuilder : DcValuesBuilderBase\r\n/// {\r\n///   public override DcValues Build()\r\n///   {\r\n///      var dcValues = base.CreateDcValues(false);\r\n///      SetId(newId);\r\n///      SetType(theType);\r\n///      SetDisplayValues(theDisplayValues);\r\n///      ...\r\n///      return dcValues;\r\n///   }\r\n/// }\r\n/// </example>\r\n/// </summary>\r\nexport abstract class DcValuesBuilderBase {\r\n\r\n  abstract Build(): DcValues;\r\n\r\n  CreateDcValues(): DcValues {\r\n    return new DcValues(false);\r\n  }\r\n\r\n  SetId(dcValues: DcValues, newId: number): void {\r\n    dcValues.SetID(newId);\r\n  }\r\n\r\n  SetType(dcValues: DcValues, type: StorageAttribute): void {\r\n    dcValues.setType(type);\r\n  }\r\n\r\n  SetDisplayValues(dcValues: DcValues, displayValues: string[]): void {\r\n    dcValues.SetDisplayValues(displayValues);\r\n  }\r\n\r\n  SetLinkValues(dcValues: DcValues, linkValues: string[]): void {\r\n    dcValues.SetLinkValues(linkValues);\r\n  }\r\n\r\n  SetNullFlags(dcValues: DcValues, nullFlagsString: string): void;\r\n  SetNullFlags(dcValues: DcValues, nullFlags: boolean[]): void;\r\n  SetNullFlags(dcValues: DcValues, nullFlagsStringOrNullFlags: any): void {\r\n    if (arguments.length === 2 && (dcValues === null || dcValues instanceof DcValues) && (nullFlagsStringOrNullFlags === null || nullFlagsStringOrNullFlags.constructor === String)) {\r\n      this.SetNullFlags_0(dcValues, nullFlagsStringOrNullFlags);\r\n      return;\r\n    }\r\n    this.SetNullFlags_1(dcValues, nullFlagsStringOrNullFlags);\r\n  }\r\n\r\n  private SetNullFlags_0(dcValues: DcValues, nullFlagsString: string): void {\r\n    let nullFlags: boolean[] = this.ParseNullFlags(nullFlagsString);\r\n    dcValues.setNullFlags(nullFlags);\r\n  }\r\n\r\n  private SetNullFlags_1(dcValues: DcValues, nullFlags: boolean[]): void {\r\n    dcValues.setNullFlags(nullFlags);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Parse a serialized values string as an array of values.\r\n  /// </summary>\r\n  /// <param name=\"valueStr\">This is string of the concatenated values, with each value preceded with a hex number denoting its length.</param>\r\n  /// <param name=\"dataType\">The data type of the values.</param>\r\n  /// <param name=\"useHex\"></param>\r\n  protected ParseValues(valueStr: string, dataType: StorageAttribute, useHex: boolean): string[] {\r\n\r\n    let snumber: string;\r\n    let tmpValue: string = null;\r\n    let buffer: List<string> = new List<string>();\r\n    let len: number;\r\n    let nextIdx: number;\r\n    let endIdx: number;\r\n    let suffixBuf: StringBuilder = null;\r\n\r\n    switch (dataType) {\r\n      case StorageAttribute.NUMERIC:\r\n      case StorageAttribute.DATE:\r\n      case StorageAttribute.TIME:\r\n        if (useHex)\r\n          len = GuiEnvironment.Environment.GetSignificantNumSize() * 2;\r\n        else\r\n          len = Math.floor((GuiEnvironment.Environment.GetSignificantNumSize() + 2) / 3) * 4;\r\n        break;\r\n\r\n      case StorageAttribute.BOOLEAN:\r\n        len = 1;\r\n        break;\r\n\r\n      default:\r\n        len = 0;\r\n        break;\r\n    }\r\n\r\n    nextIdx = 0;\r\n    while (nextIdx < valueStr.length) {\r\n      // compute the length of an alpha data\r\n      if (dataType === StorageAttribute.ALPHA || dataType === StorageAttribute.UNICODE ||\r\n        dataType === StorageAttribute.BLOB || dataType === StorageAttribute.BLOB_VECTOR) {\r\n        snumber = valueStr.substr(nextIdx, 4);\r\n        len = NNumber.Parse(snumber, NumberStyles.HexNumber);\r\n        nextIdx += 4;\r\n      }\r\n\r\n      // check if the data is spanned\r\n      if (len >= 0x8000) {\r\n        suffixBuf = new StringBuilder();\r\n        len -= 0x8000;\r\n        // next segment may also be spanned\r\n        nextIdx += RecordUtils.getSpannedField(valueStr, len, nextIdx, dataType, suffixBuf, useHex);\r\n        buffer.push(suffixBuf.ToString());\r\n      }\r\n      else {\r\n        endIdx = nextIdx + len;\r\n        if (useHex)\r\n          tmpValue = valueStr.substr(nextIdx, (endIdx) - (nextIdx));\r\n        else\r\n          tmpValue = Base64.decodeToHex(valueStr.substr(nextIdx, (endIdx) - (nextIdx)));\r\n        // the following two lines are redundant since the makePrintable() is called\r\n        // in the guiManager when building the options\r\n        /*if (dataType == DATA_TYPE_ALPHA)\r\n             tmpValue = guiManager.makePrintable(tmpValue);*/\r\n        buffer.push(tmpValue);\r\n        nextIdx = endIdx;\r\n      }\r\n    }\r\n\r\n    // vector to array\r\n    return buffer.ToArray();\r\n  }\r\n\r\n  ParseNullFlags(nullFlagsString: string): boolean[] {\r\n    let array: boolean[] = new Array<boolean>(nullFlagsString.length);\r\n    for (let i: number = 0; i < nullFlagsString.length; i = i + 1) {\r\n      array[i] = (nullFlagsString.charAt(i) !== '0'/*'0'*/);\r\n    }\r\n    return array;\r\n  }\r\n\r\n  constructor() {\r\n  }\r\n}\r\n"]}

package/esm2020/src/management/data/FieldDef.mjs

@@ -0,0 +1,331 @@
+import { BlobType } from "./BlobType";
+import { StorageAttribute, StrUtil, XmlParser, Base64, XMLConstants } from "@magic-xpa/utils";
+import { NNumber, NString, Int32 } from "@magic-xpa/mscorelib";
+import { Events } from "../../Events";
+import { DisplayConvertor } from "../gui/DisplayConvertor";
+import { VectorType } from "./VectorType";
+import { GuiEnvironment } from "../../GuiEnvironment";
+export class FieldDef {
+    set DbModifiable(value) {
+        this._dbModifiable = value;
+    }
+    get DbModifiable() {
+        return this._dbModifiable;
+    }
+    constructor(id) {
+        this.DefaultValue = null;
+        this.NullAllowed = false;
+        this._nullDefault = false;
+        this._nullValue = null;
+        this._nullDisplay = null;
+        this._dbModifiable = true;
+        this._partOfDataview = true;
+        this._picture = null;
+        this._size = 0;
+        this._varName = null;
+        this._contentType = BlobType.CONTENT_TYPE_UNKNOWN;
+        this._vecCellsContentType = BlobType.CONTENT_TYPE_UNKNOWN;
+        this._vecCellsSize = 0;
+        this._vecCellsType = StorageAttribute.NONE;
+        this._type = StorageAttribute.NONE;
+        this.Storage = 0;
+        this.VarDisplayName = null;
+        this._id = 0;
+        this._spaces = null;
+        this._id = id;
+        this.VarDisplayName = NString.Empty;
+    }
+    get PartOfDataview() {
+        return this._partOfDataview;
+    }
+    getId() {
+        return this._id;
+    }
+    getType() {
+        return this._type;
+    }
+    static getMagicDefaultNullDisplayValue(type) {
+        let val;
+        switch (type) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.UNICODE:
+            case StorageAttribute.BOOLEAN:
+                val = "";
+                break;
+            case StorageAttribute.NUMERIC:
+            case StorageAttribute.DATE:
+            case StorageAttribute.TIME:
+                val = "";
+                break;
+        }
+        return val;
+    }
+    static getMagicDefaultValue(type) {
+        let val = null;
+        switch (type) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.UNICODE:
+                val = "";
+                break;
+            case StorageAttribute.BLOB:
+            case StorageAttribute.BLOB_VECTOR:
+                val = BlobType.getEmptyBlobPrefix('\0') + ";";
+                break;
+            case StorageAttribute.NUMERIC:
+            case StorageAttribute.TIME:
+                val = "FF00000000000000000000000000000000000000";
+                break;
+            case StorageAttribute.DATE:
+                val = FieldDef._default_date;
+                break;
+            case StorageAttribute.BOOLEAN:
+                val = "0";
+                break;
+        }
+        return val;
+    }
+    getDefaultValue() {
+        let val = null;
+        if (this._type !== StorageAttribute.BLOB_VECTOR) {
+            if (this._nullDefault && this._nullValue !== null)
+                val = this._nullValue;
+            else if (this.DefaultValue !== null)
+                val = this.DefaultValue;
+            else
+                val = this.getMagicDefaultValue();
+        }
+        else
+            val = this.getMagicDefaultValue();
+        return val;
+    }
+    getCellDefualtValue() {
+        let val;
+        if (this._type === StorageAttribute.BLOB_VECTOR) {
+            if (this._nullDefault && this._nullValue !== null)
+                val = this._nullValue;
+            else if (this.DefaultValue !== null)
+                val = this.DefaultValue;
+            else {
+                val = FieldDef.getMagicDefaultValue(this._vecCellsType);
+                if (this._vecCellsType === StorageAttribute.BLOB)
+                    val = BlobType.setContentType(val, this._vecCellsContentType);
+            }
+        }
+        else
+            val = this.getDefaultValue();
+        return val;
+    }
+    getMagicDefaultValue() {
+        let val = FieldDef.getMagicDefaultValue(this._type);
+        if (this._type === StorageAttribute.BLOB)
+            val = BlobType.setContentType(val, this._contentType);
+        else {
+            if (this._type === StorageAttribute.BLOB_VECTOR) {
+                val = BlobType.SetVecCellAttr(val, this._vecCellsType);
+                if (this._vecCellsType === StorageAttribute.BLOB)
+                    val = BlobType.setContentType(val, this._vecCellsContentType);
+            }
+        }
+        return val;
+    }
+    getContentType() {
+        return this._contentType;
+    }
+    hasNullDisplayValue() {
+        return this._nullDisplay !== null;
+    }
+    getSize() {
+        return this._size;
+    }
+    getVecCellsSize() {
+        return (this._type === StorageAttribute.BLOB_VECTOR) ? this._vecCellsSize : this._size;
+    }
+    setLengths(type, vecCells) {
+        let res = this._size;
+        switch (type) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.MEMO:
+            case StorageAttribute.UNICODE:
+                if (vecCells) {
+                    res = this._vecCellsSize;
+                    this._spaces = new Array(this._vecCellsSize);
+                }
+                else
+                    this._spaces = new Array(this._size);
+                for (let i = 0; i < this._size; i = i + 1) {
+                    this._spaces[i] = ' ';
+                }
+                break;
+            case StorageAttribute.NUMERIC:
+            case StorageAttribute.DATE:
+            case StorageAttribute.TIME:
+                res = GuiEnvironment.Environment.GetSignificantNumSize() * 2;
+                break;
+            case StorageAttribute.BOOLEAN:
+                res = (!vecCells ? 1 : 4);
+                break;
+            case StorageAttribute.BLOB:
+                res = (!vecCells ? Int32.MaxValue : VectorType.BLOB_TYPE_STRUCT_SIZE);
+                break;
+            case StorageAttribute.BLOB_VECTOR:
+                res = Int32.MaxValue;
+                if (!vecCells)
+                    this.setLengths(this._vecCellsType, true);
+                else
+                    res = VectorType.BLOB_TYPE_STRUCT_SIZE;
+                break;
+        }
+        if (vecCells)
+            this._vecCellsSize = res;
+        else
+            this._size = res;
+    }
+    getCellsType() {
+        return (this._type === StorageAttribute.BLOB_VECTOR) ? this._vecCellsType : this._type;
+    }
+    getVecCellsContentType() {
+        return this._vecCellsContentType;
+    }
+    getNullValue() {
+        return this._nullValue;
+    }
+    isNullDefault() {
+        return this._nullDefault;
+    }
+    getNullDisplay() {
+        let val;
+        switch (this._type) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.UNICODE:
+            case StorageAttribute.BOOLEAN:
+                val = "";
+                break;
+            case StorageAttribute.NUMERIC:
+            case StorageAttribute.DATE:
+            case StorageAttribute.TIME:
+                val = null;
+                break;
+        }
+        return val;
+    }
+    IsContentUnicode() {
+        if (this._type === StorageAttribute.BLOB && this._contentType !== BlobType.CONTENT_TYPE_UNICODE)
+            return false;
+        return true;
+    }
+    GetPicture() {
+        return this._picture;
+    }
+    setAttribute(attribute, valueStr) {
+        let isTagProcessed = true;
+        switch (attribute) {
+            case XMLConstants.MG_ATTR_TYPE:
+                this._type = valueStr.charAt(0);
+                break;
+            case XMLConstants.MG_ATTR_SIZE:
+                this._size = XmlParser.getInt(valueStr);
+                if (this._size <= 0)
+                    Events.WriteExceptionToLog("in Field.initElements(): size must be greater than zero");
+                break;
+            case XMLConstants.MG_ATTR_VAR_NAME:
+                this._varName = XmlParser.unescape(valueStr).toString();
+                break;
+            case XMLConstants.MG_ATTR_VAR_DISP_NAME:
+                this.VarDisplayName = XmlParser.unescape(valueStr).toString();
+                break;
+            case XMLConstants.MG_ATTR_PICTURE:
+                this._picture = XmlParser.unescape(valueStr).toString();
+                break;
+            case XMLConstants.MG_ATTR_VEC_CELLS_SIZE:
+                this._vecCellsSize = NNumber.Parse(valueStr);
+                break;
+            case XMLConstants.MG_ATTR_VEC_CELLS_ATTR:
+                this._vecCellsType = valueStr.charAt(0);
+                break;
+            case XMLConstants.MG_ATTR_VEC_CELLS_CONTENT:
+                this._vecCellsContentType = valueStr.charAt(0);
+                break;
+            case XMLConstants.MG_ATTR_NULLVALUE:
+                if (this._type === StorageAttribute.NUMERIC || this._type === StorageAttribute.DATE || this._type === StorageAttribute.TIME) {
+                    if (GuiEnvironment.Environment.GetDebugLevel() > 1)
+                        this._nullValue = XmlParser.unescape(valueStr).toString();
+                    else
+                        this._nullValue = Base64.decodeToHex(valueStr);
+                }
+                else
+                    this._nullValue = XmlParser.unescape(valueStr).toString();
+                break;
+            case XMLConstants.MG_ATTR_NULLDISPLAY:
+                this._nullDisplay = XmlParser.unescape(valueStr).toString();
+                break;
+            case XMLConstants.MG_ATTR_NULLDEFAULT:
+                this._nullDefault = DisplayConvertor.toBoolean(valueStr);
+                break;
+            case XMLConstants.MG_ATTR_DB_MODIFIABLE:
+                this.DbModifiable = DisplayConvertor.toBoolean(valueStr);
+                break;
+            case XMLConstants.MG_ATTR_DEFAULTVALUE:
+                this.DefaultValue = valueStr;
+                if (this._type === StorageAttribute.ALPHA || this._type === StorageAttribute.UNICODE) {
+                    this.DefaultValue = XmlParser.unescape(valueStr).toString();
+                    this.DefaultValue = StrUtil.padStr(this.DefaultValue, this._size);
+                }
+                else if (this._type !== StorageAttribute.BLOB && this._type !== StorageAttribute.BOOLEAN) {
+                    if ((this._type === StorageAttribute.BLOB_VECTOR &&
+                        (this._vecCellsType === StorageAttribute.NUMERIC || this._vecCellsType === StorageAttribute.DATE || this._vecCellsType === StorageAttribute.TIME)) ||
+                        (this._type === StorageAttribute.NUMERIC || this._type === StorageAttribute.DATE || this._type === StorageAttribute.TIME)) {
+                        if (GuiEnvironment.Environment.GetDebugLevel() < 1)
+                            this.DefaultValue = Base64.decodeToHex(valueStr);
+                    }
+                }
+                else if (this.DefaultValue.length === 0 && this._type !== StorageAttribute.BLOB)
+                    this.DefaultValue = null;
+                else if (this._type === StorageAttribute.BLOB)
+                    this.DefaultValue = BlobType.createFromString(this.DefaultValue, this._contentType);
+                break;
+            case XMLConstants.MG_ATTR_NULLALLOWED:
+                this.NullAllowed = DisplayConvertor.toBoolean(valueStr);
+                break;
+            case XMLConstants.MG_ATTR_BLOB_CONTENT:
+                this._contentType = valueStr.charAt(0);
+                break;
+            case XMLConstants.MG_ATTR_PART_OF_DATAVIEW:
+                this._partOfDataview = DisplayConvertor.toBoolean(valueStr);
+                break;
+            case XMLConstants.MG_ATTR_STORAGE:
+                this.Storage = XmlParser.getInt(valueStr);
+                break;
+            default:
+                isTagProcessed = false;
+                break;
+        }
+        return isTagProcessed;
+    }
+    fillData(parser) {
+        let text = parser.ReadToEndOfCurrentElement();
+        text = text.substr(text.indexOf(XMLConstants.MG_TAG_FLDH) + XMLConstants.MG_TAG_FLDH.length);
+        let tokens = XmlParser.getTokens(text, XMLConstants.XML_ATTR_DELIM);
+        this.initElements(tokens);
+    }
+    initElements(tokensVector) {
+        for (let i = 0; i < tokensVector.length; i = i + 2) {
+            let attribute = tokensVector.get_Item(i);
+            let valueStr = tokensVector.get_Item(i + 1);
+            this.setAttribute(attribute, valueStr);
+        }
+        this.SetAfterParsing();
+    }
+    SetAfterParsing() {
+        this.setLengths(this._type, false);
+        if (this.NullAllowed && this._nullDisplay === null)
+            this._nullDisplay = "";
+    }
+    getVarName() {
+        return this._varName || "";
+    }
+    getName() {
+        return this.getVarName();
+    }
+}
+FieldDef._default_date = null;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FieldDef.js","sourceRoot":"","sources":["../../../../../../../projects/gui/src/management/data/FieldDef.ts"],"names":[],"mappings":"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","sourcesContent":["import {BlobType} from \"./BlobType\";\r\nimport {FldStorage, StorageAttribute, StrUtil, XmlParser, Base64, XMLConstants} from \"@magic-xpa/utils\";\r\nimport {List, NNumber, NString, Int32} from \"@magic-xpa/mscorelib\";\r\nimport {Events} from \"../../Events\";\r\nimport {DisplayConvertor} from \"../gui/DisplayConvertor\";\r\nimport {VectorType} from \"./VectorType\";\r\nimport { GuiEnvironment } from \"../../GuiEnvironment\";\r\n\r\nexport class FieldDef {\r\n  DefaultValue: string = null;\r\n  NullAllowed: boolean = false;\r\n  protected _nullDefault: boolean = false;\r\n  protected _nullValue: string = null;\r\n  protected _nullDisplay: string = null;\r\n\r\n  // true, if field is modifiable on field level\r\n  set DbModifiable(value: boolean) {\r\n    this._dbModifiable = value;\r\n  }\r\n  get DbModifiable(): boolean {\r\n    return this._dbModifiable;\r\n  }\r\n  private _dbModifiable: boolean = true;\r\n\r\n  private _partOfDataview: boolean = true;\r\n  protected _picture: string = null;\r\n  protected _size: number = 0;\r\n  protected _varName: string = null;\r\n\r\n  // Only for BLOB field. Does it contain a unicode or ANSI data?\r\n  private _contentType: string = BlobType.CONTENT_TYPE_UNKNOWN;\r\n  protected _vecCellsContentType: string = BlobType.CONTENT_TYPE_UNKNOWN;\r\n  protected _vecCellsSize: number = 0;\r\n  protected _vecCellsType: StorageAttribute = StorageAttribute.NONE;\r\n  protected _type: StorageAttribute = StorageAttribute.NONE;\r\n  Storage: FldStorage = 0;\r\n  VarDisplayName: string = null;\r\n\r\n  protected static _default_date: string = null;\r\n  protected readonly _id: number = 0;\r\n  protected _spaces: string[] = null;\r\n\r\n  /// <summary>\r\n  /// CTOR\r\n  /// </summary>\r\n  /// <param name=\"id_\"> idx in FieldsTable </param>\r\n  constructor(id: number) {\r\n    this._id = id;\r\n    this.VarDisplayName = NString.Empty;\r\n  }\r\n\r\n  get PartOfDataview(): boolean {\r\n    return this._partOfDataview;\r\n  }\r\n\r\n  /// <summary>\r\n  /// returns the id of the field\r\n  /// </summary>\r\n  getId(): number {\r\n    return this._id;\r\n  }\r\n\r\n  /// <summary>\r\n  /// size type of current Field: A, N, L, D, T\r\n  /// </summary>\r\n  /// <returns> size member of current Field\r\n  /// </returns>\r\n  getType(): StorageAttribute {\r\n    return this._type;\r\n  }\r\n\r\n  /// <summary>\r\n  /// return the magic default null display value according to the type\r\n  /// </summary>\r\n  /// <param name = \"type\">of the data</param>\r\n  static getMagicDefaultNullDisplayValue(type: StorageAttribute): string {\r\n    let val: string;\r\n\r\n    switch (type) {\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.UNICODE:\r\n      case StorageAttribute.BOOLEAN:\r\n        val = \"\";\r\n        break;\r\n\r\n      case StorageAttribute.NUMERIC:\r\n      case StorageAttribute.DATE:\r\n      case StorageAttribute.TIME:\r\n        // zero\r\n        val = \"\";\r\n        break;\r\n    }\r\n    return val;\r\n  }\r\n\r\n  /// <summary>\r\n  /// return the magic default value according to the type\r\n  /// </summary>\r\n  /// <param name = \"type\">of the data</param>\r\n  static getMagicDefaultValue(type: StorageAttribute): string {\r\n    let val: string = null;\r\n    switch (type) {\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.UNICODE:\r\n        val = \"\";\r\n        break;\r\n      case StorageAttribute.BLOB:\r\n      case StorageAttribute.BLOB_VECTOR:\r\n        val = BlobType.getEmptyBlobPrefix('\\0') + \";\";\r\n        break;\r\n      case StorageAttribute.NUMERIC:\r\n      case StorageAttribute.TIME:\r\n        val = \"FF00000000000000000000000000000000000000\";\r\n        break;\r\n      case StorageAttribute.DATE:\r\n        val = FieldDef._default_date;\r\n        break;\r\n      case StorageAttribute.BOOLEAN:\r\n        val = \"0\";\r\n        break;\r\n    }\r\n    return val;\r\n  }\r\n\r\n  /// <summary>\r\n  /// returns the default value of this field\r\n  /// </summary>\r\n  getDefaultValue(): string {\r\n    let val: string = null;\r\n    if (this._type !== StorageAttribute.BLOB_VECTOR) {\r\n      if (this._nullDefault && this._nullValue !== null)\r\n        val = this._nullValue;\r\n      else if (this.DefaultValue !== null)\r\n        val = this.DefaultValue;\r\n      else\r\n        val = this.getMagicDefaultValue();\r\n    }\r\n     else\r\n       val = this.getMagicDefaultValue();\r\n\r\n    return val;\r\n  }\r\n\r\n  /// <summary>\r\n  /// returns the vectors cells default value\r\n  /// if the field is not a vector returns field default value\r\n  /// </summary>\r\n  getCellDefualtValue(): string {\r\n    let val: string;\r\n    if (this._type === StorageAttribute.BLOB_VECTOR) {\r\n      if (this._nullDefault && this._nullValue !== null)\r\n        val = this._nullValue;\r\n      else if (this.DefaultValue !== null)\r\n          val = this.DefaultValue;\r\n      else {\r\n        val = FieldDef.getMagicDefaultValue(this._vecCellsType);\r\n        if (this._vecCellsType === StorageAttribute.BLOB)\r\n          val = BlobType.setContentType(val, this._vecCellsContentType);\r\n      }\r\n    }\r\n    else\r\n      val = this.getDefaultValue();\r\n    return val;\r\n  }\r\n\r\n  /// <summary>\r\n  /// return the magic default value according to the type\r\n  /// </summary>\r\n  getMagicDefaultValue(): string {\r\n    let val: string = FieldDef.getMagicDefaultValue(this._type);\r\n    if (this._type === StorageAttribute.BLOB)\r\n      val = BlobType.setContentType(val, this._contentType);\r\n    else {\r\n      if (this._type === StorageAttribute.BLOB_VECTOR) {\r\n        val = BlobType.SetVecCellAttr(val, this._vecCellsType);\r\n        if (this._vecCellsType === StorageAttribute.BLOB)\r\n          val = BlobType.setContentType(val, this._vecCellsContentType);\r\n      }\r\n    }\r\n    return val;\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <returns> the contentType </returns>\r\n  getContentType(): string {\r\n    return this._contentType;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the nullDisplay has a value\r\n  /// </summary>\r\n  hasNullDisplayValue(): boolean {\r\n    return this._nullDisplay !== null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   size member of current Field\r\n  /// </summary>\r\n  /// <returns> size member of current Field </returns>\r\n  getSize(): number {\r\n    return this._size;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the vector cells size\r\n  /// </summary>\r\n  getVecCellsSize(): number {\r\n    return (this._type === StorageAttribute.BLOB_VECTOR) ? this._vecCellsSize : this._size;\r\n  }\r\n\r\n  setLengths(type: StorageAttribute, vecCells: boolean): void {\r\n    let res: number = this._size;\r\n\r\n    switch (type) {\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.MEMO:\r\n      case StorageAttribute.UNICODE:\r\n        if (vecCells) {\r\n          res = this._vecCellsSize;\r\n          this._spaces = new Array<string>(this._vecCellsSize);\r\n        }\r\n        else\r\n          this._spaces = new Array<string>(this._size);\r\n\r\n        for (let i: number = 0; i < this._size; i = i + 1) {\r\n          this._spaces[i] = ' ';\r\n        }\r\n        break;\r\n\r\n      case StorageAttribute.NUMERIC:\r\n      case StorageAttribute.DATE:\r\n      case StorageAttribute.TIME:\r\n        res = GuiEnvironment.Environment.GetSignificantNumSize() * 2;\r\n        break;\r\n\r\n      case StorageAttribute.BOOLEAN:\r\n        res = (!vecCells ? 1 : 4);\r\n        break;\r\n\r\n      case StorageAttribute.BLOB:\r\n        // QCR 758913 FOR VECTORS INTERNAL USE ONLY THE SIZE OF BLOBS AND VECTOR\r\n        // IS THE SIZE OF THIER STRUCTS IN THE MAGIC ENGIN\r\n        res = (!vecCells ? Int32.MaxValue : VectorType.BLOB_TYPE_STRUCT_SIZE);\r\n        break;\r\n\r\n      case StorageAttribute.BLOB_VECTOR:\r\n        res = Int32.MaxValue;\r\n        if (!vecCells)\r\n          this.setLengths(this._vecCellsType, true);\r\n        else\r\n          res = VectorType.BLOB_TYPE_STRUCT_SIZE;\r\n        break;\r\n    }\r\n\r\n    if (vecCells)\r\n      this._vecCellsSize = res;\r\n    else\r\n      this._size = res;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the cells type of vectors elese returns the field type\r\n  /// </summary>\r\n  getCellsType(): StorageAttribute {\r\n    return (this._type === StorageAttribute.BLOB_VECTOR) ? this._vecCellsType : this._type;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the cell content type of vector field\r\n  /// </summary>\r\n  /// <returns>vector's cell content type</returns>\r\n  getVecCellsContentType(): string {\r\n    return this._vecCellsContentType;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns Null Value value of this field\r\n  /// </summary>\r\n  getNullValue(): string {\r\n    return this._nullValue;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the field is a Null Default\r\n  /// </summary>\r\n  isNullDefault(): boolean {\r\n    return this._nullDefault;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns Null Display value of this field\r\n  /// </summary>\r\n  getNullDisplay(): any {\r\n    let val: any;\r\n\r\n    switch (this._type) {\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.UNICODE:\r\n      case StorageAttribute.BOOLEAN:\r\n        val = \"\";\r\n        break;\r\n\r\n      case StorageAttribute.NUMERIC:\r\n      case StorageAttribute.DATE:\r\n      case StorageAttribute.TIME:\r\n        // zero\r\n        val = null;\r\n        break;\r\n    }\r\n    return val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   For BLOB fields, check if they contain UNICODE or ANSI chars.\r\n  /// </summary>\r\n  /// <returns>TRUE if content is UNICODE. False otherwise</returns>\r\n  IsContentUnicode(): boolean {\r\n    if (this._type === StorageAttribute.BLOB && this._contentType !== BlobType.CONTENT_TYPE_UNICODE)\r\n      return false;\r\n\r\n    return true;\r\n  }\r\n\r\n  GetPicture(): string {\r\n    return this._picture;\r\n  }\r\n\r\n  /// <summary>\r\n  /// set the field attribute in parsing\r\n  /// </summary>\r\n protected setAttribute(attribute: string, valueStr: string): boolean {\r\n    let isTagProcessed: boolean = true;\r\n\r\n    switch (attribute) {\r\n      case XMLConstants.MG_ATTR_TYPE:\r\n        this._type = <StorageAttribute>valueStr.charAt(0);\r\n        break;\r\n      case XMLConstants.MG_ATTR_SIZE:\r\n        this._size = XmlParser.getInt(valueStr);\r\n        if (this._size <= 0)\r\n          Events.WriteExceptionToLog(\"in Field.initElements(): size must be greater than zero\");\r\n        break;\r\n      case XMLConstants.MG_ATTR_VAR_NAME:\r\n        this._varName = XmlParser.unescape(valueStr).toString();\r\n        break;\r\n      case XMLConstants.MG_ATTR_VAR_DISP_NAME:\r\n        this.VarDisplayName = XmlParser.unescape(valueStr).toString();\r\n        break;\r\n      case XMLConstants.MG_ATTR_PICTURE:\r\n        this._picture = XmlParser.unescape(valueStr).toString();\r\n        break;\r\n      case XMLConstants.MG_ATTR_VEC_CELLS_SIZE:\r\n        this._vecCellsSize = NNumber.Parse(valueStr);\r\n        break;\r\n      case XMLConstants.MG_ATTR_VEC_CELLS_ATTR:\r\n        this._vecCellsType = <StorageAttribute>valueStr.charAt(0);\r\n        break;\r\n      case XMLConstants.MG_ATTR_VEC_CELLS_CONTENT:\r\n        this._vecCellsContentType = valueStr.charAt(0);\r\n        break;\r\n      case XMLConstants.MG_ATTR_NULLVALUE:\r\n        if (this._type === StorageAttribute.NUMERIC || this._type === StorageAttribute.DATE || this._type === StorageAttribute.TIME) {\r\n          if (GuiEnvironment.Environment.GetDebugLevel() > 1)\r\n            this._nullValue = XmlParser.unescape(valueStr).toString();\r\n          else\r\n            this._nullValue = Base64.decodeToHex(valueStr);\r\n        }\r\n        else\r\n          this._nullValue = XmlParser.unescape(valueStr).toString();\r\n        break;\r\n      case XMLConstants.MG_ATTR_NULLDISPLAY:\r\n        this._nullDisplay = XmlParser.unescape(valueStr).toString();\r\n        break;\r\n      case XMLConstants.MG_ATTR_NULLDEFAULT:\r\n        this._nullDefault = DisplayConvertor.toBoolean(valueStr);\r\n        break;\r\n      case XMLConstants.MG_ATTR_DB_MODIFIABLE:\r\n        this.DbModifiable = DisplayConvertor.toBoolean(valueStr);\r\n        break;\r\n      case XMLConstants.MG_ATTR_DEFAULTVALUE:\r\n        this.DefaultValue = valueStr;\r\n        if (this._type === StorageAttribute.ALPHA || this._type === StorageAttribute.UNICODE) {\r\n          this.DefaultValue = XmlParser.unescape(valueStr).toString();\r\n          this.DefaultValue = StrUtil.padStr(this.DefaultValue, this._size);\r\n        }\r\n        else if (this._type !== StorageAttribute.BLOB && this._type !== StorageAttribute.BOOLEAN) {\r\n          // working in hex or base64\r\n          if ((this._type === StorageAttribute.BLOB_VECTOR &&\r\n            (this._vecCellsType === StorageAttribute.NUMERIC || this._vecCellsType === StorageAttribute.DATE || this._vecCellsType === StorageAttribute.TIME)) ||\r\n            (this._type === StorageAttribute.NUMERIC || this._type === StorageAttribute.DATE || this._type === StorageAttribute.TIME)) {\r\n            if (GuiEnvironment.Environment.GetDebugLevel() < 1)\r\n              this.DefaultValue = Base64.decodeToHex(valueStr);\r\n          }\r\n        }\r\n        else if (this.DefaultValue.length === 0 && this._type !== StorageAttribute.BLOB)\r\n          this.DefaultValue = null;\r\n        else if (this._type === StorageAttribute.BLOB)\r\n          this.DefaultValue = BlobType.createFromString(this.DefaultValue, this._contentType);\r\n        break;\r\n      case XMLConstants.MG_ATTR_NULLALLOWED:\r\n        this.NullAllowed = DisplayConvertor.toBoolean(valueStr);\r\n        break;\r\n      case XMLConstants.MG_ATTR_BLOB_CONTENT:\r\n        this._contentType = valueStr.charAt(0);\r\n        break;\r\n      case XMLConstants.MG_ATTR_PART_OF_DATAVIEW:\r\n        this._partOfDataview = DisplayConvertor.toBoolean(valueStr);\r\n        break;\r\n      case XMLConstants.MG_ATTR_STORAGE:\r\n        this.Storage = <FldStorage>XmlParser.getInt(valueStr);\r\n        break;\r\n      default:\r\n        isTagProcessed = false;\r\n        break;\r\n    }\r\n\r\n    return isTagProcessed;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Need part input String to relevant for the Field class data\r\n  /// </summary>\r\n  fillData(parser: XmlParser): void {\r\n    let text: string = parser.ReadToEndOfCurrentElement();\r\n    text = text.substr(text.indexOf(XMLConstants.MG_TAG_FLDH) + XMLConstants.MG_TAG_FLDH.length);\r\n    let tokens: List<string> = XmlParser.getTokens(text, XMLConstants.XML_ATTR_DELIM);\r\n    this.initElements(tokens);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Make initialization of private elements by found tokens\r\n  /// </summary>\r\n  /// <param name = \"tokensVector\">found tokens, which consist attribute/value of every foundelement</param>\r\n  /// <param name = \"expTab\">reference to relevant exp. table</param>\r\n  initElements(tokensVector: List<string>): void {\r\n    for (let i: number = 0; i < tokensVector.length; i = i + 2) {\r\n      let attribute: string = tokensVector.get_Item(i);\r\n      let valueStr: string = tokensVector.get_Item(i + 1);\r\n\r\n      // the parsing is finished here\r\n      this.setAttribute(attribute, valueStr);\r\n    }\r\n    this.SetAfterParsing();\r\n  }\r\n\r\n  /// <summary>\r\n  /// some properties are needed to be set after parsing\r\n  /// </summary>\r\n  SetAfterParsing(): void {\r\n    this.setLengths(this._type, false);\r\n    if (this.NullAllowed && this._nullDisplay === null)\r\n      this._nullDisplay = \"\";\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get name of variable\r\n  /// </summary>\r\n  getVarName(): string {\r\n    return this._varName || \"\";\r\n  }\r\n\r\n  /// <summary>\r\n  ///   for get VARNAME function use\r\n  ///   A string containing the table name where the variable originates,\r\n  ///   concatenated with '.' and the variable description of the variable in that table.\r\n  ///   If the variable is a virtual one, then the table name would indicate 'Virtual'.\r\n  /// </summary>\r\n  getName(): string {\r\n    return this.getVarName();\r\n  }\r\n}\r\n"]}

package/esm2020/src/management/data/FieldsTable.mjs

@@ -0,0 +1,54 @@
+import { List } from '@magic-xpa/mscorelib';
+import { XMLConstants } from '@magic-xpa/utils';
+import { Manager } from '../../Manager';
+import { Events } from '../../Events';
+export class FieldsTable {
+    constructor() {
+        this._fields = null;
+        this._fields = new List();
+    }
+    getField(idxOrFldName) {
+        if ((idxOrFldName === null || idxOrFldName.constructor === Number)) {
+            return this.getField_0(idxOrFldName);
+        }
+        return this.getField_1(idxOrFldName);
+    }
+    getField_0(idx) {
+        let fld = null;
+        if (idx >= 0 && idx < this._fields.length)
+            fld = this._fields.get_Item(idx);
+        return fld;
+    }
+    getSize() {
+        return this._fields.length;
+    }
+    fillData(parser, dataview) {
+        while (this.initInnerObjects(parser.getNextTag(), dataview)) {
+        }
+    }
+    initInnerObjects(foundTagName, dataview) {
+        if (foundTagName === null)
+            return false;
+        let parser = Manager.GetCurrentRuntimeContext().Parser;
+        if (foundTagName === XMLConstants.MG_TAG_FLDH) {
+            let field = this.initField(parser, dataview);
+            this._fields.push(field);
+        }
+        else if (foundTagName === XMLConstants.MG_TAG_DVHEADER)
+            parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) +
+                1);
+        else if (foundTagName === "/" + XMLConstants.MG_TAG_DVHEADER) {
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        else {
+            Events.WriteExceptionToLog("There is no such tag in FieldsTable. Insert else if to FieldsTable.initInnerObjects for " + foundTagName);
+            return false;
+        }
+        return true;
+    }
+    getField_1(fldName) {
+        return this._fields.find((field) => (field.getVarName() === fldName));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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