@agilemotion/oui-react-js 1.2.7 → 1.2.8

package/dist/Utils.js

@@ -0,0 +1,369 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _DynamicJS = _interopRequireDefault(require("./DynamicJS"));
+
+var _Event = _interopRequireDefault(require("./event/Event"));
+
+var _ApplicationContext = _interopRequireDefault(require("./ApplicationContext"));
+
+var _Observable = _interopRequireDefault(require("./event/Observable"));
+
+var _EventType = _interopRequireDefault(require("./event/EventType"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class Utils {
+  constructor() {
+    _defineProperty(this, "SYSTEM_ERROR_MESSAGE", "A system error has accured. Please contact your system administrator");
+
+    _defineProperty(this, "showMessage", (viewRef, message, type) => {
+      if (Utils.isNull(message)) {
+        message = "";
+      }
+
+      let messageType = type === "ERROR" ? "danger" : Utils.isNull(type) ? "message" : type;
+      viewRef.setState({
+        message: message,
+        messageStyle: messageType
+      });
+    });
+  }
+
+  static isNull(value) {
+    return value === null || typeof value === 'undefined';
+  }
+
+  static joinScript(lines) {
+    let script = '';
+
+    for (let i = 0; i < lines.length; i++) {
+      let line = lines[i].trim();
+
+      if (!line.endsWith(';') && !line.endsWith(':')) {
+        line += ';';
+      }
+
+      line += '\n';
+      script += line;
+    }
+
+    return script;
+  }
+
+  static sleep(milliseconds) {
+    const date = Date.now();
+    let currentDate = null;
+
+    do {
+      currentDate = Date.now();
+    } while (currentDate - date < milliseconds);
+  }
+
+  static parseConfig(config, currentViewId, index = null) {
+    if (!this.isNull(config) && !this.isNull(config.id)) {
+      let configJson = JSON.stringify(config);
+      let replace = configJson.replace(/#{this}/g, '#{' + config.id + '}').replace(/#{view}/g, '#{' + currentViewId + '}');
+
+      if (index !== null) {
+        replace = replace.replace(/\[#i]/g, "[".concat(index, "]"));
+      }
+
+      return JSON.parse(replace);
+    }
+
+    return config;
+  }
+
+  static isFieldRequired(id, formId) {
+    if (!Utils.isStringEmpty(formId)) {
+      let fields = Utils.getFields(formId, 'validate');
+
+      for (var i = 0; i < fields.length; i++) {
+        if (fields[i].id === id) {
+          return fields[i].required;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  static isStringEmpty(val) {
+    return typeof val === 'undefined' || val === null || val.trim().length === 0;
+  }
+
+  static getFields(formId, className) {
+    let inputFields = [];
+    let form = document.getElementById(formId);
+
+    if (!Utils.isNull(form)) {
+      let inputDivs = form.getElementsByClassName(className);
+
+      for (let i = 0; i < inputDivs.length; i++) {
+        let inputs = inputDivs[i].getElementsByTagName("input");
+
+        for (let j = 0; j < inputs.length; j++) {
+          inputFields.push(inputs[j]);
+        }
+      }
+    }
+
+    return inputFields;
+  }
+
+  static validateField(id, required, values, currentValue, validator) {
+    let message = !this.isNull(validator) ? validator.errorMessage : null;
+    let regex = !this.isNull(validator) ? validator.regex : null;
+    let result = {};
+    result.valid = true;
+    result.message = "";
+    let value;
+
+    if (currentValue !== null) {
+      value = currentValue;
+    } else {
+      value = values[id];
+    }
+
+    let hasErrors = false;
+
+    if (required && (Utils.isNull(value) || Utils.isStringEmpty(value.toString()))) {
+      result.message = !Utils.isNull(message) ? message : "This field is required";
+      hasErrors = true;
+    } else {
+      result.message = "";
+    }
+
+    if (!hasErrors && !Utils.isNull(regex) && !Utils.isNull(value)) {
+      hasErrors = Utils.isNull(value.toString().match(regex));
+
+      if (hasErrors) {
+        result.message = !Utils.isNull(message) ? message : "This field is invalid";
+      }
+    }
+
+    result.valid = !hasErrors;
+    return result;
+  }
+
+  static getComponentAttribute(field, attribute, defaultValue) {
+    if (this.isNull(field.attributes)) {
+      return defaultValue;
+    }
+
+    return this.isNull(field.attributes[attribute]) ? defaultValue : field.attributes[attribute];
+  }
+
+  static doGetRequestJson(currentPage, curretRowsPerPage, currentSearchParameters, paged) {
+    var request = {};
+    request.pageSize = curretRowsPerPage;
+    request.currentPage = currentPage;
+    request.searchParameters = currentSearchParameters;
+    request.paged = typeof paged === 'undefined' || paged === null || paged;
+    return JSON.stringify(request);
+  }
+
+  static getFieldGrid(attributes, fields) {
+    let fieldGrid = {};
+    let maxColspan = !Utils.isNull(attributes) ? attributes.layoutColumns : 1;
+    fieldGrid.maxColPerRow = maxColspan;
+    fieldGrid.rows = [];
+    let currRow = this.createRow();
+
+    for (let i = 0; i < fields.length; i++) {
+      let field = fields[i];
+      let colspan = this.getFieldColspan(field);
+
+      if (!this.rowHasSpaceForNewField(currRow, colspan, maxColspan)) {
+        this.fillRowWithSpacers(currRow, maxColspan);
+        currRow = this.createRow();
+      }
+
+      if (currRow.fields.length === 0) {
+        fieldGrid.rows.push(currRow);
+      }
+
+      currRow.fields.push(field);
+      currRow.usedSlots += colspan;
+    }
+
+    return fieldGrid;
+  }
+
+  static evaluateBooleanExpression(expression, id, defaultValue) {
+    if (expression === "false") {
+      return false;
+    } else if (expression === "true") {
+      return true;
+    } else if (!Utils.isNull(expression)) {
+      return _DynamicJS.default.executeScript("".concat(id, "UtilsBoolEval"), expression);
+    }
+
+    return !this.isNull(defaultValue) ? defaultValue : false;
+  }
+
+  static getEntityViewTitle(queryParameterState, viewName, ...fields) {
+    if (Utils.isNull(queryParameterState) || Utils.isNull(queryParameterState.selection)) {
+      return !Utils.isNull(viewName) ? viewName + " > Add" : "Add";
+    }
+
+    let props = "";
+
+    for (let i = 0; i < fields.length; i++) {
+      if (!Utils.isNull(fields[i])) {
+        props += fields[i].trim();
+        props += " ";
+      }
+    }
+
+    props = props.trim();
+    let prefix = Utils.isNull(viewName) ? "" : " > ";
+    return (Utils.isNull(viewName) ? "" : viewName) + (props.length > 0 ? prefix + props : "");
+  }
+
+  static setLegendColor(color) {
+    let legends = document.getElementsByClassName("legend");
+
+    for (let i = 0; i < legends.length; i++) {
+      legends[i].style.color = color;
+    }
+  }
+
+  static setLegend(text) {
+    if (!Utils.isNull(text)) {
+      let legend = document.getElementById("globalLegend");
+      legend.innerHTML = text;
+    }
+  }
+
+  saveForm(viewRef, formRef, url) {
+    this.saveForm(viewRef, formRef, url, null, null, null);
+  }
+
+  saveForm(viewRef, formRef, url, successCallback, errorCallback) {
+    this.saveForm(viewRef, formRef, url, successCallback, errorCallback, null);
+  }
+
+  static offsetDate(date, yearOffset, monthOffset, dayOffset) {
+    let year = date.getFullYear() + yearOffset;
+    let day = date.getDate() + dayOffset;
+    let month = date.getMonth() + monthOffset;
+    return new Date(year, month, day);
+  }
+
+  autoSetDate(viewRef, formRef, newDate, yearOffset, monthOffset, dayOffset, autoFillDateName, refDateName) {
+    let stateDate = viewRef.state[refDateName];
+    let tempDate = stateDate;
+
+    if (Utils.isNull(stateDate) || stateDate.getTime() !== newDate.getTime()) {
+      viewRef.setState(_objectSpread(_objectSpread({}, viewRef.state), {}, {
+        [refDateName]: newDate
+      }), () => {
+        if (!Utils.isNull(tempDate) && !Utils.isNull(viewRef.state.id)) {
+          let autoFillDate = Utils.offsetDate(newDate, yearOffset, monthOffset, dayOffset);
+          formRef.current.setValue(autoFillDateName, autoFillDate);
+        } else if (Utils.isNull(viewRef.state.id)) {
+          let autoFillDate = Utils.offsetDate(newDate, yearOffset, monthOffset, dayOffset);
+          formRef.current.setValue(autoFillDateName, autoFillDate);
+        }
+      });
+    }
+  }
+
+  static getArgs(func) {
+    // First match everything inside the function argument parens.
+    var args = func.toString().match(/function\s.*?\(([^)]*)\)/)[1]; // Split the arguments string into an array comma delimited.
+
+    return args.split(',').map(function (arg) {
+      // Ensure no inline comments are parsed and trim the whitespace.
+      return arg.replace(/\/\*.*\*\//, '').trim();
+    }).filter(function (arg) {
+      // Ensure no undefined values are added.
+      return arg;
+    });
+  }
+
+}
+
+exports.default = Utils;
+
+_defineProperty(Utils, "capitalize", s => {
+  if (typeof s !== 'string') return '';
+  return s.charAt(0).toUpperCase() + s.slice(1);
+});
+
+_defineProperty(Utils, "getFieldColspan", field => {
+  return !Utils.isNull(field.attributes) && !Utils.isNull(field.attributes['colspan']) ? parseFloat(field.attributes['colspan']) : 1;
+});
+
+_defineProperty(Utils, "createRow", () => {
+  let row = {};
+  row.fields = [];
+  row.usedSlots = 0;
+  return row;
+});
+
+_defineProperty(Utils, "fillRowWithSpacers", (row, max) => {
+  for (let i = row.usedSlots; i < max; i++) {
+    let field = {};
+    field.fieldType = 'LABEL';
+    field.id = 'system_col_span_spacer_' + i;
+    row.fields.push(field);
+  }
+});
+
+_defineProperty(Utils, "rowHasSpaceForNewField", (row, colspan, max) => {
+  return colspan <= max - row.usedSlots;
+});
+
+_defineProperty(Utils, "getPropertyChainPath", expression => {
+  let path = {};
+
+  if (!Utils.isNull(expression)) {
+    let tokens = expression.split('.');
+    path.property = tokens[tokens.length - 1];
+    let voExpression = expression.substring(0, expression.indexOf('.'));
+    path.valueObject = _DynamicJS.default.executeScript("".concat(Math.random(), "_PropertyChainUtilsEval"), voExpression);
+
+    for (let i = 1; i < tokens.length - 1; i++) {
+      let token = tokens[i];
+
+      if (!Utils.isNull(path.valueObject)) {
+        let getter = path.valueObject[token];
+
+        if (!Utils.isNull(getter)) {
+          if (typeof getter === 'function') {
+            path.valueObject = getter();
+          } else {
+            path.valueObject = getter;
+          }
+        }
+      } else {
+        break;
+      }
+    }
+  }
+
+  return path;
+});
+
+_defineProperty(Utils, "publishSystemErrorMessage", viewId => {
+  let message = {
+    messageType: 'ERROR',
+    message: 'A system error has accured. Please try again later'
+  };
+  let event = new _Event.default(_ApplicationContext.default, viewId, message);
+
+  _Observable.default.fireEvent(_EventType.default.MESSAGE_ARRIVED, event);
+});