@kineticdata/react 5.1.0 → 5.1.2

package/lib/components/task/builder/models.js

@@ -24,6 +24,8 @@ export var Tree = Record({
   categories: List(),
   connectors: OrderedMap(),
   definitionId: null,
+  event: null,
+  guid: null,
   inputs: null,
   name: '',
   nextNodeId: 0,
@@ -32,6 +34,8 @@ export var Tree = Record({
   notes: '',
   outputs: null,
   ownerEmail: '',
+  platformItemId: null,
+  platformItemType: null,
   schemaVersion: '',
   sourceGroup: '',
   sourceName: '',
@@ -81,6 +85,7 @@ export var TreeBuilderState = Record({
   lastSave: null,
   lastWebApi: null,
   loading: true,
+  platformItem: null,
   redoStack: List(),
   saving: false,
   tasks: OrderedMap(),
@@ -166,11 +171,15 @@ export var deserializeTree = function deserializeTree(_ref4) {
   var bindings = _ref4.bindings,
       categories = _ref4.categories,
       definitionId = _ref4.definitionId,
+      event = _ref4.event,
+      guid = _ref4.guid,
       inputs = _ref4.inputs,
       name = _ref4.name,
       notes = _ref4.notes,
       outputs = _ref4.outputs,
       ownerEmail = _ref4.ownerEmail,
+      platformItemId = _ref4.platformItemId,
+      platformItemType = _ref4.platformItemType,
       sourceGroup = _ref4.sourceGroup,
       sourceName = _ref4.sourceName,
       status = _ref4.status,
@@ -186,11 +195,15 @@ export var deserializeTree = function deserializeTree(_ref4) {
       return [c.id, c];
     })),
     definitionId: definitionId,
+    event: event,
+    guid: guid,
     inputs: List(inputs).map(Map),
     name: name,
     notes: notes,
     outputs: List(outputs).map(Map),
     ownerEmail: ownerEmail,
+    platformItemId: platformItemId,
+    platformItemType: platformItemType,
     nextNodeId: treeJson.lastId + 1,
     nextConnectorId: treeJson.connectors.length,
     nodes: OrderedMap(treeJson.nodes.map(deserializeNode).map(function (n) {
@@ -208,6 +221,7 @@ export var serializeTree = function serializeTree(_ref5) {
   var connectors = _ref5.connectors,
       categories = _ref5.categories,
       definitionId = _ref5.definitionId,
+      event = _ref5.event,
       inputs = _ref5.inputs,
       name = _ref5.name,
       nextNodeId = _ref5.nextNodeId,
@@ -215,6 +229,8 @@ export var serializeTree = function serializeTree(_ref5) {
       notes = _ref5.notes,
       outputs = _ref5.outputs,
       ownerEmail = _ref5.ownerEmail,
+      platformItemId = _ref5.platformItemId,
+      platformItemType = _ref5.platformItemType,
       schemaVersion = _ref5.schemaVersion,
       sourceGroup = _ref5.sourceGroup,
       sourceName = _ref5.sourceName,
@@ -224,11 +240,14 @@ export var serializeTree = function serializeTree(_ref5) {
   return {
     categories: categories,
     definitionId: definitionId,
+    event: event,
     inputs: inputs,
     name: name,
     notes: notes,
     outputs: outputs,
     ownerEmail: ownerEmail,
+    platformItemId: platformItemId,
+    platformItemType: platformItemType,
     sourceGroup: sourceGroup,
     sourceName: sourceName,
     status: status,

package/lib/components/task/workflows/LinkedWorkflowForm.js

@@ -0,0 +1,255 @@
+import { get, List, Map } from 'immutable';
+import { generateForm } from '../../form/Form';
+import { createWorkflow, fetchForms, fetchKapps, fetchKappWebhookEvents, fetchSpaceWebhookEvents, fetchTree, fetchWorkflow, updateWorkflow } from '../../../apis';
+
+var spaceTrees = function spaceTrees(spaceWebhookEvents) {
+  return spaceWebhookEvents.filter(function (_v, key) {
+    return key !== 'Discussion';
+  }).map(function (events, key) {
+    return events.map(function (event) {
+      return "".concat(key, " ").concat(event);
+    });
+  }).toList().flatten();
+};
+
+var kappTrees = function kappTrees(kappWebhookEvents) {
+  return kappWebhookEvents.map(function (events, key) {
+    return events.map(function (event) {
+      return "".concat(key, " ").concat(event);
+    });
+  }).toList().flatten();
+};
+
+var formTrees = function formTrees(webhookEvents) {
+  return webhookEvents.get('Submission').map(function (event) {
+    return "Submission ".concat(event);
+  });
+};
+
+var getPossibleTrees = function getPossibleTrees(_ref) {
+  var kappSlug = _ref.kappSlug,
+      formSlug = _ref.formSlug,
+      spaceWebhookEvents = _ref.spaceWebhookEvents,
+      kappWebhookEvents = _ref.kappWebhookEvents;
+  return kappSlug && formSlug ? formTrees(kappWebhookEvents) : !kappSlug && formSlug ? formTrees(spaceWebhookEvents) : kappSlug ? kappTrees(kappWebhookEvents) : spaceTrees(spaceWebhookEvents);
+};
+
+var dataSources = function dataSources(_ref2) {
+  var workflowId = _ref2.workflowId,
+      kappSlug = _ref2.kappSlug,
+      formSlug = _ref2.formSlug,
+      cloneGuid = _ref2.cloneGuid;
+  return {
+    workflow: {
+      fn: fetchWorkflow,
+      params: workflowId && [{
+        kappSlug: kappSlug,
+        formSlug: formSlug,
+        workflowId: workflowId,
+        include: 'details'
+      }],
+      transform: function transform(result) {
+        return result.workflow;
+      }
+    },
+    cloneTree: {
+      fn: fetchTree,
+      params: cloneGuid && [{
+        include: 'details,treeJson',
+        guid: cloneGuid
+      }],
+      transform: function transform(result) {
+        return result.tree;
+      }
+    },
+    kapps: {
+      fn: fetchKapps,
+      params: cloneGuid && [],
+      transform: function transform(result) {
+        return result.kapps;
+      }
+    },
+    forms: {
+      fn: fetchForms,
+      params: function params(_ref3) {
+        var values = _ref3.values;
+        return cloneGuid && values && values.get('newKappSlug') && [{
+          kappSlug: values.get('newKappSlug')
+        }];
+      },
+      transform: function transform(result) {
+        return result.forms;
+      }
+    },
+    // The requests and data manipulation needed to determine available
+    // `events` for the dropdown options.
+    kappWebhookEvents: {
+      fn: fetchKappWebhookEvents,
+      params: [],
+      transform: function transform(result) {
+        return result;
+      }
+    },
+    spaceWebhookEvents: {
+      fn: fetchSpaceWebhookEvents,
+      params: [],
+      transform: function transform(result) {
+        return result;
+      }
+    },
+    possibleEvents: {
+      fn: getPossibleTrees,
+      params: function params(_ref4) {
+        var spaceWebhookEvents = _ref4.spaceWebhookEvents,
+            kappWebhookEvents = _ref4.kappWebhookEvents;
+        return spaceWebhookEvents && kappWebhookEvents && [{
+          kappSlug: kappSlug,
+          formSlug: formSlug,
+          spaceWebhookEvents: spaceWebhookEvents,
+          kappWebhookEvents: kappWebhookEvents
+        }];
+      },
+      transform: function transform(result) {
+        return result;
+      }
+    }
+  };
+};
+
+var NON_CLONABLE_KEYS = ['createdAt', 'createdBy', 'updatedAt', 'updatedBy', 'sourceGroup', 'sourceName', 'name', 'event', 'title', 'id', 'guid', 'platformItemType', 'platformItemId', 'versionId'];
+
+var handleSubmit = function handleSubmit(_ref5) {
+  var kappSlug = _ref5.kappSlug,
+      formSlug = _ref5.formSlug,
+      workflowId = _ref5.workflowId,
+      cloneGuid = _ref5.cloneGuid;
+  return function (values, _ref6) {
+    var cloneTree = _ref6.cloneTree;
+    var submitFn = workflowId ? updateWorkflow : createWorkflow;
+    var workflow = cloneGuid ? cloneTree.filter(function (_v, key) {
+      return !NON_CLONABLE_KEYS.includes(key);
+    }).set('name', values.get('name')).set('event', values.get('event')).toJS() : values.toJS();
+    var targetKappSlug = cloneGuid ? values.get('newKappSlug') : kappSlug;
+    var targetFormSlug = cloneGuid ? values.get('newFormSlug') : formSlug;
+    return submitFn({
+      kappSlug: targetKappSlug,
+      formSlug: targetFormSlug,
+      workflowId: workflowId,
+      workflow: workflow
+    }).then(function (_ref7) {
+      var workflow = _ref7.workflow,
+          error = _ref7.error;
+
+      if (error) {
+        throw error.statusCode === 400 && error.message || 'There was an error saving the workflow';
+      }
+
+      return {
+        workflow: workflow,
+        targetKappSlug: targetKappSlug,
+        targetFormSlug: targetFormSlug
+      };
+    });
+  };
+};
+
+var isCloneReady = function isCloneReady(cloneTree, kapps, scope) {
+  return cloneTree && (scope !== 'Space' ? kapps : true);
+};
+
+var initialEvent = function initialEvent(cloneGuid, cloneTree, workflow, possibleEvents) {
+  var cloneEvent = get(cloneTree, 'event', '');
+
+  if (!cloneGuid) {
+    // If we're not cloning (editing or new).
+    return get(workflow, 'event', '') || '';
+  } else if (cloneGuid && cloneEvent) {
+    // If we're cloning a linked workflow.
+    return cloneEvent || '';
+  } // Otherwise we have to calculate it depending on the sourceGroup and name
+
+
+  var type = get(cloneTree, 'sourceGroup', '').split(' > ')[0].replace(/s?$/, '');
+  var name = cloneTree.get('name');
+  var event = "".concat(type, " ").concat(name);
+  var legacyEvent = possibleEvents.find(function (e) {
+    return e === event;
+  });
+  return legacyEvent || '';
+};
+
+var fields = function fields(_ref8) {
+  var kappSlug = _ref8.kappSlug,
+      formSlug = _ref8.formSlug,
+      cloneGuid = _ref8.cloneGuid,
+      scope = _ref8.scope;
+  return function (_ref9) {
+    var workflow = _ref9.workflow,
+        cloneTree = _ref9.cloneTree,
+        possibleEvents = _ref9.possibleEvents,
+        kapps = _ref9.kapps;
+    return possibleEvents && (!cloneGuid || isCloneReady(cloneTree, kapps, scope)) && [{
+      name: 'name',
+      label: 'Name',
+      type: 'text',
+      required: true,
+      initialValue: cloneGuid ? '' : get(workflow, 'name') || ''
+    }, {
+      name: 'event',
+      label: 'Event',
+      type: 'select',
+      required: true,
+      enabled: !cloneGuid || !get(cloneTree, 'event', ''),
+      options: possibleEvents.map(function (event) {
+        return Map({
+          label: event,
+          value: event
+        });
+      }),
+      initialValue: initialEvent(cloneGuid, cloneTree, workflow, possibleEvents)
+    }, {
+      name: 'newKappSlug',
+      label: 'Kapp',
+      type: 'select',
+      required: cloneGuid && scope !== 'Space',
+      options: function options(_ref10) {
+        var kapps = _ref10.kapps;
+        return cloneGuid && scope !== 'Space' && kapps && kapps.map(function (kapp) {
+          return Map({
+            label: kapp.get('name'),
+            value: kapp.get('slug')
+          });
+        });
+      },
+      initialValue: kappSlug || ''
+    }, {
+      name: 'newFormSlug',
+      label: 'Form',
+      type: 'select',
+      required: cloneGuid && scope === 'Form',
+      options: function options(_ref11) {
+        var forms = _ref11.forms;
+        return forms ? forms.map(function (form) {
+          return Map({
+            label: form.get('name'),
+            value: form.get('slug')
+          });
+        }) : List();
+      },
+      initialValue: formSlug || ''
+    }, {
+      name: 'treeXml',
+      label: 'Tree XML',
+      type: 'text',
+      required: false,
+      initialValue: ''
+    }];
+  };
+};
+
+export var LinkedWorkflowForm = generateForm({
+  formOptions: ['kappSlug', 'formSlug', 'workflowId', 'cloneGuid', 'scope'],
+  dataSources: dataSources,
+  handleSubmit: handleSubmit,
+  fields: fields
+});

package/lib/components/task/workflows/LinkedWorkflowTable.js

@@ -0,0 +1,133 @@
+import { generateTable } from '../../table/Table';
+import { fetchWorkflows } from '../../../apis';
+import { defineFilter } from '../../../helpers';
+var STATUS_OPTIONS = ['Active', 'Inactive', 'Paused'].map(function (v) {
+  return {
+    label: v,
+    value: v
+  };
+});
+var clientSide = defineFilter(true).equals('name', 'name').startsWith('event', 'event').equals('status', 'status').end();
+
+var dataSource = function dataSource(_ref) {
+  var formSlug = _ref.formSlug,
+      kappSlug = _ref.kappSlug;
+  return {
+    clientSide: clientSide,
+    fn: fetchWorkflows,
+    params: function params(paramData) {
+      return [{
+        kappSlug: kappSlug,
+        formSlug: formSlug,
+        include: 'details',
+        name: paramData.filters.get('name'),
+        event: paramData.filters.get('event'),
+        status: paramData.filters.get('status')
+      }];
+    },
+    transform: function transform(result) {
+      var extraData = {
+        migratable: result.migratable,
+        missing: result.missing,
+        orphaned: result.orphaned
+      };
+      return {
+        data: result.workflows,
+        nextPageToken: result.nextPageToken,
+        extraData: extraData
+      };
+    }
+  };
+};
+
+var filters = function filters() {
+  return function (_ref2) {
+    var sourceTypes = _ref2.sourceTypes;
+    return sourceTypes && [{
+      name: 'name',
+      label: 'Name',
+      type: 'text'
+    }, {
+      name: 'event',
+      label: 'Event',
+      type: 'text'
+    }, {
+      name: 'status',
+      label: 'Status',
+      type: 'select',
+      options: STATUS_OPTIONS
+    }];
+  };
+};
+
+var columns = [{
+  value: 'id',
+  title: 'ID',
+  sortable: false
+}, {
+  value: 'name',
+  title: 'Name',
+  sortable: true
+}, {
+  value: 'event',
+  title: 'Event',
+  sortable: true
+}, {
+  value: 'notes',
+  title: 'Notes',
+  sortable: false
+}, {
+  value: 'definitionId',
+  title: 'Definition ID',
+  sortable: true
+}, {
+  value: 'ownerEmail',
+  title: 'Owner EMail',
+  sortable: false
+}, {
+  value: 'sourceGroup',
+  title: 'Source Group',
+  sortable: true
+}, {
+  value: 'sourceName',
+  title: 'Source Name',
+  sortable: true
+}, {
+  value: 'status',
+  title: 'Status',
+  sortable: true,
+  options: function options() {
+    return STATUS_OPTIONS;
+  }
+}, {
+  value: 'title',
+  title: 'Title',
+  sortable: false
+}, {
+  value: 'type',
+  title: 'type',
+  sortable: false
+}, {
+  value: 'createdAt',
+  title: 'Created',
+  sortable: false
+}, {
+  value: 'createdBy',
+  title: 'Created By',
+  sortable: false
+}, {
+  value: 'updatedAt',
+  title: 'Updated',
+  sortable: true
+}, {
+  value: 'updatedBy',
+  title: 'Updated By',
+  sortable: false
+}];
+export var LinkedWorkflowTable = generateTable({
+  tableOptions: ['kappSlug', 'formSlug'],
+  columns: columns,
+  filters: filters,
+  dataSource: dataSource
+});
+LinkedWorkflowTable.displayName = 'LinkedWorkflowTable';

package/lib/components/task/workflows/WorkflowForm.js

@@ -85,7 +85,8 @@ var fields = function fields(_ref4) {
         return sources;
       },
       initialValue: workflow ? workflow.get('sourceName') : workflowType === 'routines' ? '-' : '',
-      helpText: 'The application that is calling and getting the results back from the workflow.'
+      helpText: 'The application that is calling and getting the results back from the workflow.',
+      visible: !workflow || !workflow.get('event')
     }, {
       name: 'sourceGroup',
       label: 'Source Group',
@@ -101,7 +102,16 @@ var fields = function fields(_ref4) {
         }) : List();
       },
       initialValue: workflow ? workflow.get('sourceGroup') : workflowType === 'routines' ? '-' : '',
-      helpText: "Categorization of the workflow based on rules provided by the Source. For Request CE it's the combination of the type (submission of form), Kapp Slug and the Form Slug separated by a greater than sign ( > ). Example: Submissions > services > onboarding."
+      helpText: "Categorization of the workflow based on rules provided by the Source. For Request CE it's the combination of the type (submission of form), Kapp Slug and the Form Slug separated by a greater than sign ( > ). Example: Submissions > services > onboarding.",
+      visible: !workflow || !workflow.get('event')
+    }, {
+      name: 'event',
+      label: 'Event',
+      type: 'text',
+      initialValue: workflow ? workflow.get('event') : '',
+      required: workflow && !!workflow.get('event'),
+      visible: workflow && !!workflow.get('event'),
+      enabled: false
     }, {
       name: 'name',
       label: 'Name',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kineticdata/react",
-  "version": "5.1.0",
+  "version": "5.1.2",
   "description": "A React library for the Kinetic Platform",
   "main": "lib/index.js",
   "main:src": "src/index.js",
@@ -32,7 +32,7 @@
     "lodash.isplainobject": "^4.0.6",
     "lodash.isstring": "^4.0.1",
     "modularscale-sass": "^3.0.8",
-    "moment": "^2.21.0",
+    "moment": "^2.29.4",
     "prismjs": "1.23.0",
     "prop-types": "^15.7.2",
     "react-autosuggest": "^9.4.3",
@@ -92,5 +92,5 @@
   "eslintConfig": {
     "extends": "react-app"
   },
-  "gitHead": "5040d157c5e19e593fc9f9ca36407058a8d927c5"
+  "gitHead": "08d318b36f6e8922fdbfe2875a1d1d1a0b2552b4"
 }

package/proxyhelper.js

@@ -67,7 +67,6 @@ module.exports = (
   secure: true,
   changeOrigin: true,
   ws: true,
-  xfwd: true,
   onProxyReq: (proxyRequest, originalRequest) => {
     // Browsers may send Origin headers even with same-origin
     // requests. To prevent CORS issues, we have to change
@@ -78,7 +77,7 @@ module.exports = (
 
     if (
       process.env.REACT_APP_PROXY_SUBDOMAIN &&
-      (!proxyRequest.path.endsWith('pack') ||
+      (!proxyRequest.path.endsWith('pack') &&
         !proxyRequest.path.endsWith('favicon.ico'))
     ) {
       proxyRequest.setHeader(