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

package/esm2020/src/exp/ExpTable.mjs

@@ -0,0 +1,59 @@
+import { List } from '@magic-xpa/mscorelib';
+import { Logger } from '@magic-xpa/utils';
+import { Expression } from './Expression';
+import { ConstInterface } from '../ConstInterface';
+export class ExpTable {
+    constructor() {
+        this._exps = new List();
+    }
+    fillData(task, parser) {
+        while (this.initInnerObjects(parser, parser.getNextTag(), task)) {
+        }
+    }
+    initInnerObjects(parser, foundTagName, task) {
+        if (foundTagName === null)
+            return false;
+        if (foundTagName === ConstInterface.MG_TAG_EXP) {
+            let expression = new Expression();
+            expression.fillData(task, parser);
+            this._exps.push(expression);
+        }
+        else if (foundTagName === ConstInterface.MG_TAG_EXPTABLE) {
+            parser.setCurrIndex(parser.getXMLdata().indexOf(">", parser.getCurrIndex()) + 1);
+        }
+        else if (foundTagName === ('/' + ConstInterface.MG_TAG_EXPTABLE)) {
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        else {
+            Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in ExpTable.initInnerObjects(): " + foundTagName);
+            return false;
+        }
+        return true;
+    }
+    getExpById(id) {
+        let exp;
+        if (id < 0)
+            return null;
+        for (let i = 0; i < this._exps.length; i++) {
+            exp = this._exps.get_Item(i);
+            if (exp.getId() === id)
+                return exp;
+            exp = null;
+        }
+        return exp;
+    }
+    getExp(idx) {
+        let exp = null;
+        if (idx >= 0 && idx < this._exps.length)
+            exp = this._exps.get_Item(idx);
+        return exp;
+    }
+    getSize() {
+        let count = 0;
+        if (this._exps !== null)
+            count = this._exps.length;
+        return count;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/exp/Expression.mjs

@@ -0,0 +1,200 @@
+import { NString, NNumber, NumberStyles } from "@magic-xpa/mscorelib";
+import { StorageAttribute, Logger, Misc, Base64, XmlParser, XMLConstants } from "@magic-xpa/utils";
+import { ExpVal, VectorType, RecordUtils, NUM_TYPE } from "@magic-xpa/gui";
+import { ExpressionEvaluator } from "./ExpressionEvaluator";
+import { CommandFactory } from "../commands/ClientToServer/CommandFactory";
+import { ConstInterface } from "../ConstInterface";
+import { Environment } from "../env/Environment";
+import { AccessHelper } from "../AccessHelper";
+export class Expression {
+    constructor() {
+        this._cmdToServer = null;
+        this._cmdsToServer = null;
+        this._computeBy = '\0';
+        this._expBytes = null;
+        this._id = -1;
+        this._prevResType = StorageAttribute.NONE;
+        this._resultValue = null;
+        this._task = null;
+        this._type = StorageAttribute.NONE;
+        this._clientStorageAttribute = StorageAttribute.NONE;
+    }
+    GetStorageAttribute() {
+        return this._clientStorageAttribute;
+    }
+    async evaluateWithResultTypeAndLength(resType, length) {
+        let retVal;
+        let retExpressionStorage = StorageAttribute.NONE;
+        if (this.computedByClient()) {
+            let expVal = await ExpressionEvaluator.eval(this._expBytes, resType, this._task);
+            if (expVal.IsNull)
+                retVal = null;
+            else if (resType === StorageAttribute.BLOB_VECTOR && expVal.Attr === StorageAttribute.BLOB) {
+                if (VectorType.validateBlobContents(expVal.StrVal))
+                    retVal = expVal.ToMgVal();
+                else
+                    retVal = null;
+            }
+            else if (expVal.Attr === StorageAttribute.BLOB_VECTOR && resType !== StorageAttribute.BLOB_VECTOR && resType !== StorageAttribute.BLOB)
+                retVal = null;
+            else
+                retVal = expVal.ToMgVal();
+            if (!expVal.IsNull)
+                retExpressionStorage = expVal.Attr;
+        }
+        else {
+            let rtEvt = AccessHelper.eventsManager.getLastRtEvent();
+            let mprgCreator = null;
+            if (rtEvt !== null)
+                mprgCreator = rtEvt.getMainPrgCreator();
+            if (resType !== this._prevResType)
+                this._cmdToServer = CommandFactory.CreateEvaluateCommand(this._task.getTaskTag(), resType, this._id, length, mprgCreator);
+            await AccessHelper.mgDataTable.execRequestWithSubformRecordCycle(this._cmdsToServer, this._cmdToServer, this);
+            if (resType !== StorageAttribute.BLOB && resType !== StorageAttribute.BLOB_VECTOR)
+                retVal = this._resultValue;
+            else if (this._resultValue !== null && this._resultValue === " ")
+                retVal = "";
+            else
+                retVal = RecordUtils.byteStreamToString(this._resultValue);
+        }
+        this._prevResType = resType;
+        if (resType === StorageAttribute.NONE)
+            this._clientStorageAttribute = retExpressionStorage;
+        return retVal;
+    }
+    async DiscardCndRangeResult() {
+        return await ExpressionEvaluator.DiscardCndRangeResult(this._expBytes, this._task);
+    }
+    async evaluateWithResType(resType) {
+        let isNull = false;
+        let expVal;
+        if (this.computedByClient())
+            expVal = await ExpressionEvaluator.eval(this._expBytes, resType, this._task);
+        else {
+            let rtEvt = AccessHelper.eventsManager.getLastRtEvent();
+            let mprgCreator = null;
+            if (rtEvt !== null)
+                mprgCreator = rtEvt.getMainPrgCreator();
+            if (resType !== this._prevResType)
+                this._cmdToServer = CommandFactory.CreateEvaluateCommand(this._task.getTaskTag(), resType, this._id, 0, mprgCreator);
+            await AccessHelper.mgDataTable.execRequestWithSubformRecordCycle(this._cmdsToServer, this._cmdToServer, this);
+            let retVal;
+            if (resType !== StorageAttribute.BLOB && resType !== StorageAttribute.BLOB_VECTOR)
+                retVal = this._resultValue;
+            else if (this._resultValue !== null && this._resultValue === " ")
+                retVal = "";
+            else
+                retVal = RecordUtils.byteStreamToString(this._resultValue);
+            if (retVal === null)
+                isNull = true;
+            if (resType === StorageAttribute.NONE)
+                resType = this._type;
+            expVal = new ExpVal(resType, isNull, retVal);
+        }
+        this._prevResType = resType;
+        return expVal;
+    }
+    async evaluateWithResLength(length) {
+        let resType = StorageAttribute.NONE;
+        let val;
+        if (this.computedByClient()) {
+            let expVal = await ExpressionEvaluator.eval(this._expBytes, resType, this._task);
+            if (expVal.IsNull)
+                val = null;
+            else
+                val = expVal.ToMgVal();
+            resType = expVal.Attr;
+        }
+        else {
+            val = await this.evaluateWithResultTypeAndLength(resType, length);
+            resType = this._type;
+        }
+        return new Expression_ReturnValue(val, resType);
+    }
+    fillData(taskRef, parser) {
+        let tokensVector;
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
+        if (this._task == null)
+            this._task = taskRef;
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_EXP) + ConstInterface.MG_TAG_EXP.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 Command.FillData() out of string bounds");
+    }
+    initElements(tokensVector) {
+        let expStr;
+        let attribute, valueStr;
+        for (let j = 0; j < tokensVector.length; j += 2) {
+            attribute = (tokensVector.get_Item(j));
+            valueStr = (tokensVector.get_Item(j + 1));
+            switch (attribute) {
+                case XMLConstants.MG_ATTR_VALUE:
+                    if (Environment.Instance.GetDebugLevel() > 1) {
+                        expStr = valueStr;
+                        this.buildByteArray(expStr);
+                    }
+                    else
+                        this._expBytes = Misc.ToSByteArray(Base64.decodeToByte(valueStr));
+                    break;
+                case XMLConstants.MG_ATTR_ID:
+                    this._id = XmlParser.getInt(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_COMPUTE_BY:
+                    this._computeBy = valueStr[0];
+                    break;
+                default:
+                    Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in Expression.initElements class. Insert case to Expression.initElements for " + attribute);
+                    break;
+            }
+        }
+        if (!this.computedByClient())
+            this._cmdsToServer = this._task.getMGData().CmdsToServer;
+    }
+    buildByteArray(expStr) {
+        if (expStr === null || expStr.length === 0 || expStr.length % 2 > 0) {
+            Logger.Instance.WriteExceptionToLogWithMsg("in Expression.buildByteArray() expStr cannot be changed " + expStr);
+            return;
+        }
+        this._expBytes = new Int8Array(expStr.length / 2);
+        for (let i = 0; i < expStr.length; i = i + 2) {
+            let twoHexDigits = expStr.substr(i, 2);
+            this._expBytes[i / 2] = NUM_TYPE.toSByte(NNumber.Parse(twoHexDigits, NumberStyles.HexNumber));
+        }
+    }
+    getId() {
+        return this._id;
+    }
+    computedByClient() {
+        return this._computeBy !== 'S';
+    }
+    computedByClientOnly() {
+        return this._computeBy === 'C';
+    }
+    computedByServerOnly() {
+        return this._computeBy === 'S';
+    }
+    getTask() {
+        return this._task;
+    }
+    SetResultValue(result, type_) {
+        this._resultValue = result;
+        this._type = type_;
+    }
+    toString() {
+        return NString.Format("{{Expression #{0} of {1}}}", this._id, this._task);
+    }
+}
+export class Expression_ReturnValue {
+    constructor(mgVal_, type_) {
+        this.mgVal = null;
+        this.type = StorageAttribute.NONE;
+        this.mgVal = mgVal_;
+        this.type = type_;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Expression.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/exp/Expression.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,OAAO,EAAE,OAAO,EAAE,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAC1E,OAAO,EAAC,gBAAgB,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAC,MAAM,kBAAkB,CAAC;AACjG,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAIzE,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAG1D,OAAO,EAAC,cAAc,EAAC,MAAM,2CAA2C,CAAC;AACzE,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAK/C,MAAM,OAAO,UAAU;IAerB;QAdQ,iBAAY,GAAmB,IAAI,CAAC;QACpC,kBAAa,GAAkB,IAAI,CAAC;QACpC,eAAU,GAAW,IAAI,CAAC;QAC1B,cAAS,GAAc,IAAI,CAAC;QAC5B,QAAG,GAAW,CAAC,CAAC,CAAC;QACjB,iBAAY,GAAqB,gBAAgB,CAAC,IAAI,CAAC;QACvD,iBAAY,GAAW,IAAI,CAAC;QAC5B,UAAK,GAAS,IAAI,CAAC;QACnB,UAAK,GAAqB,gBAAgB,CAAC,IAAI,CAAC;QAChD,4BAAuB,GAAqB,gBAAgB,CAAC,IAAI,CAAC;IAM1E,CAAC;IAEM,mBAAmB;QACxB,OAAO,IAAI,CAAC,uBAAuB,CAAC;IACtC,CAAC;IAOD,KAAK,CAAC,+BAA+B,CAAC,OAAyB,EAAE,MAAc;QAC7E,IAAI,MAAc,CAAC;QACnB,IAAI,oBAAoB,GAAuB,gBAAgB,CAAC,IAAI,CAAC;QACrE,IAAI,IAAI,CAAC,gBAAgB,EAAE,EAAE;YAE3B,IAAI,MAAM,GAAW,MAAM,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;YAEzF,IAAI,MAAM,CAAC,MAAM;gBACf,MAAM,GAAG,IAAI,CAAC;iBACX,IAAI,OAAO,KAAK,gBAAgB,CAAC,WAAW,IAAI,MAAM,CAAC,IAAI,KAAK,gBAAgB,CAAC,IAAI,EAAE;gBACxF,IAAI,UAAU,CAAC,oBAAoB,CAAC,MAAM,CAAC,MAAM,CAAC;oBAChD,MAAM,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;;oBAE1B,MAAM,GAAG,IAAI,CAAC;aACjB;iBACE,IAAI,MAAM,CAAC,IAAI,KAAK,gBAAgB,CAAC,WAAW,IAAI,OAAO,KAAK,gBAAgB,CAAC,WAAW,IAAI,OAAO,KAAK,gBAAgB,CAAC,IAAI;gBACpI,MAAM,GAAG,IAAI,CAAC;;gBAEd,MAAM,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;YAE5B,IAAI,CAAC,MAAM,CAAC,MAAM;gBAChB,oBAAoB,GAAG,MAAM,CAAC,IAAI,CAAC;SACtC;aACI;YACH,IAAI,KAAK,GAAiB,YAAY,CAAC,aAAa,CAAC,cAAc,EAAE,CAAC;YACtE,IAAI,WAAW,GAAS,IAAI,CAAC;YAE7B,IAAI,KAAK,KAAK,IAAI;gBAChB,WAAW,GAAS,KAAK,CAAC,iBAAiB,EAAE,CAAC;YAGhD,IAAI,OAAO,KAAK,IAAI,CAAC,YAAY;gBAC/B,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;YAC5H,MAAM,YAAY,CAAC,WAAW,CAAC,iCAAiC,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;YAE9G,IAAI,OAAO,KAAK,gBAAgB,CAAC,IAAI,IAAI,OAAO,KAAK,gBAAgB,CAAC,WAAW;gBAC/E,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC;iBACxB,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI,IAAI,IAAI,CAAC,YAAY,KAAK,GAAG;gBAC9D,MAAM,GAAG,EAAE,CAAC;;gBAEZ,MAAM,GAAG,WAAW,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;SAC9D;QACD,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC;QAC5B,IAAI,OAAO,KAAK,gBAAgB,CAAC,IAAI;YACnC,IAAI,CAAC,uBAAuB,GAAG,oBAAoB,CAAC;QACtD,OAAO,MAAM,CAAC;IAChB,CAAC;IAQD,KAAK,CAAC,qBAAqB;QACzB,OAAO,MAAM,mBAAmB,CAAC,qBAAqB,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IACrF,CAAC;IAOD,KAAK,CAAC,mBAAmB,CAAC,OAAyB;QACjD,IAAI,MAAM,GAAY,KAAK,CAAC;QAC5B,IAAI,MAAc,CAAC;QAEnB,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACzB,MAAM,GAAG,MAAM,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;aAE1E;YACH,IAAI,KAAK,GAAiB,YAAY,CAAC,aAAa,CAAE,cAAc,EAAE,CAAC;YACvE,IAAI,WAAW,GAAS,IAAI,CAAC;YAE7B,IAAI,KAAK,KAAK,IAAI;gBAChB,WAAW,GAAS,KAAK,CAAC,iBAAiB,EAAE,CAAC;YAGhD,IAAI,OAAO,KAAK,IAAI,CAAC,YAAY;gBAC/B,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC;YAEvH,MAAM,YAAY,CAAC,WAAW,CAAC,iCAAiC,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;YAE9G,IAAI,MAAc,CAAC;YACnB,IAAI,OAAO,KAAK,gBAAgB,CAAC,IAAI,IAAI,OAAO,KAAK,gBAAgB,CAAC,WAAW;gBAC/E,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC;iBACxB,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI,IAAI,IAAI,CAAC,YAAY,KAAK,GAAG;gBAC9D,MAAM,GAAG,EAAE,CAAC;;gBAEZ,MAAM,GAAG,WAAW,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAE7D,IAAI,MAAM,KAAK,IAAI;gBACjB,MAAM,GAAG,IAAI,CAAC;YAGhB,IAAI,OAAO,KAAK,gBAAgB,CAAC,IAAI;gBACnC,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC;YAEvB,MAAM,GAAG,IAAI,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;SAC9C;QACD,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC;QAC5B,OAAO,MAAM,CAAC;IAChB,CAAC;IAMD,KAAK,CAAC,qBAAqB,CAAC,MAAc;QACxC,IAAI,OAAO,GAAqB,gBAAgB,CAAC,IAAI,CAAC;QACtD,IAAI,GAAW,CAAC;QAChB,IAAI,IAAI,CAAC,gBAAgB,EAAE,EAAE;YAC3B,IAAI,MAAM,GAAW,MAAM,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;YAGzF,IAAI,MAAM,CAAC,MAAM;gBACf,GAAG,GAAG,IAAI,CAAC;;gBAEX,GAAG,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;YAEzB,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC;SACvB;aACI;YACF,GAAG,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAClE,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC;SACvB;QACD,OAAO,IAAI,sBAAsB,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAClD,CAAC;IAKM,QAAQ,CAAC,OAAa,EAAE,MAAiB;QAC9C,IAAI,YAA0B,CAAC;QAC/B,IAAI,UAAU,GAAW,MAAM,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;QAEnG,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI;YACpB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC;QAEvB,IAAI,UAAU,KAAK,CAAC,CAAC,IAAI,UAAU,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC,MAAM,EAAE;YAEhE,IAAI,GAAG,GAAW,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;YACrD,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,cAAc,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAChG,YAAY,GAAG,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,cAAc,CAAC,CAAC;YACpG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;YAChC,MAAM,CAAC,YAAY,CAAC,UAAU,GAAG,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;SAChE;;YAEC,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,4CAA4C,CAAC,CAAC;IAC7F,CAAC;IAOO,YAAY,CAAC,YAA0B;QAC7C,IAAI,MAAc,CAAC;QACnB,IAAI,SAAiB,EAAE,QAAQ,CAAC;QAEhC,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE;YACvD,SAAS,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;YACvC,QAAQ,GAAG,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAE1C,QAAQ,SAAS,EAAE;gBACjB,KAAK,YAAY,CAAC,aAAa;oBAE7B,IAAI,WAAW,CAAC,QAAQ,CAAC,aAAa,EAAE,GAAG,CAAC,EAAE;wBAC5C,MAAM,GAAG,QAAQ,CAAC;wBAClB,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;qBAC7B;;wBAEC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC;oBACpE,MAAM;gBAER,KAAK,YAAY,CAAC,UAAU;oBAC1B,IAAI,CAAC,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;oBACtC,MAAM;gBAER,KAAK,cAAc,CAAC,kBAAkB;oBACpC,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;oBAC9B,MAAM;gBAER;oBACE,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,oGAAoG,GAAG,SAAS,CAAC,CAAC;oBAC7J,MAAM;aACT;SACF;QACD,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;YAC1B,IAAI,CAAC,aAAa,GAAkB,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,YAAY,CAAC;IAC5E,CAAC;IAKO,cAAc,CAAC,MAAc;QACnC,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,EAAE;YACnE,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,0DAA0D,GAAG,MAAM,CAAC,CAAC;YAChH,OAAO;SACR;QAED,IAAI,CAAC,SAAS,GAAG,IAAI,SAAS,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAClD,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACpD,IAAI,YAAY,GAAW,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAC/C,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;SAC/F;IACH,CAAC;IAKD,KAAK;QACH,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAKO,gBAAgB;QACtB,OAAO,IAAI,CAAC,UAAU,KAAK,GAAG,CAAQ;IACxC,CAAC;IAKD,oBAAoB;QAClB,OAAO,IAAI,CAAC,UAAU,KAAK,GAAG,CAAQ;IACxC,CAAC;IAKD,oBAAoB;QAClB,OAAO,IAAI,CAAC,UAAU,KAAK,GAAG,CAAQ;IACxC,CAAC;IAKD,OAAO;QACL,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IASD,cAAc,CAAC,MAAc,EAAE,KAAuB;QACpD,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC;QAC3B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,QAAQ;QACN,OAAO,OAAO,CAAC,MAAM,CAAC,4BAA4B,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5E,CAAC;CACF;AAKD,MAAM,OAAO,sBAAsB;IAOjC,YAAY,MAAc,EAAE,KAAuB;QANnD,UAAK,GAAW,IAAI,CAAC;QACrB,SAAI,GAAqB,gBAAgB,CAAC,IAAI,CAAC;QAM7C,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC;QACpB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;IACpB,CAAC;CACF","sourcesContent":["import {List, NString, NNumber, NumberStyles} from \"@magic-xpa/mscorelib\";\r\nimport {StorageAttribute, Logger, Misc, Base64, XmlParser, XMLConstants} from \"@magic-xpa/utils\";\r\nimport {ExpVal, VectorType, RecordUtils, NUM_TYPE} from \"@magic-xpa/gui\";\r\nimport {IResultValue} from \"../rt/IResultValue\";\r\nimport {IClientCommand} from \"../commands/IClientCommand\";\r\nimport {CommandsTable} from \"../CommandsTable\";\r\nimport {ExpressionEvaluator} from \"./ExpressionEvaluator\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {RunTimeEvent} from \"../event/RunTimeEvent\";\r\nimport {CommandFactory} from \"../commands/ClientToServer/CommandFactory\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\nimport { Environment } from \"../env/Environment\";\r\nimport { AccessHelper } from \"../AccessHelper\";\r\n\r\n/// <summary>\r\n///   data for <exp ...> tag\r\n/// </summary>\r\nexport class Expression implements IResultValue {\r\n  private _cmdToServer: IClientCommand = null;\r\n  private _cmdsToServer: CommandsTable = null;\r\n  private _computeBy: string = '\\0';\r\n  private _expBytes: Int8Array = null;\r\n  private _id: number = -1;\r\n  private _prevResType: StorageAttribute = StorageAttribute.NONE;\r\n  private _resultValue: string = null; // the result returned by the server\r\n  private _task: Task = null;\r\n  private _type: StorageAttribute = StorageAttribute.NONE; // the type of the result which is returned by the server\r\n  private _clientStorageAttribute: StorageAttribute = StorageAttribute.NONE; // the type of the result witch is returned by the client (use for custom properties)\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  constructor() {\r\n  }\r\n\r\n  public GetStorageAttribute(): StorageAttribute {\r\n    return this._clientStorageAttribute;\r\n  }\r\n  /// <summary>\r\n  ///   evaluate the expression and return the result\r\n  /// </summary>\r\n  /// <param name = \"resType\">is the expected type </param>\r\n  /// <param name = \"length\">of expected Alpha string </param>\r\n  /// <returns> evaluated value or null if value evaluated to null (by ExpressionEvaluator) </returns>\r\n  async evaluateWithResultTypeAndLength(resType: StorageAttribute, length: number): Promise<string> {\r\n    let retVal: string;\r\n    let retExpressionStorage : StorageAttribute =  StorageAttribute.NONE;\r\n    if (this.computedByClient()) {\r\n\r\n      let expVal: ExpVal = await ExpressionEvaluator.eval(this._expBytes, resType, this._task);\r\n\r\n      if (expVal.IsNull)\r\n        retVal = null;\r\n      else if (resType === StorageAttribute.BLOB_VECTOR && expVal.Attr === StorageAttribute.BLOB) {\r\n          if (VectorType.validateBlobContents(expVal.StrVal))\r\n            retVal = expVal.ToMgVal();\r\n          else\r\n            retVal = null;\r\n        }\r\n      else if (expVal.Attr === StorageAttribute.BLOB_VECTOR && resType !== StorageAttribute.BLOB_VECTOR && resType !== StorageAttribute.BLOB)\r\n        retVal = null;\r\n      else\r\n        retVal = expVal.ToMgVal();\r\n\r\n      if (!expVal.IsNull)\r\n        retExpressionStorage = expVal.Attr;\r\n    }\r\n    else {\r\n      let rtEvt: RunTimeEvent = AccessHelper.eventsManager.getLastRtEvent();\r\n      let mprgCreator: Task = null;\r\n\r\n      if (rtEvt !== null)\r\n        mprgCreator = <Task>rtEvt.getMainPrgCreator();\r\n\r\n      // create a new command object only when necessary\r\n      if (resType !== this._prevResType)\r\n        this._cmdToServer = CommandFactory.CreateEvaluateCommand(this._task.getTaskTag(), resType, this._id, length, mprgCreator);\r\n      await AccessHelper.mgDataTable.execRequestWithSubformRecordCycle(this._cmdsToServer, this._cmdToServer, this);\r\n\r\n      if (resType !== StorageAttribute.BLOB && resType !== StorageAttribute.BLOB_VECTOR)\r\n        retVal = this._resultValue;\r\n      else if (this._resultValue !== null && this._resultValue === \" \")\r\n        retVal = \"\";\r\n      else\r\n        retVal = RecordUtils.byteStreamToString(this._resultValue);\r\n    }\r\n    this._prevResType = resType;\r\n    if (resType === StorageAttribute.NONE)\r\n      this._clientStorageAttribute = retExpressionStorage;\r\n    return retVal;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"resType\"></param>\r\n  /// <param name=\"length\"></param>\r\n  /// <returns></returns>\r\n  async DiscardCndRangeResult(): Promise<boolean> {\r\n    return await ExpressionEvaluator.DiscardCndRangeResult(this._expBytes, this._task);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"resType\"></param>\r\n  /// <returns></returns>\r\n  async evaluateWithResType(resType: StorageAttribute): Promise<ExpVal> {\r\n    let isNull: boolean = false;\r\n    let expVal: ExpVal;\r\n\r\n    if (this.computedByClient())\r\n      expVal = await ExpressionEvaluator.eval(this._expBytes, resType, this._task);\r\n\r\n    else {\r\n      let rtEvt: RunTimeEvent = AccessHelper.eventsManager .getLastRtEvent();\r\n      let mprgCreator: Task = null;\r\n\r\n      if (rtEvt !== null)\r\n        mprgCreator = <Task>rtEvt.getMainPrgCreator();\r\n\r\n      // create a new command object only when necessary\r\n      if (resType !== this._prevResType)\r\n        this._cmdToServer = CommandFactory.CreateEvaluateCommand(this._task.getTaskTag(), resType, this._id, 0, mprgCreator);\r\n\r\n      await AccessHelper.mgDataTable.execRequestWithSubformRecordCycle(this._cmdsToServer, this._cmdToServer, this);\r\n\r\n      let retVal: string;\r\n      if (resType !== StorageAttribute.BLOB && resType !== StorageAttribute.BLOB_VECTOR)\r\n        retVal = this._resultValue;\r\n      else if (this._resultValue !== null && this._resultValue === \" \")\r\n        retVal = \"\";\r\n      else\r\n        retVal = RecordUtils.byteStreamToString(this._resultValue);\r\n\r\n      if (retVal === null)\r\n        isNull = true;\r\n\r\n      // If we don't know what result type we got, and want to keep it, as in ExpCalc\r\n      if (resType === StorageAttribute.NONE)\r\n        resType = this._type;\r\n\r\n      expVal = new ExpVal(resType, isNull, retVal);\r\n    }\r\n    this._prevResType = resType;\r\n    return expVal;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   evaluate the expression and return the ReturnValue\r\n  /// </summary\r\n  async evaluateWithResLength(length: number): Promise<Expression_ReturnValue> {\r\n    let resType: StorageAttribute = StorageAttribute.NONE;\r\n    let val: string;\r\n    if (this.computedByClient()) {\r\n      let expVal: ExpVal = await ExpressionEvaluator.eval(this._expBytes, resType, this._task);\r\n\r\n      // even if actual dotnet obj is null, we need to return blobPrefix\r\n      if (expVal.IsNull)\r\n        val = null;\r\n      else\r\n        val = expVal.ToMgVal();\r\n\r\n      resType = expVal.Attr;\r\n    }\r\n    else {\r\n       val = await this.evaluateWithResultTypeAndLength(resType, length);\r\n       resType = this._type;\r\n    }\r\n    return new Expression_ReturnValue(val, resType);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse the expression\r\n  /// </summary>\r\n  public fillData(taskRef: Task, parser: XmlParser): void {\r\n    let tokensVector: List<String>;\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());\r\n\r\n    if (this._task == null)\r\n      this._task = taskRef;\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_EXP) + ConstInterface.MG_TAG_EXP.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);\r\n    }\r\n    else\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in Command.FillData() out of string bounds\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse the expression XML tag\r\n  /// </summary>\r\n  /// <param name = \"tokensVector\">the vector of attributes and their values\r\n  /// </param>\r\n  private initElements(tokensVector: List<String>): void {\r\n    let expStr: string;\r\n    let attribute: String, valueStr;\r\n\r\n    for (let j: number = 0; j < tokensVector.length; j += 2) {\r\n      attribute = (tokensVector.get_Item(j));\r\n      valueStr = (tokensVector.get_Item(j + 1));\r\n\r\n      switch (attribute) {\r\n        case XMLConstants.MG_ATTR_VALUE:\r\n          // if we work in hex\r\n          if (Environment.Instance.GetDebugLevel() > 1) {\r\n            expStr = valueStr;\r\n            this.buildByteArray(expStr);\r\n          }\r\n          else\r\n            this._expBytes = Misc.ToSByteArray(Base64.decodeToByte(valueStr));\r\n          break;\r\n\r\n        case XMLConstants.MG_ATTR_ID:\r\n          this._id = XmlParser.getInt(valueStr);\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_COMPUTE_BY:\r\n          this._computeBy = valueStr[0];\r\n          break;\r\n\r\n        default:\r\n          Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such tag in Expression.initElements class. Insert case to Expression.initElements for \" + attribute);\r\n          break;\r\n      }\r\n    }\r\n    if (!this.computedByClient())\r\n      this._cmdsToServer = <CommandsTable>this._task.getMGData().CmdsToServer;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build the expression as a byte array\r\n  /// </summary>\r\n  private buildByteArray(expStr: string): void {\r\n    if (expStr === null || expStr.length === 0 || expStr.length % 2 > 0) {\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in Expression.buildByteArray() expStr cannot be changed \" + expStr);\r\n      return;\r\n    }\r\n\r\n    this._expBytes = new Int8Array(expStr.length / 2);\r\n    for (let i: number = 0; i < expStr.length; i = i + 2) {\r\n      let twoHexDigits: string = expStr.substr(i, 2);\r\n      this._expBytes[i / 2] = NUM_TYPE.toSByte(NNumber.Parse(twoHexDigits, NumberStyles.HexNumber));\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get ID of the Expression\r\n  /// </summary>\r\n  getId(): number {\r\n    return this._id;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the expression may be computed by the Client\r\n  /// </summary>\r\n  private computedByClient(): boolean {\r\n    return this._computeBy !== 'S'/*'S'*/; // i.e, Client or Don't care\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the expression can be computed ONLY by the Client\r\n  /// </summary>\r\n  computedByClientOnly(): boolean {\r\n    return this._computeBy === 'C'/*'C'*/;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the expression can be computed ONLY by the Server\r\n  /// </summary>\r\n  computedByServerOnly(): boolean {\r\n    return this._computeBy === 'S'/*'S'*/;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the task\r\n  /// </summary>\r\n  getTask(): Task {\r\n    return this._task;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set result value by the Result command\r\n  /// </summary>\r\n  /// <param name = \"result\">the result computed by the server\r\n  /// </param>\r\n  /// <param name = \"type_\">the type of the result which was computed by the server\r\n  /// </param>\r\n  SetResultValue(result: string, type_: StorageAttribute): void {\r\n    this._resultValue = result;\r\n    this._type = type_;\r\n  }\r\n\r\n  toString(): string {\r\n    return NString.Format(\"{{Expression #{0} of {1}}}\", this._id, this._task);\r\n  }\r\n}\r\n\r\n/// <summary>\r\n///   represents the returned evaluated expression value and it's type (attribute)\r\n/// </summary>\r\nexport class Expression_ReturnValue {\r\n  mgVal: string = null;\r\n  type: StorageAttribute = StorageAttribute.NONE;\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  constructor(mgVal_: string, type_: StorageAttribute) {\r\n    this.mgVal = mgVal_;\r\n    this.type = type_;\r\n  }\r\n}\r\n"]}