@agilemotion/oui-react-js 1.7.1 → 1.7.3

package/dist/ApplicationManager.js

@@ -654,6 +654,9 @@ class ApplicationManager {
     var _this3 = this;
     return function (parameterConfig) {
       let eventData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      if (parameterConfig.static) {
+        return parameterConfig.value;
+      }
       let expression = parameterConfig.value.toString();
       let isEvent = expression.startsWith('$event.data');
       if (isEvent) {
@@ -725,7 +728,9 @@ class ApplicationManager {
     if (this.graphs.length > 0) {
       let graph = this.graphs[this.graphs.length - 1];
       let view = graph.config.isWindow ? this.getTopWindowView() : this.getTopAnchorView();
-      this.closeView(view.config.id, false);
+      if (view) {
+        this.closeView(view.config.id, false);
+      }
       if (!_Utils.default.isNull(graph.anchorHistoryElement) && routeBackToAnchor) {
         this.loadAnchor(graph);
       }
@@ -755,11 +760,11 @@ class ApplicationManager {
       graph.anchorView = this.getTopAnchorView(); //= this.getCurrentView();
       graph.anchorHistoryElement = this.navHistory[this.navHistory.length - 1];
     }
-    graph.init();
+    this.graphs.push(graph);
     for (const parameterValue of parameterValues) {
       graph.model[parameterValue.name] = parameterValue.value;
     }
-    this.graphs.push(graph);
+    graph.init();
   }
   getTopAnchorView() {
     for (let i = this.views.length - 1; i >= 0; i--) {

package/dist/BasicAppHome.js

@@ -99,7 +99,7 @@ const BasicAppHome = props => {
   }, /*#__PURE__*/_react.default.createElement("div", {
     className: "w-100 h-100"
   }, /*#__PURE__*/_react.default.createElement(_ThemeProvider.default, {
-    theme: (0, _core.createMuiTheme)({
+    theme: (0, _core.createTheme)({
       palette: {
         primary: {
           main: dashboardSettings.systemProfileDto.firstCorporateBrandColor

package/dist/DynamicJS.js

@@ -68,12 +68,14 @@ class DynamicJS {
    * @param componentId
    * @param isScriplet
    * @param event
+   * @param scriptConfig
    */
   executeScript = (() => {
     var _this2 = this;
     return function (name, scriptCode, componentId) {
       let isScriplet = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
       let event = arguments.length > 4 ? arguments[4] : undefined;
+      let scriptConfig = arguments.length > 5 ? arguments[5] : undefined;
       let parsedScript = _this2.parseScript(scriptCode, componentId, isScriplet);
       let eventParam = null;
       if (!_Utils.default.isNull(event)) {
@@ -90,7 +92,8 @@ class DynamicJS {
         }
       } catch (e) {
         console.error(e);
-        throw new Error("Error Executing script : " + parsedScript + " - " + e.message);
+        console.error("Error Executing script : ", scriptConfig?.lines);
+        throw new Error(e.message);
       }
       return null;
     };
@@ -130,7 +133,7 @@ class DynamicJS {
       for (const line of script.lines) {
         scriptBody += _this3.parseScriptLine(line, valuesMap);
       }
-      return _this3.executeScript(name, scriptBody, componentId, false, event);
+      return _this3.executeScript(name, scriptBody, componentId, false, event, script);
     };
   })();
 }

package/dist/InteractionPortalAppHome.js

@@ -47,6 +47,11 @@ const InteractionPortalAppHome = /*#__PURE__*/_react.default.memo( /*#__PURE__*/
     }, e => {
       console.log(e);
     });
+    (0, _RestUtils.sendRequest)(location + _ApplicationManager.default.getContextRoot() + '/auth/api/v1/user/find', response => {
+      _ApplicationManager.default.setUserDetails(response);
+    }, e => {
+      console.log(e);
+    });
     setLoading(false);
   }, []);
   _react.default.useEffect(() => {

package/dist/RestService.js

@@ -0,0 +1,344 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.location = exports.invokeRpc = exports.invokeRest = void 0;
+var _Utils = _interopRequireDefault(require("./Utils"));
+var _reactPromiseTracker = require("react-promise-tracker");
+var _ApplicationManager = _interopRequireDefault(require("./ApplicationManager"));
+var _Event = _interopRequireDefault(require("./event/Event"));
+var _Observable = _interopRequireDefault(require("./event/Observable"));
+var _EventType = _interopRequireDefault(require("./event/EventType"));
+var _propTypes = require("prop-types");
+var _RestUtils = require("./RestUtils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const location = exports.location = window.location.protocol + '//' + window.location.hostname;
+const status = response => {
+  if (response.ok) {
+    return Promise.resolve(response);
+  } else {
+    return Promise.reject(response);
+  }
+};
+const json = response => {
+  return response.text();
+};
+class RestService {
+  isParamValueNull(paramValue) {
+    if (_Utils.default.isNull(paramValue)) {
+      return true;
+    }
+    return paramValue.hasOwnProperty('value') ? _Utils.default.isNull(paramValue.value) : false;
+  }
+  invokeRest(request) {
+    let service = request.service;
+    let url = service.url.startsWith('http://') || service.url.startsWith('https://') ? service.url : location + `${_ApplicationManager.default.getContextRoot() + service.url}`;
+    let requestBody = null;
+    let headers = service.headers;
+    return new Promise((resolve, reject) => {
+      if (!_Utils.default.isNull(service.parameters)) {
+        let queryString = '';
+        let pathParameters = '';
+        let requestBodyParamFound = false;
+        for (const parameter of service.parameters) {
+          let parameterValue = _ApplicationManager.default.resolveParameterValue(parameter, request.event ? request.event.data : null);
+          if (!_Utils.default.isNull(parameter.validator) && !_Utils.default.evaluateBooleanExpression(parameter.validator.nullable, parameter.name) && this.isParamValueNull(parameterValue)) {
+            reject({
+              errorType: 'INVALID_PARAMETER',
+              parameter
+            });
+            return;
+          }
+          let httpParameterType = parameter.httpParameterType;
+          if (_Utils.default.isNull(httpParameterType)) {
+            httpParameterType = 'QUERY_PARAMETER';
+          }
+          if (httpParameterType === 'QUERY_PARAMETER') {
+            if (!_Utils.default.isNull(parameterValue)) {
+              if (queryString.length > 0) {
+                queryString += '&';
+              }
+              if (!_Utils.default.isNull(service.includeParameterTypes) && service.includeParameterTypes === true) {
+                queryString += parameterValue.type + ':';
+              }
+              queryString += parameter.name + '=';
+              queryString += typeof parameterValue.value === 'string' || typeof parameterValue.value === 'number' ? parameterValue.value : JSON.stringify(parameterValue.value);
+            }
+          }
+          if (httpParameterType === 'PATH_VARIABLE') {
+            if (!_Utils.default.isNull(parameterValue)) {
+              pathParameters += '/' + (typeof parameterValue.value === 'object' ? JSON.stringify(parameterValue.value) : parameterValue.instanceType === 'TypedValue' ? parameterValue.value : parameterValue);
+            }
+          }
+          if (httpParameterType === 'HEADER') {
+            if (!_Utils.default.isNull(parameterValue)) {
+              if (!headers) {
+                headers = {};
+              }
+              headers[parameter.name] = parameterValue.value;
+            }
+          }
+          if (httpParameterType === 'REQUEST_BODY') {
+            if (requestBodyParamFound) {
+              reject(new Error("Only one request body is permitted"));
+              return;
+            } else {
+              if (!this.isParamValueNull(parameterValue)) {
+                requestBody = parameterValue.instanceType === 'TypedValue' ? parameterValue.value : parameterValue;
+                if (typeof requestBody === 'object') {
+                  requestBody.type = parameterValue.type;
+                }
+              }
+            }
+          }
+        }
+        if (pathParameters.length > 0) {
+          url += pathParameters;
+        }
+        if (queryString.length > 0) {
+          url += '?';
+          url += queryString;
+        }
+      }
+      let contentType = null;
+      if (!_Utils.default.isNull(headers)) {
+        contentType = headers['Content-Type'];
+      }
+      if (requestBody !== null && service.method === 'GET') {
+        throw new Error('A request body parameter cannot be specified for a GET request');
+      }
+      if (requestBody !== null || service.method === 'POST') {
+        this.fetchWithCustomConfig({
+          url,
+          serviceType: request.service.type,
+          method: 'POST',
+          secure: !service.url.startsWith('http://'),
+          body: requestBody,
+          headers
+        }).then(response => {
+          let path = _Utils.default.getPropertyChainPath(request.returnValueBinding);
+          if (!_Utils.default.isNull(path.valueObject) && !_Utils.default.isNull(path.property)) {
+            path.valueObject[path.property] = response;
+          }
+          resolve(this.processSuccessfulResponseData(request.component, response, request.viewId, request.successMessage));
+        }).catch(e => {
+          reject(e);
+        });
+      } else if (contentType === 'application/pdf' || contentType === 'application/vnd.ms-excel') {
+        this.fetchWithCustomConfig({
+          url,
+          serviceType: request.service.type,
+          secure: request.secure,
+          method: 'GET',
+          download: true,
+          headers
+        }).then(() => {
+          resolve();
+        }).catch(e => {
+          reject(e);
+        });
+      } else {
+        this.fetchWithCustomConfig({
+          url,
+          serviceType: request.service.type,
+          secure: !service.url.startsWith('http://'),
+          method: 'GET',
+          headers
+        }).then(response => {
+          let path = _Utils.default.getPropertyChainPath(request.returnValueBinding);
+          if (!_Utils.default.isNull(path.valueObject) && !_Utils.default.isNull(path.property)) {
+            path.valueObject[path.property] = response;
+          }
+          resolve(this.processSuccessfulResponseData(request.component, response, request.viewId, request.successMessage));
+        }).catch(e => {
+          reject(e);
+        });
+      }
+    });
+  }
+  invokeRpc(request) {
+    let rpcRequest = {};
+    rpcRequest.id = request.viewId;
+    let split = request.service.serviceId.split('.');
+    rpcRequest.service = split[1];
+    rpcRequest.method = request.service.procedureName;
+    let module = split[0].toLowerCase();
+    return new Promise((resolve, reject) => {
+      if (!_Utils.default.isNull(request.service.parameters) && request.service.parameters.length > 0) {
+        rpcRequest.parameters = [];
+        for (let i = 0; i < request.service.parameters.length; i++) {
+          let parameterConfig = request.service.parameters[i];
+          let parameter = {};
+          parameter.name = parameterConfig.name;
+          parameter.index = parameterConfig.index;
+          let val = _ApplicationManager.default.resolveParameterValue(parameterConfig, request.event ? request.event.data : null);
+          if (!_Utils.default.isNull(val)) {
+            parameter.value = val.value;
+            parameter.type = val.type;
+          }
+          if (typeof parameter.value === 'undefined') {
+            parameter.value = null;
+          }
+          if (_Utils.default.isNull(parameter.type)) {
+            parameter.type = 'String';
+          }
+          if (!_Utils.default.isNull(parameterConfig.validator) && _Utils.default.evaluateBooleanExpression(parameterConfig.validator.nullable, parameterConfig.name) === false && this.isParamValueNull(parameter)) {
+            console.error('INVALID PARAMETER : ', parameter);
+            reject({
+              errorType: 'INVALID_PARAMETER',
+              parameter
+            });
+            return;
+          }
+          rpcRequest.parameters.push(parameter);
+        }
+      }
+      this.fetchWithCustomConfig({
+        url: location + _ApplicationManager.default.getContextRoot() + '/' + module + '/api/v1/rpc/invoke',
+        serviceType: request.service.type,
+        secure: true,
+        method: 'POST',
+        body: rpcRequest,
+        track: true,
+        contentType: 'application/json'
+      }).then(response => {
+        if (request.returnValueBinding) {
+          let path = _Utils.default.getPropertyChainPath(request.returnValueBinding);
+          if (!_Utils.default.isNull(path.valueObject) && !_Utils.default.isNull(path.property)) {
+            path.valueObject[path.property] = response;
+          }
+        }
+        resolve(this.processSuccessfulResponseData(request.component, response, request.viewId, request.successMessage));
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+  fetchWithCustomConfig(request) {
+    const accessToken = sessionStorage.getItem('accessToken');
+    const idToken = sessionStorage.getItem('idToken');
+    let data = request.body ? request.body instanceof FormData ? request.body : JSON.stringify(request.body) : null;
+    let fetchConfig = request.config;
+    return new Promise((resolve, reject) => {
+      if (_Utils.default.isNull(fetchConfig)) {
+        if (_Utils.default.isNull(request.secure) || request.secure === true) {
+          fetchConfig = {
+            method: _Utils.default.isNull(request.method) ? 'GET' : request.method,
+            headers: {
+              ...request.headers,
+              'Content-Type': request.contentType ? request.contentType : 'application/x-www-form-urlencoded',
+              'Authorization': 'Bearer ' + accessToken,
+              'idToken': idToken
+            },
+            body: data
+          };
+        } else {
+          fetchConfig = {
+            method: _Utils.default.isNull(request.method) ? 'GET' : request.method,
+            headers: {
+              ...request.headers,
+              'Content-Type': request.contentType ? request.contentType : 'application/json',
+              'Accept': request.accept ? request.accept : 'application/json'
+            },
+            body: data
+          };
+        }
+        if ('rest' === request.serviceType && !(request.body instanceof FormData)) {
+          fetchConfig.headers['Content-Type'] = request.contentType ? request.contentType : 'application/json; charset=utf-8';
+        }
+        if (request.body instanceof FormData) {
+          delete fetchConfig.headers['Content-Type'];
+          fetchConfig.headers['Accept'] = request.accept ? request.accept : 'application/json';
+        }
+      }
+      if (request.contentType) {
+        fetchConfig.headers['Content-Type'] = request.contentType;
+      }
+      let url = request.url;
+      if (request.download) {
+        if (url.indexOf('?') < 0) {
+          url += '?';
+        } else {
+          url += '&';
+        }
+        url += 'access_token=' + accessToken;
+        url += '&idToken=' + idToken;
+        url += '&themePrimaryColor=' + encodeURIComponent(_ApplicationManager.default.getApplicationPrimaryColor());
+        url += '&themeSecondaryColor=' + encodeURIComponent(_ApplicationManager.default.getApplicationSecondaryColor());
+        window.open(encodeURI(url), '_blank');
+      } else {
+        if (_Utils.default.isNull(request.track) || request.track === true) {
+          (0, _reactPromiseTracker.trackPromise)(this.executeFetch(url, fetchConfig, request.viewId, request.successMessage).then(response => {
+            resolve(response);
+          }).catch(e => {
+            reject(e);
+          }));
+        } else {
+          this.executeFetch(url, fetchConfig, request.viewId, request.successMessage).then(response => {
+            resolve(response);
+          }).catch(e => {
+            reject(e);
+          });
+        }
+      }
+    });
+  }
+  executeFetch(url, fetchConfig, viewId, successMessage) {
+    return new Promise((resolve, reject) => {
+      fetch(encodeURI(url), fetchConfig).then(status).then(json).then(data => {
+        resolve(this.processSuccessfulResponseData(null, data, viewId, successMessage));
+      }).catch(e => {
+        console.error(e);
+        if (e.status === 401 && !url.endsWith('/logout')) {
+          _ApplicationManager.default.clear();
+          _ApplicationManager.default.navigate('/login');
+        }
+        reject(e);
+      });
+    });
+  }
+  processSuccessfulResponseData(component, data, viewId, successMessage) {
+    let response;
+    if (!_Utils.default.isNull(data) && data.toString().trim().length === 0) {
+      response = null;
+    } else if (typeof data === 'object' || _Utils.default.isNull(data) || data.toString().trim().length === 0) {
+      response = data;
+    } else {
+      try {
+        response = JSON.parse(data);
+      } catch (ignored) {
+        response = data;
+      }
+    }
+    if (response && response.dataType === 'message') {
+      let event = new _Event.default(_ApplicationManager.default, viewId, response);
+      _Observable.default.fireEvent(_EventType.default.MESSAGE_ARRIVED, event);
+      if (component !== null) {
+        event = new _Event.default(component, viewId, response);
+        _Observable.default.fireEvent(_EventType.default.MESSAGE_ARRIVED, event);
+      }
+    } else if (!_Utils.default.isNull(successMessage)) {
+      let message = {
+        messageType: 'SUCCESS',
+        message: _ApplicationManager.default.populateTemplate(successMessage, response)
+      };
+      let event = new _Event.default(_ApplicationManager.default, viewId, message);
+      _Observable.default.fireEvent(_EventType.default.MESSAGE_ARRIVED, event);
+      if (component !== null) {
+        event = new _Event.default(component, viewId, message);
+        _Observable.default.fireEvent(_EventType.default.MESSAGE_ARRIVED, event);
+      }
+    }
+    return response;
+  }
+}
+const instance = new RestService();
+const invokeRpc = request => {
+  return instance.invokeRpc(request);
+};
+exports.invokeRpc = invokeRpc;
+const invokeRest = request => {
+  return instance.invokeRest(request);
+};
+exports.invokeRest = invokeRest;

package/dist/RestUtils.js

@@ -34,6 +34,7 @@ class RestUtils {
     let event = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : null;
     let url = service.url.startsWith('http://') || service.url.startsWith('https://') ? service.url : location + `${_ApplicationManager.default.getContextRoot() + service.url}`;
     let requestBody = null;
+    let headers = service.headers;
     if (!_Utils.default.isNull(service.parameters)) {
       let queryString = '';
       let pathParameters = '';
@@ -71,6 +72,14 @@ class RestUtils {
             pathParameters += '/' + (typeof parameterValue.value === 'object' ? JSON.stringify(parameterValue.value) : parameterValue.instanceType === 'TypedValue' ? parameterValue.value : parameterValue);
           }
         }
+        if (httpParameterType === 'HEADER') {
+          if (!_Utils.default.isNull(parameterValue)) {
+            if (!headers) {
+              headers = {};
+            }
+            headers[parameter.name] = parameterValue;
+          }
+        }
         if (httpParameterType === 'REQUEST_BODY') {
           if (requestBodyParamFound) {
             console.error('Only one request body is permitted');
@@ -97,7 +106,6 @@ class RestUtils {
         url += queryString;
       }
     }
-    let headers = service.headers;
     let contentType = null;
     if (!_Utils.default.isNull(headers)) {
       contentType = headers['Content-Type'];
@@ -180,11 +188,13 @@ class RestUtils {
     }
     this.doFetch(location + _ApplicationManager.default.getContextRoot() + '/' + module + '/api/v1/rpc/invoke', response => {
       if (!_Utils.default.isNull(viewId) && !_Utils.default.isNull(component)) {
-        let path = _Utils.default.getPropertyChainPath(returnValueBinding);
-        if (!_Utils.default.isNull(path.valueObject) && !_Utils.default.isNull(path.property)) {
-          path.valueObject[path.property] = response;
+        if (returnValueBinding) {
+          let path = _Utils.default.getPropertyChainPath(returnValueBinding);
+          if (!_Utils.default.isNull(path.valueObject) && !_Utils.default.isNull(path.property)) {
+            path.valueObject[path.property] = response;
+          }
         }
-        this.fireEvent(viewId, component, _EventType.default.SERVICE_CALL_SUCCESS, response.data);
+        this.fireEvent(viewId, component, _EventType.default.SERVICE_CALL_SUCCESS, response);
         if (successCallback !== null) {
           successCallback(response);
         }
@@ -196,15 +206,16 @@ class RestUtils {
       if (!_Utils.default.isNull(viewId) && !_Utils.default.isNull(component)) {
         this.fireEvent(viewId, component, _EventType.default.SERVICE_CALL_FAILURE);
       }
-    }, true, 'POST', false, request, viewId, successMessage, true);
+    }, true, 'POST', false, request, viewId, successMessage, true, 'application/json');
   }
   doPostData(url, successCallback, errorCallback, secure, data, viewId, successMessage) {
     this.fetchWithCustomConfig(url, successCallback, errorCallback, secure, null, 'POST', false, data, 'rest');
   }
   doFetch(url, successCallback, errorCallback, secure, method, download, body, viewId, successMessage, track) {
-    this.fetchWithCustomConfig(url, successCallback, errorCallback, secure, null, method, download, body, null, viewId, successMessage, track);
+    let contentType = arguments.length > 10 && arguments[10] !== undefined ? arguments[10] : null;
+    this.fetchWithCustomConfig(url, successCallback, errorCallback, secure, null, method, download, body, null, viewId, successMessage, track, contentType);
   }
-  fetchWithCustomConfig(url, successCallback, errorCallback, secure, config, method, download, body, serviceType, viewId, successMessage, track) {
+  fetchWithCustomConfig(url, successCallback, errorCallback, secure, config, method, download, body, serviceType, viewId, successMessage, track, contentType) {
     const accessToken = sessionStorage.getItem('accessToken');
     const idToken = sessionStorage.getItem('idToken');
     let data = body ? body instanceof FormData ? body : JSON.stringify(body) : null;
@@ -238,6 +249,9 @@ class RestUtils {
         fetchConfig.headers['Accept'] = 'application/json';
       }
     }
+    if (contentType) {
+      fetchConfig.headers['Content-Type'] = contentType;
+    }
     if (download) {
       if (url.indexOf('?') < 0) {
         url += '?';

package/dist/Utils.js

@@ -345,5 +345,14 @@ class Utils {
     let component = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     Utils.publishErrorMessage('A system error has accured. Please try again later', viewId, component);
   };
+  static base64ToArrayBuffer = base64 => {
+    const binaryString = window.atob(base64);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes.buffer;
+  };
 }
 exports.default = Utils;

package/dist/components/AlertBar.js

@@ -43,6 +43,9 @@ const AlertBar = /*#__PURE__*/_react.default.memo( /*#__PURE__*/_react.default.f
       }
     }
     _Observable.default.addSubscriptions(eventHandlingConfig, props.handle, props.viewId);
+    return () => {
+      _Observable.default.clearComponentEventListeners(props.handle);
+    };
   }, []);
   const api = () => {
     return {