@kineticdata/react 5.0.15 → 5.0.18

package/lib/components/core/file_resource/FileResourceForm.js

@@ -0,0 +1,180 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { get, Map } from 'immutable';
+import { createFileResource, fetchAgentComponents, fetchFileResource, fetchFilestores, fetchSecurityPolicyDefinitions, updateFileResource } from '../../../apis';
+import { generateForm } from '../../form/Form';
+import { handleFormErrors } from '../../form/Form.helpers';
+
+var dataSources = function dataSources(_ref) {
+  var fileResourceSlug = _ref.fileResourceSlug;
+  return {
+    fileResource: {
+      fn: fetchFileResource,
+      params: fileResourceSlug && [{
+        fileResourceSlug: fileResourceSlug,
+        include: 'details,securityPolicies'
+      }],
+      transform: function transform(result) {
+        return result.fileResource;
+      }
+    },
+    agents: {
+      fn: fetchAgentComponents,
+      params: [],
+      transform: function transform(result) {
+        return [{
+          label: 'System',
+          value: 'system'
+        }].concat(_toConsumableArray(get(result, 'agents', []).map(function (agent) {
+          return {
+            label: agent.name,
+            value: agent.slug
+          };
+        })));
+      }
+    },
+    filestores: {
+      fn: function fn(options) {
+        return options && options.agentSlug ? fetchFilestores(options) : Promise.resolve([]);
+      },
+      params: function params(_ref2) {
+        var values = _ref2.values;
+        return [{
+          agentSlug: get(values, 'agentSlug', 'system')
+        }];
+      },
+      transform: function transform(result) {
+        return get(result, 'filestores', []).map(function (agent) {
+          return {
+            label: agent.name,
+            value: agent.slug
+          };
+        });
+      }
+    },
+    securityPolicyDefinitions: {
+      fn: fetchSecurityPolicyDefinitions,
+      params: [],
+      transform: function transform(result) {
+        return result.securityPolicyDefinitions;
+      }
+    }
+  };
+};
+
+var handleSubmit = function handleSubmit(_ref3) {
+  var fileResourceSlug = _ref3.fileResourceSlug;
+  return function (values) {
+    return (fileResourceSlug ? updateFileResource : createFileResource)({
+      fileResourceSlug: fileResourceSlug,
+      fileResource: values.toJS()
+    }).then(handleFormErrors('fileResource', 'There was a problem saving the File Resource.'));
+  };
+};
+
+var securityEndpoints = {
+  fileAccess: {
+    endpoint: 'File Access',
+    label: 'File Access',
+    types: ['Space', 'File Resource']
+  },
+  fileModification: {
+    endpoint: 'File Modification',
+    label: 'File Modification',
+    types: ['Space', 'File Resource']
+  }
+};
+
+var fields = function fields(_ref4) {
+  var fileResourceSlug = _ref4.fileResourceSlug;
+  return function (_ref5) {
+    var fileResource = _ref5.fileResource,
+        agents = _ref5.agents,
+        securityPolicyDefinitions = _ref5.securityPolicyDefinitions;
+    return (!fileResourceSlug || fileResource) && securityPolicyDefinitions && agents && [{
+      name: 'slug',
+      label: 'Slug',
+      type: 'text',
+      required: true,
+      initialValue: get(fileResource, 'slug', '')
+    }, {
+      name: 'agentSlug',
+      label: 'Agent Slug',
+      type: 'select',
+      required: true,
+      initialValue: get(fileResource, 'agentSlug', 'system'),
+      options: function options(_ref6) {
+        var agents = _ref6.agents;
+        return agents;
+      },
+      onChange: function onChange(_, _ref7) {
+        var setValue = _ref7.setValue;
+        return setValue('filestoreSlug', '');
+      }
+    }, {
+      name: 'filestoreSlug',
+      label: 'Filestore Slug',
+      type: 'select',
+      required: true,
+      initialValue: get(fileResource, 'filestoreSlug', ''),
+      options: function options(_ref8) {
+        var filestores = _ref8.filestores;
+        return filestores;
+      }
+    }].concat(_toConsumableArray(Object.entries(securityEndpoints).map(function (_ref9) {
+      var _ref10 = _slicedToArray(_ref9, 2),
+          endpointFieldName = _ref10[0],
+          endpoint = _ref10[1];
+
+      return {
+        name: endpointFieldName,
+        label: endpoint.label,
+        type: 'select',
+        options: function options(_ref11) {
+          var securityPolicyDefinitions = _ref11.securityPolicyDefinitions;
+          return securityPolicyDefinitions ? securityPolicyDefinitions.filter(function (definition) {
+            return endpoint.types.includes(definition.get('type'));
+          }).map(function (definition) {
+            return Map({
+              value: definition.get('name'),
+              label: definition.get('name')
+            });
+          }) : [];
+        },
+        initialValue: fileResource ? fileResource.get('securityPolicies').find(function (pol) {
+          return pol.get('endpoint') === endpoint.endpoint;
+        }, null, Map({})).get('name', '') : '',
+        "transient": true
+      };
+    })), [{
+      name: 'securityPolicies',
+      label: 'Security Policies',
+      type: null,
+      visible: false,
+      serialize: function serialize(_ref12) {
+        var values = _ref12.values;
+        return Object.entries(securityEndpoints).map(function (_ref13) {
+          var _ref14 = _slicedToArray(_ref13, 2),
+              endpointFieldName = _ref14[0],
+              policy = _ref14[1];
+
+          return {
+            endpoint: policy.endpoint,
+            name: values.get(endpointFieldName)
+          };
+        }).filter(function (endpoint) {
+          return endpoint.name !== '';
+        });
+      },
+      initialValue: get(fileResource, 'securityPolicies')
+    }]);
+  };
+};
+
+export var FileResourceForm = generateForm({
+  formOptions: ['fileResourceSlug'],
+  dataSources: dataSources,
+  fields: fields,
+  handleSubmit: handleSubmit
+});
+FileResourceForm.displayName = 'FileResourceForm';

package/lib/components/core/file_resource/FileResourceTable.js

@@ -0,0 +1,71 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { defineKqlQuery } from '../../../helpers';
+import { fetchFileResources } from '../../../apis';
+import { generatePaginationParams, generateSortParams } from '../../../apis/http';
+import { generateTable } from '../../table/Table';
+
+var filters = function filters() {
+  return function () {
+    return [{
+      name: 'slug',
+      label: 'Slug',
+      type: 'text'
+    }];
+  };
+};
+
+var fileResourceQuery = defineKqlQuery().matches('agentSlug', 'agentSlug').matches('filestoreSlug', 'filestoreSlug').matches('slug', 'slug').end();
+
+var dataSource = function dataSource() {
+  return {
+    fn: fetchFileResources,
+    params: function params(paramData) {
+      return [_objectSpread(_objectSpread(_objectSpread({}, generateSortParams(paramData)), generatePaginationParams(paramData)), {}, {
+        q: fileResourceQuery(paramData.filters.toJS()),
+        include: 'details'
+      })];
+    },
+    transform: function transform(result) {
+      return {
+        data: result.fileResources,
+        nextPageToken: result.nextPageToken
+      };
+    }
+  };
+};
+
+var columns = [{
+  value: 'slug',
+  title: 'Slug',
+  sortable: true
+}, {
+  value: 'agentSlug',
+  title: 'Agent Slug',
+  sortable: true
+}, {
+  value: 'filestoreSlug',
+  title: 'File Store Slug',
+  sortable: true
+}, {
+  value: 'createdAt',
+  title: 'Created',
+  sortable: true
+}, {
+  value: 'createdBy',
+  title: 'Created By'
+}, {
+  value: 'updatedAt',
+  title: 'Updated At',
+  sortable: true
+}, {
+  value: 'updatedBy',
+  title: 'Updated By',
+  sortable: true
+}];
+export var FileResourceTable = generateTable({
+  tableOptions: [],
+  columns: columns,
+  filters: filters,
+  dataSource: dataSource
+});
+FileResourceTable.displayName = 'FileResourceTable';

package/lib/components/core/i18n/I18n.js

@@ -99,24 +99,24 @@ export var I18n = /*#__PURE__*/function (_React$Component) {
           }, _this3.props.children);
         } // Otherwise wrap children in a new instance of I18nProvider with the new context
         else if (_this3.state.context) {
-            return /*#__PURE__*/React.createElement(I18nContext.Provider, {
-              value: {
-                context: _this3.state.context,
-                locale: locale,
-                translations: translations,
-                loadTranslations: loadTranslations
-              }
-            }, /*#__PURE__*/React.createElement(I18nTranslate, {
+          return /*#__PURE__*/React.createElement(I18nContext.Provider, {
+            value: {
               context: _this3.state.context,
               locale: locale,
               translations: translations,
-              loadTranslations: loadTranslations,
-              "public": _this3.props["public"]
-            }, _this3.props.children));
-          } // Otherwise return children
-          else {
-              return _this3.props.children;
+              loadTranslations: loadTranslations
             }
+          }, /*#__PURE__*/React.createElement(I18nTranslate, {
+            context: _this3.state.context,
+            locale: locale,
+            translations: translations,
+            loadTranslations: loadTranslations,
+            "public": _this3.props["public"]
+          }, _this3.props.children));
+        } // Otherwise return children
+        else {
+          return _this3.props.children;
+        }
       }) : null;
     }
   }]);

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
+    }]);
+  };
+};