@magic-xpa/engine 4.1200.0-dev4120.70 → 4.1200.0-dev4120.72

package/fesm2022/magic-xpa-engine.mjs

@@ -515,6 +515,7 @@ class ConstInterface {
     static RC_TOKEN_CTX_GROUP = "CTXGROUP=";
     static RC_TOKEN_SESSION_COUNT = "SESSION=";
     static RC_TOKEN_DATA = "DATA=";
+    static RC_TOKEN_TARGET_FILE = "TARGETFILE=";
     static WEBCLIENT_REINITIALIZE_REQUEST = "WCREINITIALIZEREQUEST=Y";
     static MAIN_PROG_VIEW = "MainProgramsDataView";
     static GLOBAL_PARAM_LIST = "GlobalParamList";
@@ -5560,20 +5561,26 @@ class HttpClientBase {
     /// </summary>
     /// <param name="requestURL"></param>
     /// <returns></returns>
-    DecideOnRequestMethod(requestContent, requestURL) {
+    DecideOnRequestMethod(requestContent, requestContentType, requestURL) {
         let method = RequestMethod.Get;
-        if (requestContent === null) {
-            // requestContent (== content to be sent to server) is allowed only in POST requests. In case no content is required, opt for GET (for the aforementioned performance reason).
-            method = RequestMethod.Get;
-        }
+        // the method optimizes the request method (favoring GET over POST whenever possible) for performance reasons (one roundtrip to the web server).
+        if (requestContentType != null)
+            // the requestContentType should be sent only for non-textual content, which can't be added to the URL of a GET request
+            method = RequestMethod.Post;
         else {
-            if (requestURL.value.length + 1 + requestContent.length <= this._HTTPMaxURLLength) {
-                // append the request content to the URL, and switch to using a GET request.
-                requestURL.value = requestURL.value + "?" + requestContent;
+            if (requestContent === null) {
+                // requestContent (== content to be sent to server) is allowed only in POST requests. In case no content is required, opt for GET (for the aforementioned performance reason).
                 method = RequestMethod.Get;
             }
             else {
-                method = RequestMethod.Post;
+                if (requestURL.value.length + 1 + requestContent.length <= this._HTTPMaxURLLength) {
+                    // append the request content to the URL, and switch to using a GET request.
+                    requestURL.value = requestURL.value + "?" + requestContent;
+                    method = RequestMethod.Get;
+                }
+                else {
+                    method = RequestMethod.Post;
+                }
             }
         }
         return method;
@@ -5584,14 +5591,14 @@ class HttpClientBase {
     /// <param name="requestURL">URL to be accessed.</param>
     /// <param name="requestContent">content to be sent to server (relevant only for POST method - is null for other methods).</param>
     /// <returns>response (from the server).</returns>
-    async GetContent(requestURL, requestContent, useCache) {
+    async GetContent(requestURL, requestContent, requestContentType, useCache) {
         let contentFromServer = new RefParam(null);
         let requestUrlRef = new RefParam(requestURL);
-        let httpMethod = this.DecideOnRequestMethod(requestContent, requestUrlRef);
+        let httpMethod = this.DecideOnRequestMethod(requestContent, requestContentType, requestUrlRef);
         requestURL = requestUrlRef.value;
         try {
             // Execute the http request
-            let response = await this.ExecuteHttpRequest(requestURL, requestContent, useCache, httpMethod, contentFromServer);
+            let response = await this.ExecuteHttpRequest(requestURL, requestContent, requestContentType, useCache, httpMethod, contentFromServer);
             if (response != null) {
                 Logger.Instance.WriteServerToLog("Incoming Headers : " + HttpClientBase.HeadersToString(response.headers, true));
                 // set the next session counter (which will be expected by the server in the next request).
@@ -5616,7 +5623,7 @@ class HttpClientBase {
     /// <param name="httpMethod">enum RequestMethod to specify the method that will be used to execute the request.</param>
     /// <param name="contentFromServer">content received from the response. [OUT]</param>
     /// <returns></returns>
-    async ExecuteHttpRequest(urlString, requestContent, useCache, httpMethod, contentFromServer) {
+    async ExecuteHttpRequest(urlString, requestContent, requestContentType, useCache, httpMethod, contentFromServer) {
         let httpResponse = null;
         this.prepareRequest();
         let httpCommunicationTimeoutMS = HttpClientEvents.GetHttpCommunicationTimeout();
@@ -5653,12 +5660,14 @@ class HttpClientBase {
                 }
                 let timeBeforeRequest = Misc.getSystemMilliseconds();
                 Logger.Instance.WriteServerToLog(NString.Format("Accessing (method: '{0}'): '{1}'", httpMethod, urlString));
-                Logger.Instance.WriteServerToLog("Outgoing Headers : " + HttpClientBase.HeadersToString(httpHeaders, false));
                 if (httpMethod === RequestMethod.Post) {
+                    if (requestContentType != null)
+                        httpHeaders = httpHeaders.append('Content-Type', "application/octet-stream");
                     // TODO: Handle Expect100Continue.
                     // httpWebRequest.ServicePoint.Expect100Continue = this.GetHTTPExpect100Continue();
                     // this.WriteContentToRequest(requestContent, httpWebRequest);
                 }
+                Logger.Instance.WriteServerToLog("Outgoing Headers : " + HttpClientBase.HeadersToString(httpHeaders, false));
                 // =============================================================================================================
                 // send the request & get the response:
                 // =============================================================================================================
@@ -5779,7 +5788,13 @@ class HttpClientAsync extends HttpClientBase {
         return httpHeaders;
     }
     async sendRequestToServer(httpMethod, urlString, httpHeaders, requestContent, contentFromServer) {
-        let httpResponse = await this.httpClient.request(RequestMethod[httpMethod], urlString, { headers: httpHeaders, responseType: "text", observe: "response", body: requestContent }).toPromise();
+        let contents = requestContent;
+        let responseType = "text";
+        if (requestContent instanceof Uint8Array) {
+            contents = requestContent.buffer;
+            responseType = "arraybuffer";
+        }
+        let httpResponse = await this.httpClient.request(RequestMethod[httpMethod], urlString, { headers: httpHeaders, responseType: responseType, observe: "response", body: contents }).toPromise();
         contentFromServer.value = httpResponse.body;
         return httpResponse;
     }
@@ -5868,7 +5883,7 @@ class HttpManager {
     SetCommunicationsFailureHandler(handler) {
         this.getHttpClient().CommunicationsFailureHandler = handler;
     }
-    async GetContent(requestedURL, requestContent, useCache, isError) {
+    async GetContent(requestedURL, requestContent, requestContentType, useCache, isError) {
         let response;
         Debug.Assert(this.getHttpClient() != null);
         // let startTime: number = Misc.getSystemMilliseconds();
@@ -5876,8 +5891,9 @@ class HttpManager {
             Logger.Instance.WriteServerToLog("*************************************************************************************************");
             isError.value = false;
             Logger.Instance.WriteServerToLog(requestedURL);
+            requestContent = requestContent instanceof ArrayBuffer ? this.arrayBufferToString(requestContent) : requestContent;
             HttpManager.LogAccessToServer("", requestContent);
-            response = await this.getHttpClient().GetContent(requestedURL, requestContent, useCache);
+            response = await this.getHttpClient().GetContent(requestedURL, requestContent, requestContentType, useCache);
             Debug.Assert(response !== null);
             let errorResponse = HttpManager.CheckAndGetErrorResponse(response);
             if (errorResponse !== null) {
@@ -5914,12 +5930,20 @@ class HttpManager {
             //               );
         }
     }
+    // <summary>
+    // Converts an ArrayBuffer to a UTF-8 encoded string.
+    // </summary>
+    arrayBufferToString(arrayBuffer) {
+        const decoder = new TextDecoder('utf-8');
+        return decoder.decode(arrayBuffer);
+    }
     /// <summary>Check if an HTTP response is an error response.
     /// <param name="httpResponse">response returned to an HTTP request.</param>
     /// <returns>if the response contains the error indicator - the error indicator is truncated and the remaining is returned.
     /// otherwise - null (indicating that the 'http Response' didn't contain an error).</returns>
     static CheckAndGetErrorResponse(httpResponse) {
         let errorResponse = null;
+        httpResponse = httpResponse instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(httpResponse) : httpResponse;
         if (httpResponse.startsWith(ConstInterface.V24_RIA_ERROR_PREFIX))
             errorResponse = httpResponse.substr(ConstInterface.V24_RIA_ERROR_PREFIX.length);
         return errorResponse;
@@ -7280,6 +7304,8 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
     /// an xml/html error</summary>
     /// <param name="response"></param>
     HandleErrorResponse(response) {
+        if (response instanceof ArrayBuffer)
+            response = this.ArrayBufferToString(response);
         try {
             // error responses are always scrambled by the web server.
             Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + response);
@@ -7296,17 +7322,27 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
             throw new ServerError(response);
         }
     }
+    // <summary>
+    // Converts an ArrayBuffer to a UTF-8 encoded string.
+    // </summary>
+    ArrayBufferToString(arrayBuffer) {
+        const decoder = new TextDecoder('utf-8');
+        return decoder.decode(arrayBuffer);
+    }
     /// <summary>send 'encodedBody' to 'url' and receive a response.
     /// </summary>
     /// <param name="url">URL to be accessed.</param>
     /// <param name="encodedBody">In case of POST, content to be sent to server. For other methods, null.</param>
     /// <returns>the response from the server</returns>
     async ExecuteRequest(url, encodedBody) {
-        return await this.GetContent(url, false, encodedBody);
+        let response = await this.GetContent(url, false, encodedBody);
+        return response instanceof ArrayBuffer ? this.ArrayBufferToString(response) : response;
     }
-    async GetContent(requestedURL, useCache, requestContent) {
+    async GetContent(requestedURL, useCache, requestContent, requestContentType) {
         if (isUndefined(requestContent))
             requestContent = null;
+        if (isUndefined(requestContentType))
+            requestContentType = null;
         let responseStr;
         try {
             // if relative, prefix with the 'protocol://server/' from which the rich-client was activated
@@ -7317,7 +7353,7 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
                 AccessHelper.eventsManager.CheckAndShowSpinner(true);
             });
             let isError = new RefParam(false);
-            responseStr = await HttpManager.GetInstance().GetContent(requestedURL, requestContent, useCache, isError);
+            responseStr = await HttpManager.GetInstance().GetContent(requestedURL, requestContent, requestContentType, useCache, isError);
             spinnerTimerSubscription.unsubscribe();
             spinnerTimerSubscription = null;
             if (isError.value) {
@@ -7341,6 +7377,26 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
         }
         return responseStr;
     }
+    // <summary> Upload contents to a file on server </summary>
+    // <param name="serverFileName">filename to be saved on the server.</param>
+    // <param name="fileContent">file content to be sent to server.</param>
+    // <returns> Return status number 0(Success) , 2(Destination cannot be created) or 3(Problem uploading) </returns>
+    async UploadFileToServer(fileContent, serverFileName) {
+        const contentType = "application/octet-stream";
+        const encodedName = HttpUtility.UrlEncode(serverFileName, Encoding.UTF8);
+        const sessionID = this.SessionId;
+        let queryStr = `${ConstInterface.REQ_ARG_START}${ConstInterface.RC_INDICATION}${ConstInterface.RC_TOKEN_CTX_ID}${ClientManager.Instance.GetRuntimeCtxID()}`;
+        if (!isNullOrUndefined(sessionID))
+            queryStr += `${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_SESSION_ID}${sessionID}`;
+        queryStr += `${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_SESSION_COUNT}${this.GetSessionCounter()}${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_TARGET_FILE}${encodedName}`;
+        const url = ServerConfig.Instance.getServerURL() + queryStr;
+        let response = await this.GetContent(url, false, fileContent, contentType);
+        if (response instanceof ArrayBuffer) {
+            let uInt8Array = new Uint8Array(response);
+            return uInt8Array[0];
+        }
+        return response;
+    }
     ClientActivated() {
         // log the values as client is active again
         // TODO - formatting
@@ -8150,6 +8206,7 @@ class LanguageData {
                     msgsInCommentString = this._constMessagesContent;
                 }
                 if (msgsInCommentString != null) {
+                    msgsInCommentString = msgsInCommentString instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(msgsInCommentString) : msgsInCommentString;
                     // ignore the comment wrapper
                     let startData = msgsInCommentString.indexOf(START_TAG);
                     let endData = msgsInCommentString.indexOf(END_TAG) + END_TAG.length;
@@ -8239,8 +8296,8 @@ class LanguageData {
             else if (this._mlsFileUrl != null) {
                 if (this._mlsFileUrl.startsWith("./"))
                     this._mlsFileUrl = NString.Replace(this._mlsFileUrl, './', ClientManager.GetAssetsURL() + '/cache/');
-                let contentStr = await CommandsProcessorManager.GetContent(this._mlsFileUrl, true);
-                let buffer = contentStr;
+                let buffer = await CommandsProcessorManager.GetContent(this._mlsFileUrl, true);
+                buffer = buffer instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(buffer) : buffer;
                 if (buffer != null && buffer.length > 0) {
                     let contentLen = buffer.length;
                     this._mlsStrings = new Hashtable();
@@ -11263,6 +11320,7 @@ class Environment {
                         case ConstInterface.MG_TAG_KBDMAP_URL:
                             break;
                         case ConstInterface.MG_TAG_ENV_PARAM_URL:
+                            Content = Content instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(Content) : Content;
                             let innerXmlParser = new XmlParser(Content);
                             while (AccessHelper.envParamsTable.mirrorFromXML(innerXmlParser.getNextTag(), innerXmlParser)) {
                             }
@@ -27154,6 +27212,7 @@ class TableCacheManager {
             try {
                 let residentTableContentStr = await server.GetContent(tableUId, true);
                 try {
+                    residentTableContentStr = residentTableContentStr instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(residentTableContentStr) : residentTableContentStr;
                     RuntimeContextBase.Instance.Parser.loadTableCacheData(residentTableContentStr);
                 }
                 catch (innerException) {
@@ -32789,6 +32848,7 @@ class Task extends TaskBase {
             if (taskCacheURL.startsWith("./"))
                 taskCacheURL = NString.Replace(taskCacheURL, './', ClientManager.GetAssetsURL() + '/cache/');
             taskContentOriginal = await Task.CommandsProcessor.GetContent(taskCacheURL, true);
+            taskContentOriginal = taskContentOriginal instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(taskContentOriginal) : taskContentOriginal;
         }
         // prefix the original data till the start of the current <taskURL>
         let taskContentFinal = new StringBuilder(xmlData.substr(0, RuntimeContextBase.Instance.Parser.getCurrIndex() - (ConstInterface.MG_TAG_TASKURL.length + 1)), taskContentOriginal.length);
@@ -39284,7 +39344,7 @@ class CommandsTable {
     }
 }
 
-let CurrentClientVersion = '4.1200.0-dev4120.70';
+let CurrentClientVersion = '4.1200.0-dev4120.72';
 
 // @dynamic
 class ClientManager {
@@ -39632,13 +39692,19 @@ class ClientManager {
     /// </summary>
     async LoadExecutionProps() {
         // return true, if successfully loaded.
-        let response = "";
+        let response = null;
         let succeeded = true;
         try {
             // isError cannot be true here, because it is returned by runtime engine and to read execution properties, we do not reach the engine.
             let isError = new RefParam(false);
-            response = await HttpManager.GetInstance().GetContent(ClientManager._executionPropertiesFileName, null, false, isError);
-            ServerConfig.Instance.Init(JSON.parse(response));
+            response = await HttpManager.GetInstance().GetContent(ClientManager._executionPropertiesFileName, null, null, false, isError);
+            if (response instanceof ArrayBuffer) {
+                const decoder = new TextDecoder('utf-8');
+                ServerConfig.Instance.Init(JSON.parse(decoder.decode(response)));
+            }
+            else {
+                ServerConfig.Instance.Init(JSON.parse(response));
+            }
             let assetsURL = ServerConfig.Instance.getAssetsURL();
             if (assetsURL !== null) {
                 ClientManager.assetsURL = assetsURL;
@@ -39672,6 +39738,9 @@ class ClientManager {
         }
         return pic;
     }
+    static UploadFileToServer(fileContent, serverFileName) {
+        return RemoteCommandsProcessor.GetInstance().UploadFileToServer(fileContent, serverFileName);
+    }
     /// <summary>
     ///   Get formatted value
     /// </summary>
@@ -39819,6 +39888,9 @@ class MagicBridge {
     static GetControlPictureMask(taskId, controlName) {
         return ClientManager.GetControlPictureMask(taskId, controlName);
     }
+    static UploadFileToServer(fileContent, serverFileName) {
+        return ClientManager.UploadFileToServer(fileContent, serverFileName);
+    }
     static GetFormattedValue(taskId, controlName, value, rowId) {
         return ClientManager.GetFormattedValue(taskId, controlName, value, rowId);
     }