@kineticdata/react 5.1.0-rc.2 → 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;
@@ -117,22 +117,22 @@ var securityEndpoints = {
   defaultFormDisplay: {
     endpoint: 'Default Form Display',
     label: 'Default Form Display',
-    types: ['Space', 'Form']
+    types: ['Form']
   },
   defaultFormModification: {
     endpoint: 'Default Form Modification',
     label: 'Default Form Modification',
-    types: ['Space', 'Form']
+    types: ['Form']
   },
   defaultSubmissionAccess: {
     endpoint: 'Default Submission Access',
     label: 'Default Submission Access',
-    types: ['Space', 'Form', 'Submission']
+    types: ['Form', 'Submission']
   },
   defaultSubmissionModification: {
     endpoint: 'Default Submission Modification',
     label: 'Default Submission Modification',
-    types: ['Space', 'Form', 'Submission']
+    types: ['Form', 'Submission']
   }
 };
 
@@ -446,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/SubmissionForm.js

@@ -0,0 +1,124 @@
+import { List, getIn } from 'immutable';
+import { fetchSubmission, updateSubmission } from '../../../apis';
+import { generateForm } from '../../form/Form';
+import moment from 'moment';
+
+var dataSources = function dataSources(_ref) {
+  var submissionId = _ref.submissionId;
+  return {
+    submission: {
+      fn: fetchSubmission,
+      params: [{
+        id: submissionId,
+        include: 'details,values,form,form.fields,form.fields.details,form.pages'
+      }],
+      transform: function transform(result) {
+        return result.submission;
+      }
+    }
+  };
+};
+
+var handleSubmit = function handleSubmit(_ref2) {
+  var id = _ref2.submissionId;
+  return function (values) {
+    return updateSubmission({
+      id: id,
+      values: values.toJS()
+    }).then(function (_ref3) {
+      var submission = _ref3.submission,
+          error = _ref3.error;
+
+      if (error) {
+        throw error.statusCode === 400 && error.message || 'There was an error saving the submission';
+      }
+
+      return submission;
+    });
+  };
+};
+
+var traverseElement = function traverseElement(traverse, iteratee, acc) {
+  var element = traverse.get(0);
+  var elements = traverse.shift();
+  var childElements = element.get('elements', List());
+  var result = iteratee(element, acc); // If the current element has child elements make a recursive call.
+
+  if (childElements.size > 0) {
+    result = traverseElement(childElements, iteratee, result);
+  }
+
+  if (elements.size > 0) {
+    return traverseElement(elements, iteratee, result);
+  }
+
+  return result;
+};
+
+var convertRenderType = function convertRenderType(element) {
+  if (element.get('renderType') === 'dropdown') {
+    return element.get('choicesResourceName') ? 'text' : 'select';
+  } else if (element.get('renderType') === 'checkbox') {
+    return 'text-multi';
+  } else if (element.get('renderType') === 'attachment') {
+    return 'text';
+  }
+
+  return element.get('renderType');
+};
+
+var getInitialValue = function getInitialValue(submission, element, type) {
+  var name = element.get('name');
+  var isAttachment = element.get('renderType') === 'attachment';
+  var value = getIn(submission, ['values', name], element.get('renderType') === 'checkbox' ? List() : '') || '';
+  return isAttachment ? JSON.stringify(List.isList(value) ? value.toJS() : value) : type === 'datetime' ? moment(value).format('yyyy-MM-DDThh:mm') : type === 'date' ? moment(value).format('yyyy-MM-DD') : value;
+};
+
+var serializer = function serializer(element, type) {
+  return function (_ref4) {
+    var values = _ref4.values;
+    var name = element.get('name');
+    return type === 'datetime' ? moment(values.get(name)).format() : values.get(name);
+  };
+}; // If the element uses bridged options then the `choices` value represents the
+// label/value mapping from and not actual choices.
+
+
+var getChoices = function getChoices(element) {
+  return !!element.get('choicesResourceName') ? List() : element.get('choices');
+};
+
+var fields = function fields() {
+  return function (_ref5) {
+    var submission = _ref5.submission;
+
+    if (submission) {
+      var pages = submission.getIn(['form', 'pages'], List());
+      var values = traverseElement(pages, function (element, values) {
+        var name = element.get('name');
+        var type = convertRenderType(element);
+        var initialValue = getInitialValue(submission, element, type);
+        var isAttachment = element.get('renderType') === 'attachment';
+        return element.get('type') === 'field' ? values.push({
+          name: name,
+          label: name,
+          type: type,
+          options: getChoices(element, initialValue),
+          initialValue: initialValue,
+          enabled: !isAttachment,
+          "transient": isAttachment,
+          serialize: serializer(element, type)
+        }) : values;
+      }, List());
+      return values.toJS();
+    }
+  };
+};
+
+export var SubmissionForm = generateForm({
+  formOptions: ['submissionId'],
+  dataSources: dataSources,
+  fields: fields,
+  handleSubmit: handleSubmit
+});
+SubmissionForm.displayName = 'SubmissionForm';

package/lib/components/core/webapi/WebApiForm.js

@@ -4,7 +4,7 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { generateForm } from '../../form/Form';
 import { get, Map } from 'immutable';
-import { fetchWebApi, createWebApi, updateWebApi, fetchSecurityPolicyDefinitions, fetchSpace, fetchTree, createTree, updateTree } from '../../../apis';
+import { createWebApi, updateWebApi, fetchSecurityPolicyDefinitions, createTree, updateTree, fetchSpace } from '../../../apis';
 export var WEB_API_METHODS = ['GET', 'POST', 'PUT', 'DELETE'];
 var securityEndpoints = {
   webApiExecution: {
@@ -15,136 +15,116 @@ var securityEndpoints = {
 };
 
 var dataSources = function dataSources(_ref) {
-  var slug = _ref.slug,
-      kappSlug = _ref.kappSlug;
+  var kappSlug = _ref.kappSlug,
+      webApi = _ref.webApi;
   return {
-    webApi: {
-      fn: fetchWebApi,
-      params: slug && [{
-        slug: slug,
-        kappSlug: kappSlug,
-        include: 'details,securityPolicies'
-      }],
-      transform: function transform(result) {
-        return result.webApi;
-      }
-    },
     securityPolicyDefinitions: {
       fn: fetchSecurityPolicyDefinitions,
-      params: kappSlug ? [{
-        kappSlug: kappSlug
+      params: kappSlug || webApi && webApi.get('kappSlug') ? [{
+        kappSlug: kappSlug || webApi && webApi.get('kappSlug')
       }] : [],
       transform: function transform(result) {
         return result.securityPolicyDefinitions;
       }
-    },
-    sourceName: {
-      fn: fetchSpace,
-      params: [{
-        include: 'platformComponents'
-      }],
-      transform: function transform(result) {
-        return result.space.platformComponents.task.config.platformSourceName;
-      }
-    },
-    sourceGroup: {
-      fn: function fn() {
-        return kappSlug ? "WebApis > ".concat(kappSlug) : 'WebApis';
-      },
-      params: []
-    },
-    tree: {
-      fn: fetchTree,
-      params: function params(_ref2) {
-        var sourceName = _ref2.sourceName,
-            sourceGroup = _ref2.sourceGroup,
-            webApi = _ref2.webApi;
-        return webApi && sourceName && [{
-          sourceName: sourceName,
-          sourceGroup: sourceGroup,
-          name: webApi.get('slug')
-        }];
-      },
-      transform: function transform(result) {
-        return result.error && result.error.notFound ? {} : result.tree;
-      }
     }
   };
 };
 
-var handleSubmit = function handleSubmit(_ref3) {
-  var slug = _ref3.slug,
-      kappSlug = _ref3.kappSlug;
+var handleSubmit = function handleSubmit(_ref2) {
+  var slug = _ref2.slug,
+      kappSlug = _ref2.kappSlug,
+      webApi = _ref2.webApi;
   return /*#__PURE__*/function () {
-    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(values, bindings) {
-      var sourceGroup, sourceName, tree, _yield, webApi, error, _yield$createTree, createTreeError, _yield$updateTree, updateTreeError;
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(values) {
+      var _yield$fetchSpace, space, sourceName, sourceGroup, _ref4, _webApi, error1, _ref5, tree, error2;
 
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {
             case 0:
-              sourceGroup = bindings.sourceGroup, sourceName = bindings.sourceName, tree = bindings.tree;
+              if (webApi) {
+                _context.next = 38;
+                break;
+              }
+
               _context.next = 3;
-              return (slug ? updateWebApi : createWebApi)({
-                kappSlug: kappSlug,
-                slug: slug,
-                webApi: values.toJS(),
-                include: 'securityPolicies'
+              return fetchSpace({
+                include: 'platformComponents'
               });
 
             case 3:
-              _yield = _context.sent;
-              webApi = _yield.webApi;
-              error = _yield.error;
+              _yield$fetchSpace = _context.sent;
+              space = _yield$fetchSpace.space;
+              sourceName = space.platformComponents.task.config.platformSourceName;
+              sourceGroup = kappSlug ? "WebApis > ".concat(kappSlug) : 'WebApis';
 
-              if (!error) {
-                _context.next = 8;
+              if (!slug) {
+                _context.next = 13;
                 break;
               }
 
-              throw error.statusCode === 400 && error.message || 'There was an error saving the WebAPI';
+              _context.next = 10;
+              return updateWebApi({
+                kappSlug: kappSlug,
+                slug: slug,
+                webApi: values.toJS(),
+                include: 'securityPolicies'
+              });
 
-            case 8:
-              if (slug) {
-                _context.next = 17;
-                break;
-              }
+            case 10:
+              _context.t0 = _context.sent;
+              _context.next = 16;
+              break;
 
-              _context.next = 11;
-              return createTree({
-                tree: {
-                  sourceGroup: sourceGroup,
-                  sourceName: sourceName,
-                  name: values.get('slug')
-                }
+            case 13:
+              _context.next = 15;
+              return createWebApi({
+                kappSlug: kappSlug,
+                webApi: values.toJS(),
+                include: 'securityPolicies'
               });
 
-            case 11:
-              _yield$createTree = _context.sent;
-              createTreeError = _yield$createTree.error;
+            case 15:
+              _context.t0 = _context.sent;
+
+            case 16:
+              _ref4 = _context.t0;
+              _webApi = _ref4.webApi;
+              error1 = _ref4.error;
 
-              if (!createTreeError) {
-                _context.next = 15;
+              if (!error1) {
+                _context.next = 21;
                 break;
               }
 
-              throw createTreeError.statusCode === 400 && createTreeError.message || 'There was an error creating the WebAPI tree';
-
-            case 15:
-              _context.next = 24;
-              break;
+              throw error1.statusCode === 400 && error1.message || 'There was an error saving the WebAPI';
 
-            case 17:
-              if (!(!tree.isEmpty() && slug !== values.get('slug'))) {
-                _context.next = 24;
+            case 21:
+              if (!slug) {
+                _context.next = 27;
                 break;
               }
 
-              _context.next = 20;
+              _context.next = 24;
               return updateTree({
                 sourceName: sourceName,
                 sourceGroup: sourceGroup,
                 name: slug,
+                tree: {
+                  sourceName: sourceName,
+                  sourceGroup: sourceGroup,
+                  name: values.get('slug')
+                }
+              });
+
+            case 24:
+              _context.t1 = _context.sent;
+              _context.next = 30;
+              break;
+
+            case 27:
+              _context.next = 29;
+              return createTree({
                 tree: {
                   sourceGroup: sourceGroup,
                   sourceName: sourceName,
@@ -152,21 +132,31 @@ var handleSubmit = function handleSubmit(_ref3) {
                 }
               });
 
-            case 20:
-              _yield$updateTree = _context.sent;
-              updateTreeError = _yield$updateTree.error;
+            case 29:
+              _context.t1 = _context.sent;
+
+            case 30:
+              _ref5 = _context.t1;
+              tree = _ref5.tree;
+              error2 = _ref5.error;
 
-              if (!updateTreeError) {
-                _context.next = 24;
+              if (!error2) {
+                _context.next = 35;
                 break;
               }
 
-              throw updateTreeError.statusCode === 400 && updateTreeError.message || 'There was an error updating the WebAPI tree';
+              throw error2.statusCode === 400 && error2.message || 'There was an error saving the WebAPI tree';
 
-            case 24:
-              return _context.abrupt("return", webApi);
+            case 35:
+              return _context.abrupt("return", {
+                tree: tree,
+                webApi: _webApi
+              });
+
+            case 38:
+              return _context.abrupt("return", values.toObject());
 
-            case 25:
+            case 39:
             case "end":
               return _context.stop();
           }
@@ -174,18 +164,17 @@ var handleSubmit = function handleSubmit(_ref3) {
       }, _callee);
     }));
 
-    return function (_x, _x2) {
-      return _ref4.apply(this, arguments);
+    return function (_x) {
+      return _ref3.apply(this, arguments);
     };
   }();
 };
 
-var fields = function fields(_ref5) {
-  var slug = _ref5.slug;
-  return function (_ref6) {
-    var tree = _ref6.tree,
-        webApi = _ref6.webApi;
-    return (!slug || webApi && tree) && [{
+var fields = function fields(_ref6) {
+  var webApi = _ref6.webApi;
+  return function (_ref7) {
+    var securityPolicyDefinitions = _ref7.securityPolicyDefinitions;
+    return securityPolicyDefinitions && [{
       name: 'slug',
       label: 'Slug',
       type: 'text',
@@ -203,17 +192,17 @@ var fields = function fields(_ref5) {
         };
       }),
       initialValue: get(webApi, 'method') || ''
-    }].concat(_toConsumableArray(Object.entries(securityEndpoints).map(function (_ref7) {
-      var _ref8 = _slicedToArray(_ref7, 2),
-          endpointFieldName = _ref8[0],
-          endpoint = _ref8[1];
+    }].concat(_toConsumableArray(Object.entries(securityEndpoints).map(function (_ref8) {
+      var _ref9 = _slicedToArray(_ref8, 2),
+          endpointFieldName = _ref9[0],
+          endpoint = _ref9[1];
 
       return {
         name: endpointFieldName,
         label: endpoint.label,
         type: 'select',
-        options: function options(_ref9) {
-          var securityPolicyDefinitions = _ref9.securityPolicyDefinitions;
+        options: function options(_ref10) {
+          var securityPolicyDefinitions = _ref10.securityPolicyDefinitions;
           return securityPolicyDefinitions ? securityPolicyDefinitions.filter(function (definition) {
             return endpoint.types.includes(definition.get('type'));
           }).map(function (definition) {
@@ -233,20 +222,16 @@ var fields = function fields(_ref5) {
       label: 'Security Policies',
       type: null,
       visible: false,
-      serialize: function serialize(_ref10) {
-        var values = _ref10.values;
-        return Object.entries(securityEndpoints).map(function (_ref11) {
-          var _ref12 = _slicedToArray(_ref11, 2),
-              endpointFieldName = _ref12[0],
-              policy = _ref12[1];
-
-          return {
+      serialize: function serialize(_ref11) {
+        var values = _ref11.values;
+        return Map(securityEndpoints).map(function (policy, endpointFieldName) {
+          return Map({
             endpoint: policy.endpoint,
             name: values.get(endpointFieldName)
-          };
-        }).filter(function (endpoint) {
-          return endpoint.name !== '';
-        });
+          });
+        }).valueSeq().filter(function (policy) {
+          return policy.get('name') !== '';
+        }).toList();
       },
       initialValue: get(webApi, 'securityPolicies')
     }]);
@@ -254,7 +239,7 @@ var fields = function fields(_ref5) {
 };
 
 export var WebApiForm = generateForm({
-  formOptions: ['slug', 'kappSlug'],
+  formOptions: ['kappSlug', 'slug', 'webApi'],
   dataSources: dataSources,
   fields: fields,
   handleSubmit: handleSubmit

package/lib/components/form/Form.helpers.js

@@ -257,7 +257,7 @@ export var getFieldComponentProps = function getFieldComponentProps(field, readO
     onBlur: field.eventHandlers.get('onBlur'),
     onChange: field.eventHandlers.get('onChange'),
     onFocus: field.eventHandlers.get('onFocus'),
-    options: ['attributes', 'code', 'form', 'form-multi', 'map', 'radio', 'select', 'select-multi', 'table', 'text', 'text-multi'].includes(field.type) ? field.options : undefined,
+    options: ['attributes', 'checkbox-multi', 'code', 'form', 'form-multi', 'map', 'radio', 'select', 'select-multi', 'table', 'text', 'text-multi'].includes(field.type) ? field.options : undefined,
     placeholder: field.placeholder,
     renderAttributes: field.renderAttributes,
     required: field.required,