@kineticdata/react 5.0.16 → 5.1.0

package/lib/components/core/space/SpaceForm.js

@@ -1,6 +1,6 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import { get, Map } from 'immutable';
+import { fromJS, get, Map } from 'immutable';
 import t from 'prop-types';
 import { generateForm } from '../../form/Form';
 import { updateSpace, fetchSpace, fetchAttributeDefinitions, fetchLocales, fetchTimezones, fetchSecurityPolicyDefinitions } from '../../../apis';
@@ -12,7 +12,7 @@ var dataSources = function dataSources() {
     space: {
       fn: fetchSpace,
       params: [{
-        include: 'attributesMap,securityPolicies,details'
+        include: 'allowedIps,attributesMap,securityPolicies,details'
       }],
       transform: function transform(result) {
         return result.space;
@@ -113,6 +113,26 @@ var securityEndpoints = {
     endpoint: 'User Modification',
     label: 'User Modification',
     types: ['Space', 'User']
+  },
+  defaultFormDisplay: {
+    endpoint: 'Default Form Display',
+    label: 'Default Form Display',
+    types: ['Form']
+  },
+  defaultFormModification: {
+    endpoint: 'Default Form Modification',
+    label: 'Default Form Modification',
+    types: ['Form']
+  },
+  defaultSubmissionAccess: {
+    endpoint: 'Default Submission Access',
+    label: 'Default Submission Access',
+    types: ['Form', 'Submission']
+  },
+  defaultSubmissionModification: {
+    endpoint: 'Default Submission Modification',
+    label: 'Default Submission Modification',
+    types: ['Form', 'Submission']
   }
 };
 
@@ -146,20 +166,20 @@ var fields = function fields() {
         return get(values, 'sharedBundleBase') !== '' && get(values, 'displayType') === 'Display Page';
       }
     }, {
-      name: 'defaultDatastoreFormConfirmationPage',
-      label: 'Default Datastore Form Confirmation Page',
+      name: 'defaultFormConfirmationPage',
+      label: 'Default Form Confirmation Page',
       type: 'text',
-      initialValue: get(space, 'defaultDatastoreFormConfirmationPage'),
+      initialValue: get(space, 'defaultFormConfirmationPage'),
       placeholder: 'confirmation.jsp',
       visible: function visible(_ref6) {
         var values = _ref6.values;
         return get(values, 'displayType') !== 'Single Page App';
       }
     }, {
-      name: 'defaultDatastoreFormDisplayPage',
-      label: 'Default Datastore Form Display Page',
+      name: 'defaultFormDisplayPage',
+      label: 'Default Form Display Page',
       type: 'text',
-      initialValue: get(space, 'defaultDatastoreFormDisplayPage'),
+      initialValue: get(space, 'defaultFormDisplayPage'),
       placeholder: 'form.jsp',
       visible: function visible(_ref7) {
         var values = _ref7.values;
@@ -426,13 +446,42 @@ var fields = function fields() {
         });
       },
       initialValue: get(space, 'securityPolicies')
+    }, {
+      name: 'allowedIps',
+      label: 'Allowed IPs',
+      type: 'select',
+      options: function options() {
+        return fromJS([{
+          name: 'description',
+          label: 'Description',
+          type: 'text'
+        }, {
+          name: 'value',
+          label: 'IP Range',
+          type: 'text'
+        }]);
+      },
+      visible: function visible(_ref34) {
+        var values = _ref34.values;
+        return values.get('allowedIpsEnabled', false);
+      },
+      initialValue: get(space, 'allowedIps', []),
+      serialize: function serialize(_ref35) {
+        var values = _ref35.values;
+        return values.get('allowedIpsEnabled', false) ? values.get('allowedIps') : [];
+      }
+    }, {
+      name: 'allowedIpsEnabled',
+      label: 'Enabled Allowed IP Restrictions?',
+      type: 'checkbox',
+      initialValue: get(space, 'allowedIpsEnabled', false) || false
     }, {
       name: 'attributesMap',
       label: 'Attributes',
       type: 'attributes',
       required: false,
-      options: function options(_ref34) {
-        var attributeDefinitions = _ref34.attributeDefinitions;
+      options: function options(_ref36) {
+        var attributeDefinitions = _ref36.attributeDefinitions;
         return attributeDefinitions;
       },
       initialValue: get(space, 'attributesMap')

package/lib/components/core/submission/DatastoreSubmissionTable.js

@@ -1,5 +1,10 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import React, { Component } from 'react';
 import { generateTable } from '../../table/Table';
 import { searchSubmissions } from '../../../apis';
 import { generatePaginationParams } from '../../../apis/http';
@@ -103,12 +108,37 @@ var columns = [{
   title: 'Updated By',
   sortable: false
 }];
-export var DatastoreSubmissionTable = generateTable({
+var DatastoreSubmissionTableComponent = generateTable({
   tableOptions: ['formSlug', 'include'],
   columns: columns,
   dataSource: dataSource,
   filters: filters,
   filterDataSources: filterDataSources
 });
+export var DatastoreSubmissionTable = /*#__PURE__*/function (_Component) {
+  _inherits(DatastoreSubmissionTable, _Component);
+
+  var _super = _createSuper(DatastoreSubmissionTable);
+
+  function DatastoreSubmissionTable() {
+    _classCallCheck(this, DatastoreSubmissionTable);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(DatastoreSubmissionTable, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      console.warn('Datastore Submissions are deprecated in Core 5.1, please upgrade to "form" mode.');
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(DatastoreSubmissionTableComponent, this.props, this.props.children);
+    }
+  }]);
+
+  return DatastoreSubmissionTable;
+}(Component);
 DatastoreSubmissionTable.displayName = 'DatastoreSubmissionTable';
 export default DatastoreSubmissionTable;

package/lib/components/core/submission/FormSubmissionFilters.js

@@ -0,0 +1,378 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { List, Map, Range } from 'immutable';
+import moment from 'moment';
+import { fetchForm, fetchKapp, fetchSpace } from '../../../apis';
+import { defineKqlQuery, MAX_PART_LENGTH, TIMELINES } from '../../../helpers';
+import { availableParts, getUsedFields } from './helpers';
+export var filterDataSources = function filterDataSources(_ref) {
+  var formSlug = _ref.formSlug,
+      kappSlug = _ref.kappSlug;
+  return {
+    form: {
+      fn: !formSlug && !kappSlug ? fetchSpace : kappSlug && !formSlug ? fetchKapp : fetchForm,
+      params: [{
+        kappSlug: kappSlug,
+        formSlug: formSlug,
+        include: 'indexDefinitions,fields,fields.details'
+      }],
+      transform: function transform(result) {
+        return !formSlug && !kappSlug ? result.space : kappSlug && !formSlug ? result.kapp : result.form;
+      }
+    },
+    fields: {
+      fn: function fn(form) {
+        return form.get('fields').filter(function (f) {
+          return f.get('dataType') !== 'file';
+        }).map(function (f) {
+          return "values[".concat(f.get('name'), "]");
+        });
+      },
+      params: function params(_ref2) {
+        var form = _ref2.form;
+        return form && [form];
+      }
+    },
+    indexDefinitions: {
+      fn: function fn(form) {
+        return form.get('indexDefinitions');
+      },
+      params: function params(_ref3) {
+        var form = _ref3.form;
+        return form && [form];
+      }
+    }
+  };
+};
+
+var getPartIndex = function getPartIndex(name) {
+  var match = name.match(/op(\d+)-part/);
+  return match && parseInt(match[1]);
+};
+
+var getOrderPartIndex = function getOrderPartIndex(name) {
+  var match = name.match(/orderby(\d+)-part/);
+  return match && parseInt(match[1]);
+};
+
+var operatorChangeFn = function operatorChangeFn(i) {
+  return function (_ref4, _ref5) {
+    var values = _ref4.values;
+    var setValue = _ref5.setValue;
+    var value = values.get("op".concat(i, "-operator")); // If the operator was set to '' and the first operand is set, clear it.
+
+    if (!value && values.get("op".concat(i, "-operand1"))) {
+      setValue("op".concat(i, "-operand1"), '');
+    } // If the operator is not 'bt' and the second operand is set, clear it.
+
+
+    if (value !== 'between' && values.get("op".concat(i, "-operand2"))) {
+      setValue("op".concat(i, "-operand2"), '');
+    } // If the operator is not 'in and the third operand is set, clear it.
+
+
+    if (value !== 'in' && !values.get("op".concat(i, "-operand3")).isEmpty()) {
+      setValue("op".concat(i, "-operand3"), List());
+    }
+  };
+};
+
+var partChangeFn = function partChangeFn(i) {
+  return function (_ref6, _ref7) {
+    var values = _ref6.values;
+    var setValue = _ref7.setValue;
+    // If the operator was set to something besides 'eq' or 'in' clear any
+    // operators after this. Their change events will then fire and clear the
+    // corresponding operands.
+    values.filter(function (value, name) {
+      return getPartIndex(name) > i;
+    }).forEach(function (_value, name) {
+      return setValue(name, '', false);
+    });
+    setValue('range-part', '', false);
+    Range(0, MAX_PART_LENGTH).forEach(function (i) {
+      return setValue("orderby".concat(i, "-part"), '', false);
+    });
+  };
+};
+
+var orderChangeFn = function orderChangeFn(i) {
+  return function (_ref8, _ref9) {
+    var values = _ref8.values;
+    var setValue = _ref9.setValue;
+    var value = values.get("orderby".concat(i, "-part"));
+
+    if (!value || TIMELINES.includes(value)) {
+      values.filter(function (value, name) {
+        return getOrderPartIndex(name) > i;
+      }).forEach(function (_value, name) {
+        return setValue(name, '', false);
+      });
+    }
+  };
+};
+
+var enabledFn = function enabledFn(i) {
+  return function (_ref10) {
+    var values = _ref10.values;
+    return Range(0, i, -1).map(function (i) {
+      return values.get("op".concat(i, "-part"));
+    }).every(function (value) {
+      return value;
+    });
+  };
+};
+
+var rangeVisibleFn = function rangeVisibleFn(operatorType) {
+  var timeline = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  return function (_ref11) {
+    var values = _ref11.values,
+        indexDefinitions = _ref11.indexDefinitions;
+    var usedFields = getUsedFields(values, -1, 'range');
+    var partsAvailable = availableParts(values, indexDefinitions, usedFields, 'range');
+    var isOperandValid = operatorType ? !timeline ? operatorType === 'between' ? !TIMELINES.includes(values.get('range-part')) && values.get('range-operator') === 'between' : !TIMELINES.includes(values.get('range-part')) : operatorType === 'between' ? TIMELINES.includes(values.get('range-part')) && values.get('range-operator') === 'between' : TIMELINES.includes(values.get('range-part')) : true;
+    return isOperandValid && partsAvailable.size > 0;
+  };
+};
+
+var visibleFn = function visibleFn(currentPart, i, operatorType) {
+  return function (_ref12) {
+    var values = _ref12.values,
+        indexDefinitions = _ref12.indexDefinitions;
+    var hasRange = values.get('range-part') !== '';
+    var hasOrderBy = Range(0, MAX_PART_LENGTH).map(function (i) {
+      return values.get("orderby".concat(i, "-part"));
+    }).filter(function (v) {
+      return v !== '';
+    }).toList().size > 0;
+    var usedFields = getUsedFields(values, i, 'eq');
+    var partsAvailable = availableParts(values, indexDefinitions, usedFields, 'eq'); // If this equality has this operator type selected.
+
+    if (operatorType) return values.get("op".concat(i, "-operator")) === operatorType; // If there's a range value set and this equality is not.
+
+    if ((hasRange || hasOrderBy) && !values.get("op".concat(i, "-part"))) return false; // If it is the first equality or the previous equality has a value set and
+    // this equality has available options.
+
+    return (i === 0 || values.get("op".concat(i - 1, "-part"))) && partsAvailable.size > 0;
+  };
+};
+
+var orderVisibleFn = function orderVisibleFn(partIndex) {
+  return function (bindings) {
+    var values = bindings.values;
+    var prevPart = values.get("orderby".concat(partIndex - 1, "-part"));
+    return partIndex === 0 || !values.get('range-part') && prevPart && !TIMELINES.includes(prevPart);
+  };
+};
+
+export var availableOptions = function availableOptions(partType, partIndex) {
+  return function (bindings) {
+    var values = bindings.values,
+        indexDefinitions = bindings.indexDefinitions;
+    var usedFields = getUsedFields(values, partIndex, partType);
+    var partsAvailable = availableParts(values, indexDefinitions, usedFields, partType).flatten();
+    var valueParts = partsAvailable.filter(function (f) {
+      return f.startsWith('values[');
+    }).sort();
+    var staticParts = partsAvailable.filterNot(function (f) {
+      return f.startsWith('values[');
+    }).sort();
+    return valueParts.concat(staticParts).map(function (f) {
+      return Map({
+        label: f,
+        value: f
+      });
+    });
+  };
+};
+
+var getRValues = function getRValues(operator, values, opBase) {
+  var isTimeline = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var v1 = isTimeline ? values.get("".concat(opBase, "-operand3")) : values.get("".concat(opBase, "-operand1"));
+  var v2 = isTimeline ? values.get("".concat(opBase, "-operand4")) : values.get("".concat(opBase, "-operand2"));
+  return operator === 'between' ? [v1, v2] : operator === 'in' ? [values.get("".concat(opBase, "-operand3"))] : [v1];
+};
+
+var getSerializedParts = function getSerializedParts(values) {
+  return Range(0, MAX_PART_LENGTH).filter(function (i) {
+    return values.get("op".concat(i, "-part"));
+  }).map(function (i) {
+    // Handle the equality parts.
+    var part = values.get("op".concat(i, "-part"));
+    var operator = values.get("op".concat(i, "-operator"));
+    var rValues = getRValues(operator, values, "op".concat(i));
+    return List([part, operator, "op".concat(i)].concat(_toConsumableArray(rValues)));
+  }).toList().update(function (ps) {
+    var rangePart = values.get('range-part');
+    var rangeOp = values.get('range-operator');
+    var rangeValues = getRValues(rangeOp, values, 'range', TIMELINES.includes(rangePart));
+    return rangePart ? ps.push(List([rangePart, rangeOp, 'range'].concat(_toConsumableArray(rangeValues)))) : ps;
+  });
+};
+
+var serializeQuery = function serializeQuery(_ref13) {
+  var values = _ref13.values;
+  var parts = getSerializedParts(values);
+  return {
+    parts: parts,
+    q: parts.reduce(function (query, partEntry) {
+      var _partEntry = _slicedToArray(partEntry, 3),
+          part = _partEntry[0],
+          operator = _partEntry[1],
+          opBase = _partEntry[2];
+
+      var op1 = opBase === 'range' && TIMELINES.includes(part) ? "".concat(opBase, "-operand3") : "".concat(opBase, "-operand1");
+      var op2 = opBase === 'range' && TIMELINES.includes(part) ? "".concat(opBase, "-operand4") : "".concat(opBase, "-operand2");
+      var op3 = "".concat(opBase, "-operand3");
+      return operator === 'between' ? query.between(part, op1, op2, true) : operator === 'in' ? query["in"](part, op3, true) : operator ? query[operator](part, op1, true) : query;
+    }, defineKqlQuery()).end()(values.map(function (v, k) {
+      return ['range-operand3', 'range-operand4'].includes(k) && v ? moment(v).toISOString() : v;
+    }).toJS()),
+    orderBy: Range(0, MAX_PART_LENGTH).map(function (i) {
+      return values.get("orderby".concat(i, "-part"));
+    }).filter(function (v) {
+      return v;
+    }).toArray().join(',')
+  };
+};
+
+export var filters = function filters() {
+  return function (_ref14) {
+    var form = _ref14.form,
+        indexDefinitions = _ref14.indexDefinitions;
+    return form && indexDefinitions && [].concat(_toConsumableArray(Range(0, MAX_PART_LENGTH).flatMap(function (i) {
+      return [{
+        enabled: enabledFn(i),
+        name: "op".concat(i, "-part"),
+        type: 'select',
+        visible: visibleFn("op".concat(i, "-part"), i),
+        onChange: partChangeFn(i),
+        options: availableOptions('eq', i),
+        "transient": true
+      }, {
+        enabled: enabledFn(i),
+        name: "op".concat(i, "-operator"),
+        type: 'select',
+        visible: visibleFn("op".concat(i, "-part"), i),
+        onChange: operatorChangeFn(i),
+        options: [{
+          label: '=',
+          value: 'equals'
+        }, {
+          label: 'in',
+          value: 'in'
+        }],
+        initialValue: 'equals',
+        "transient": true
+      }, {
+        enabled: enabledFn(i),
+        name: "op".concat(i, "-operand1"),
+        "transient": true,
+        type: 'text',
+        visible: visibleFn("op".concat(i, "-part"), i)
+      }, {
+        enabled: enabledFn(i),
+        name: "op".concat(i, "-operand2"),
+        "transient": true,
+        type: 'text',
+        visible: visibleFn("op".concat(i, "-part"), i, 'between')
+      }, {
+        enabled: enabledFn(i),
+        name: "op".concat(i, "-operand3"),
+        "transient": true,
+        type: 'text-multi',
+        visible: visibleFn("op".concat(i, "-part"), i, 'in')
+      }];
+    }).toArray()), [{
+      name: 'range-part',
+      type: 'select',
+      visible: rangeVisibleFn(),
+      options: availableOptions('range'),
+      onChange: function onChange(_ref15, _ref16) {
+        var values = _ref15.values;
+        var setValue = _ref16.setValue;
+        // Recalculate order by.
+        var value = values.get('range-part'); // Clear out all of the order by values, range supersedes.
+
+        setValue('orderby0-part', value);
+        Range(1, MAX_PART_LENGTH).forEach(function (i) {
+          return setValue("orderby".concat(i, "-part"), '');
+        });
+      },
+      "transient": true
+    }, {
+      name: 'range-operator',
+      type: 'select',
+      visible: rangeVisibleFn(),
+      options: [{
+        label: '>',
+        value: 'greaterThan'
+      }, {
+        label: '>=',
+        value: 'greaterThanOrEquals'
+      }, {
+        label: '<',
+        value: 'lessThan'
+      }, {
+        label: '<=',
+        value: 'lessThanOrEquals'
+      }, {
+        label: 'between',
+        value: 'between'
+      }, {
+        label: 'startsWith',
+        value: 'startsWith'
+      }],
+      "transient": true
+    }, {
+      name: 'range-operand1',
+      "transient": true,
+      type: 'text',
+      visible: rangeVisibleFn('eq', false)
+    }, {
+      name: 'range-operand2',
+      "transient": true,
+      type: 'text',
+      visible: rangeVisibleFn('between', false)
+    }, {
+      name: 'range-operand3',
+      "transient": true,
+      type: 'datetime',
+      visible: rangeVisibleFn('eq', true)
+    }, {
+      name: 'range-operand4',
+      "transient": true,
+      type: 'datetime',
+      visible: rangeVisibleFn('between', true)
+    }, {
+      name: 'orderDirection',
+      type: 'select',
+      options: [{
+        label: 'ASC',
+        value: 'ASC'
+      }, {
+        label: 'DESC',
+        value: 'DESC'
+      }],
+      initialValue: 'DESC',
+      required: true
+    }], _toConsumableArray(Range(0, MAX_PART_LENGTH).flatMap(function (i) {
+      return [{
+        name: "orderby".concat(i, "-part"),
+        "transient": true,
+        type: 'select',
+        onChange: orderChangeFn(i),
+        enabled: function enabled(_ref17) {
+          var values = _ref17.values;
+          return !values.get('range-part');
+        },
+        options: availableOptions('orderBy', i),
+        visible: orderVisibleFn(i)
+      }];
+    }).toArray()), [{
+      name: 'query',
+      type: null,
+      serialize: serializeQuery
+    }]);
+  };
+};

package/lib/components/core/submission/FormSubmissionTable.js

@@ -0,0 +1,116 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { generateTable } from '../../table/Table';
+import { searchSubmissions } from '../../../apis';
+import { generatePaginationParams, transformCoreResult } from '../../../apis/http';
+import { filterDataSources, filters } from './FormSubmissionFilters';
+import { Set } from 'immutable';
+
+var dataSource = function dataSource(_ref) {
+  var kappSlug = _ref.kappSlug,
+      formSlug = _ref.formSlug,
+      include = _ref.include,
+      count = _ref.count;
+  return {
+    fn: function fn(options) {
+      return searchSubmissions(options);
+    },
+    params: function params(paramData) {
+      var q = paramData.filters.getIn(['query', 'q']) || undefined;
+      var orderBy = paramData.filters.getIn(['query', 'orderBy']) || 'createdAt';
+      return [{
+        form: formSlug,
+        kapp: kappSlug,
+        search: _objectSpread({
+          direction: paramData.filters.get('orderDirection', 'DESC'),
+          include: Set([].concat(_toConsumableArray(typeof include === 'string' ? include.split(',') : Array.isArray(include) ? include : []), ['details'])).toJS(),
+          // need to pass undefined instead of null so the `q` parameter is not
+          // added to the query string with empty value
+          q: q,
+          orderBy: orderBy
+        }, generatePaginationParams(paramData)),
+        count: count ? true : undefined
+      }];
+    },
+    transform: transformCoreResult('submissions')
+  };
+};
+
+var columns = [{
+  value: 'closedAt',
+  title: 'Closed At',
+  sortable: true
+}, {
+  value: 'closedBy',
+  title: 'closedBy',
+  sortable: false
+}, {
+  value: 'coreState',
+  title: 'Core State',
+  sortable: false
+}, {
+  value: 'createdAt',
+  title: 'Created',
+  sortable: true
+}, {
+  value: 'createdBy',
+  title: 'Created By',
+  sortable: false
+}, {
+  value: 'currentPage',
+  title: 'Current Page',
+  sortable: false
+}, {
+  value: 'handle',
+  title: 'Handle',
+  sortable: false
+}, {
+  value: 'id',
+  title: 'Id',
+  sortable: false
+}, {
+  value: 'label',
+  title: 'Label',
+  sortable: false
+}, {
+  value: 'origin',
+  title: 'Origin',
+  sortable: false
+}, {
+  value: 'parent',
+  title: 'Parent',
+  sortable: false
+}, {
+  value: 'sessionToken',
+  title: 'Session Token',
+  sortable: false
+}, {
+  value: 'submittedAt',
+  title: 'Submitted At',
+  sortable: true
+}, {
+  value: 'submittedBy',
+  title: 'Submitted By',
+  sortable: false
+}, {
+  value: 'type',
+  title: 'Type',
+  sortable: false
+}, {
+  value: 'updatedAt',
+  title: 'Updated',
+  sortable: false
+}, {
+  value: 'updatedBy',
+  title: 'Updated By',
+  sortable: false
+}];
+export var FormSubmissionTable = generateTable({
+  tableOptions: ['kappSlug', 'formSlug', 'include', 'count'],
+  columns: columns,
+  dataSource: dataSource,
+  filters: filters,
+  filterDataSources: filterDataSources
+});
+FormSubmissionTable.displayName = 'FormSubmissionTable';
+export default FormSubmissionTable;