@kineticdata/react 5.1.1 → 6.0.0

package/lib/components/task/triggers/TriggerTable.js

@@ -1,18 +1,23 @@
-import { fetchTaskTriggers, fetchSources } from '../../../apis';
-import { generateTable } from '../../table/Table';
-import { get } from 'immutable';
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TriggerTable = void 0;
+var _apis = require("../../../apis");
+var _Table = require("../../table/Table");
+var _immutable = require("immutable");
 var dataSource = function dataSource(_ref) {
   var runId = _ref.runId,
-      sourceName = _ref.sourceName,
-      sourceGroup = _ref.sourceGroup,
-      tree = _ref.tree,
-      treeType = _ref.treeType,
-      triggerStatus = _ref.triggerStatus,
-      sourceId = _ref.sourceId,
-      status = _ref.status;
+    sourceName = _ref.sourceName,
+    sourceGroup = _ref.sourceGroup,
+    tree = _ref.tree,
+    treeType = _ref.treeType,
+    triggerStatus = _ref.triggerStatus,
+    sourceId = _ref.sourceId,
+    status = _ref.status;
   return {
-    fn: fetchTaskTriggers,
+    fn: _apis.fetchTaskTriggers,
     params: function params(paramData) {
       return [{
         runId: runId,
@@ -39,11 +44,10 @@ var dataSource = function dataSource(_ref) {
     }
   };
 };
-
 var filterDataSources = function filterDataSources() {
   return {
     sourceTypes: {
-      fn: fetchSources,
+      fn: _apis.fetchSources,
       params: [],
       transform: function transform(result) {
         return result.sources.filter(function (s) {
@@ -58,7 +62,6 @@ var filterDataSources = function filterDataSources() {
     }
   };
 };
-
 var filters = function filters() {
   return function (_ref2) {
     var sourceTypes = _ref2.sourceTypes;
@@ -82,7 +85,6 @@ var filters = function filters() {
     }];
   };
 };
-
 var columns = [{
   value: 'action',
   title: 'Action',
@@ -168,7 +170,7 @@ var columns = [{
   title: 'Tree',
   sortable: false,
   valueTransform: function valueTransform(value) {
-    return get(value, 'name', '');
+    return (0, _immutable.get)(value, 'name', '');
   }
 }, {
   value: 'treeType',
@@ -198,10 +200,11 @@ var columns = [{
   title: 'Updated By',
   sortable: false
 }];
-export var TriggerTable = generateTable({
+var TriggerTable = (0, _Table.generateTable)({
   tableOptions: ['runId', 'triggerStatus'],
   columns: columns,
   filters: filters,
   filterDataSources: filterDataSources,
   dataSource: dataSource
-});
+});
+exports.TriggerTable = TriggerTable;

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

@@ -0,0 +1,249 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPossibleTrees = exports.LinkedWorkflowForm = void 0;
+var _immutable = require("immutable");
+var _Form = require("../../form/Form");
+var _apis = require("../../../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);
+};
+exports.getPossibleTrees = getPossibleTrees;
+var dataSources = function dataSources(_ref2) {
+  var workflowId = _ref2.workflowId,
+    kappSlug = _ref2.kappSlug,
+    formSlug = _ref2.formSlug,
+    cloneGuid = _ref2.cloneGuid;
+  return {
+    workflow: {
+      fn: _apis.fetchWorkflow,
+      params: workflowId && [{
+        kappSlug: kappSlug,
+        formSlug: formSlug,
+        workflowId: workflowId,
+        include: 'details'
+      }],
+      transform: function transform(result) {
+        return result.workflow;
+      }
+    },
+    cloneTree: {
+      fn: _apis.fetchTree,
+      params: cloneGuid && [{
+        include: 'details,treeJson',
+        guid: cloneGuid
+      }],
+      transform: function transform(result) {
+        return result.tree;
+      }
+    },
+    kapps: {
+      fn: _apis.fetchKapps,
+      params: cloneGuid && [],
+      transform: function transform(result) {
+        return result.kapps;
+      }
+    },
+    forms: {
+      fn: _apis.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: _apis.fetchKappWebhookEvents,
+      params: [],
+      transform: function transform(result) {
+        return result;
+      }
+    },
+    spaceWebhookEvents: {
+      fn: _apis.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 ? _apis.updateWorkflow : _apis.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 = (0, _immutable.get)(cloneTree, 'event', '');
+  if (!cloneGuid) {
+    // If we're not cloning (editing or new).
+    return (0, _immutable.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 = (0, _immutable.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 ? '' : (0, _immutable.get)(workflow, 'name') || ''
+    }, {
+      name: 'event',
+      label: 'Event',
+      type: 'select',
+      required: true,
+      enabled: !cloneGuid || !(0, _immutable.get)(cloneTree, 'event', ''),
+      options: possibleEvents.map(function (event) {
+        return (0, _immutable.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 (0, _immutable.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 (0, _immutable.Map)({
+            label: form.get('name'),
+            value: form.get('slug')
+          });
+        }) : (0, _immutable.List)();
+      },
+      initialValue: formSlug || ''
+    }, {
+      name: 'treeXml',
+      label: 'Tree XML',
+      type: 'text',
+      required: false,
+      initialValue: ''
+    }];
+  };
+};
+var LinkedWorkflowForm = (0, _Form.generateForm)({
+  formOptions: ['kappSlug', 'formSlug', 'workflowId', 'cloneGuid', 'scope'],
+  dataSources: dataSources,
+  handleSubmit: handleSubmit,
+  fields: fields
+});
+exports.LinkedWorkflowForm = LinkedWorkflowForm;

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

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LinkedWorkflowTable = void 0;
+var _Table = require("../../table/Table");
+var _apis = require("../../../apis");
+var _helpers = require("../../../helpers");
+var STATUS_OPTIONS = ['Active', 'Inactive', 'Paused'].map(function (v) {
+  return {
+    label: v,
+    value: v
+  };
+});
+var clientSide = (0, _helpers.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: _apis.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
+}];
+var LinkedWorkflowTable = (0, _Table.generateTable)({
+  tableOptions: ['kappSlug', 'formSlug'],
+  columns: columns,
+  filters: filters,
+  dataSource: dataSource
+});
+exports.LinkedWorkflowTable = LinkedWorkflowTable;
+LinkedWorkflowTable.displayName = 'LinkedWorkflowTable';

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

@@ -1,11 +1,16 @@
-import { generateTable } from '../../table/Table';
-import { fetchMissingRoutines } from '../../../apis';
-import { defineFilter } from '../../../helpers';
-var clientSide = defineFilter(true).startsWith('definitionId', 'definitionId').end();
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MissingRoutineTable = void 0;
+var _Table = require("../../table/Table");
+var _apis = require("../../../apis");
+var _helpers = require("../../../helpers");
+var clientSide = (0, _helpers.defineFilter)(true).startsWith('definitionId', 'definitionId').end();
 var dataSource = function dataSource() {
   return {
-    fn: fetchMissingRoutines,
+    fn: _apis.fetchMissingRoutines,
     clientSide: clientSide,
     params: function params() {
       return [];
@@ -17,7 +22,6 @@ var dataSource = function dataSource() {
     }
   };
 };
-
 var filters = function filters() {
   return function () {
     return [{
@@ -27,7 +31,6 @@ var filters = function filters() {
     }];
   };
 };
-
 var columns = [{
   value: 'definitionId',
   title: 'Routine Definition Id',
@@ -45,10 +48,11 @@ var columns = [{
   title: 'Nodes',
   sortable: true
 }];
-export var MissingRoutineTable = generateTable({
+var MissingRoutineTable = (0, _Table.generateTable)({
   tableOptions: [],
   columns: columns,
   filters: filters,
   dataSource: dataSource
 });
+exports.MissingRoutineTable = MissingRoutineTable;
 MissingRoutineTable.displayName = 'MissingRoutineTable';