foreman_acd 0.0.1

data/webpack/components/ParameterSelection/ParameterSelectionActions.js

@@ -0,0 +1,294 @@
+import React from 'react';
+import * as sort from 'sortabular';
+
+import {
+  actionHeaderCellFormatter,
+  sortableHeaderCellFormatter,
+  tableCellFormatter,
+  TABLE_SORT_DIRECTION
+} from 'patternfly-react';
+
+import api from 'foremanReact/API';
+
+import {
+  propsToSnakeCase,
+  propsToCamelCase,
+} from 'foremanReact/common/helpers';
+
+import {
+  isNewDefinition,
+  isEditDefinition,
+  isDefinition,
+  isNewInstance,
+  isEditInstance,
+  isInstance,
+  filterUsedParameterTypes,
+} from './ParameterSelectionHelper';
+
+import {
+  INIT_PARAMETER_SELECTION,
+  PARAMETER_TYPES,
+  PARAMETER_DELETE,
+  PARAMETER_ADD,
+  PARAMETER_EDIT_ACTIVATE,
+  PARAMETER_EDIT_CONFIRM,
+  PARAMETER_EDIT_CHANGE,
+  PARAMETER_EDIT_CANCEL,
+  PARAMETER_SORT,
+  LOAD_PARAMETER_SELECTION_REQUEST,
+  LOAD_PARAMETER_SELECTION_SUCCESS,
+  LOAD_PARAMETER_SELECTION_FAILURE,
+  LOAD_FOREMAN_DATA_REQUEST,
+  LOAD_FOREMAN_DATA_SUCCESS,
+  LOAD_FOREMAN_DATA_FAILURE,
+} from './ParameterSelectionConstants';
+
+export const initParameterSelection = (
+  mode,
+  appDefinition,
+  parameters,
+  sortingFormatter,
+  sortableTransform,
+  inlineEditFormatter,
+  inlineEditButtonsFormatter,
+) => dispatch => {
+  const initialState = {};
+
+  initialState.sortingColumns = {
+    name: {
+      direction: TABLE_SORT_DIRECTION.ASC,
+        position: 0
+    }
+  };
+  initialState.appDefinition = appDefinition;
+
+  var valueLabel = 'Value';
+  if (isDefinition(mode)) {
+    valueLabel = 'Default value';
+  }
+
+  initialState.columns = [
+    {
+      property: 'name',
+      header: {
+        label: 'Name',
+        props: {
+          index: 0,
+          sort: true,
+          style: {
+            width: '20%'
+          }
+        },
+        transforms: [sortableTransform],
+        formatters: [sortingFormatter],
+        customFormatters: [sortableHeaderCellFormatter]
+      },
+      cell: {
+        formatters: [isDefinition(mode) ? inlineEditFormatter : tableCellFormatter]
+      }
+    },
+    {
+      property: 'description',
+      header: {
+        label: 'Description',
+        props: {
+          index: 1,
+          sort: true,
+          style: {
+            width: '25%'
+          }
+        },
+        transforms: [sortableTransform],
+        formatters: [sortingFormatter],
+        customFormatters: [sortableHeaderCellFormatter]
+      },
+      cell: {
+        props: {
+          index: 1
+        },
+        formatters: [isDefinition(mode) ? inlineEditFormatter : tableCellFormatter]
+      }
+    },
+    {
+      property: 'type',
+      header: {
+        label: 'Type',
+        props: {
+          index: 2,
+          sort: true,
+          style: {
+            width: '20%'
+          }
+        },
+        transforms: [sortableTransform],
+        formatters: [sortingFormatter],
+        customFormatters: [sortableHeaderCellFormatter]
+      },
+      cell: {
+        props: {
+          index: 2
+        },
+        // we are always using the inlineEditFormatter so that
+        // the well formatted type name is shown
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'value',
+      header: {
+        label: valueLabel,
+        props: {
+          index: 3,
+          sort: true,
+          style: {
+            width: '25%'
+          }
+        },
+        transforms: [sortableTransform],
+        formatters: [sortingFormatter],
+        customFormatters: [sortableHeaderCellFormatter]
+      },
+      cell: {
+        props: {
+          index: 3
+        },
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'actions',
+      header: {
+        label: 'Actions',
+        props: {
+          index: 4
+        },
+        formatters: [actionHeaderCellFormatter]
+      },
+      cell: {
+        props: {
+          index: 4
+        },
+        formatters: [inlineEditButtonsFormatter]
+      }
+    }
+  ];
+
+  if ((isNewDefinition(mode)) || (isNewInstance(mode))) {
+    initialState.rows = [];
+  } else if ((isEditDefinition(mode)) || (isEditInstance(mode))) {
+    initialState.rows = parameters;
+    initialState.hostgroupId = appDefinition.hostgroup_id;
+  } else {
+    // FIXME: should never ever happen
+  }
+
+  if (isNewDefinition(mode) || isNewInstance(mode)) {
+    initialState.parameterTypes = PARAMETER_TYPES;
+  } else {
+    initialState.parameterTypes = filterUsedParameterTypes(PARAMETER_TYPES, parameters);
+  }
+
+  dispatch({
+    type: INIT_PARAMETER_SELECTION,
+    payload: initialState,
+  });
+}
+
+const errorHandler = (msg, err) => {
+  const error = {
+    errorMsg: 'Failed to fetch data from server.',
+    statusText: err,
+  };
+  return { type: msg, payload: { error } };
+};
+
+export const addParameter = (additionalData) => ({
+  type: PARAMETER_ADD,
+  payload: {
+    ...additionalData,
+  },
+});
+
+export const deleteParameter = (additionalData) => ({
+  type: PARAMETER_DELETE,
+  payload: {
+    ...additionalData,
+  },
+});
+
+export const activateEditParameter = (additionalData) => ({
+  type: PARAMETER_EDIT_ACTIVATE,
+  payload: {
+    ...additionalData,
+  },
+});
+
+export const confirmEditParameter = (rowData) => ({
+  type: PARAMETER_EDIT_CONFIRM,
+  payload: {
+    ...rowData,
+  },
+});
+
+export const cancelEditParameter = (rowData) => ({
+  type: PARAMETER_EDIT_CANCEL,
+  payload: {
+    ...rowData,
+  },
+});
+
+export const changeEditParameter = (value, additionalData) => ({
+  type: PARAMETER_EDIT_CHANGE,
+  payload: {
+    value,
+    ...additionalData,
+  },
+});
+
+export const sortParameter = (selectedColumn, defaultSortingOrder) => ({
+  type: PARAMETER_SORT,
+  payload: {
+    selectedColumn,
+    defaultSortingOrder,
+  },
+});
+
+export const loadParameterSelection = (
+  url,
+  applicationDefinitionId
+) => dispatch => {
+  dispatch({ type: LOAD_PARAMETER_SELECTION_REQUEST });
+
+  var realUrl = url.replace("__id__", applicationDefinitionId);
+
+  return api
+    .get(realUrl, {}, {})
+    .then(({ data }) =>
+      dispatch({
+        type: LOAD_PARAMETER_SELECTION_SUCCESS,
+        payload: data,
+      })
+    )
+    .catch(error => dispatch(errorHandler(LOAD_PARAMETER_SELECTION_FAILURE, error)));
+};
+
+export const loadForemanData = (
+  url,
+  hostgroupId,
+  clearRows = false,
+) => dispatch => {
+  dispatch({ type: LOAD_FOREMAN_DATA_REQUEST, payload: { clearRows: clearRows } });
+
+  var realUrl = url.replace("__id__", hostgroupId);
+
+  return api
+    .get(realUrl, {}, {})
+    .then(({ data }) =>
+      dispatch({
+        type: LOAD_FOREMAN_DATA_SUCCESS,
+        payload: data,
+      })
+    )
+    .catch(error => dispatch(errorHandler(LOAD_FOREMAN_DATA_FAILURE, error)));
+};
+

data/webpack/components/ParameterSelection/ParameterSelectionConstants.js

@@ -0,0 +1,31 @@
+export const INIT_PARAMETER_SELECTION = 'INIT_PARAMETER_SELECTION';
+
+export const PARAMETER_DELETE = 'PARAMETER_DELETE';
+export const PARAMETER_ADD = 'PARAMETER_ADD';
+export const PARAMETER_EDIT_ACTIVATE = 'PARAMETER_EDIT_ACTIVATE';
+export const PARAMETER_EDIT_CONFIRM = 'PARAMETER_EDIT_CONFIRM';
+export const PARAMETER_EDIT_CHANGE = 'PARAMETER_EDIT_CHANGE';
+export const PARAMETER_EDIT_CANCEL = 'PARAMETER_EDIT_CANCEL';
+export const PARAMETER_SORT = 'PARAMETER_SORT';
+
+export const LOAD_PARAMETER_SELECTION_REQUEST = 'LOAD_PARAMETER_SELECTION_REQUEST';
+export const LOAD_PARAMETER_SELECTION_SUCCESS = 'LOAD_PARAMETER_SELECTION_SUCCESS';
+export const LOAD_PARAMETER_SELECTION_FAILURE = 'LOAD_PARAMETER_SELECTION_FAILURE';
+
+export const LOAD_FOREMAN_DATA_REQUEST = 'LOAD_FOREMAN_DATA_REQUEST';
+export const LOAD_FOREMAN_DATA_SUCCESS = 'LOAD_FOREMAN_DATA_SUCCESS';
+export const LOAD_FOREMAN_DATA_FAILURE = 'LOAD_FOREMAN_DATA_FAILURE';
+
+// Make sure the object is sorted by value
+//   (Compute Profile -> Partition table -> Root password)
+export const PARAMETER_TYPES = {
+  computeprofile: 'Compute profile',
+  domain: 'Domain',
+  hostname: 'Hostname',
+  hostparam: 'Host parameter',
+  ip: 'IP',
+  lifecycleenv: 'Lifecycle environment',
+  ptable: 'Partition table',
+  puppetenv: 'Puppet environment',
+  password: 'Root password',
+};

data/webpack/components/ParameterSelection/ParameterSelectionHelper.js

@@ -0,0 +1,52 @@
+import {
+  cloneDeep,
+} from 'lodash';
+
+export const isNewDefinition = (mode) => {
+  if (mode == "newDefinition")
+    return true;
+  return false;
+}
+
+export const isEditDefinition = (mode) => {
+  if (mode == "editDefinition")
+    return true;
+  return false;
+}
+
+export const isDefinition = (mode) => {
+  return (isNewDefinition(mode) || isEditDefinition(mode))
+}
+
+export const isNewInstance = (mode) => {
+  if (mode == "newInstance")
+    return true;
+  return false;
+}
+
+export const isEditInstance = (mode) => {
+  if (mode == "editInstance")
+    return true;
+  return false;
+}
+
+export const isInstance = (mode) => {
+  return (isNewInstance(mode) || isEditInstance(mode))
+}
+
+export const transformForemanData = (fdata) => {
+  if (fdata === undefined) {
+    return "";
+  }
+  var result = {};
+  fdata.map(item => result[item.id] = item.name)
+  return (result);
+}
+
+export const filterUsedParameterTypes = (options, parameters) => {
+  var newOptions = cloneDeep(options);
+  // hostparam can be used multiple times
+  var alreadyUsed = parameters.map(item => item["type"]).filter(item => item != 'hostparam');
+  alreadyUsed.forEach(item => delete newOptions[item])
+  return newOptions;
+}

data/webpack/components/ParameterSelection/ParameterSelectionReducer.js

@@ -0,0 +1,175 @@
+import Immutable from 'seamless-immutable';
+
+import {
+  cloneDeep,
+  findIndex,
+  findLastIndex,
+} from 'lodash';
+
+import {
+  filterUsedParameterTypes,
+} from './ParameterSelectionHelper';
+
+import * as sort from 'sortabular';
+
+import {
+  INIT_PARAMETER_SELECTION,
+  PARAMETER_TYPES,
+  PARAMETER_DELETE,
+  PARAMETER_ADD,
+  PARAMETER_EDIT_ACTIVATE,
+  PARAMETER_EDIT_CONFIRM,
+  PARAMETER_EDIT_CHANGE,
+  PARAMETER_EDIT_CANCEL,
+  PARAMETER_SORT,
+  LOAD_PARAMETER_SELECTION_REQUEST,
+  LOAD_PARAMETER_SELECTION_SUCCESS,
+  LOAD_PARAMETER_SELECTION_FAILURE,
+  LOAD_FOREMAN_DATA_REQUEST,
+  LOAD_FOREMAN_DATA_SUCCESS,
+  LOAD_FOREMAN_DATA_FAILURE,
+} from './ParameterSelectionConstants';
+
+export const initialState = Immutable({
+  editMode: false,
+  error: { errorMsg: '', status: '', statusText: '' },
+});
+
+const parameterSelectionParameters = (state = initialState, action) => {
+  const { payload } = action;
+
+  switch (action.type) {
+    case INIT_PARAMETER_SELECTION: {
+      return state.merge(payload);
+    }
+    case PARAMETER_ADD: {
+      var rows = [];
+      var index = 0;
+
+      if ('rows' in state && state.rows !== undefined && state.rows.length > 0) {
+        rows = cloneDeep(state.rows);
+        index = Math.max(...rows.map(e => e.id)) + 1;
+      }
+
+      const newRow = {id: index, name: "", description: '', type: '', value: '', newEntry: true };
+      newRow.backup = cloneDeep(newRow)
+      rows.push(newRow);
+
+      return state.merge({
+        editMode: true,
+        rows: rows
+      });
+    }
+    case PARAMETER_DELETE: {
+      var rows = state.rows.filter(v => v.id !== payload.rowData.id);
+      return state.merge({
+        rows: rows,
+        parameterTypes: filterUsedParameterTypes(PARAMETER_TYPES, rows),
+      })
+    }
+    case PARAMETER_EDIT_ACTIVATE: {
+      const rows = cloneDeep(state.rows);
+      const index = findIndex(rows, { id: payload.rowData.id });
+
+      rows[index].backup = cloneDeep(rows[index]);
+
+      return state.merge({
+        editMode: true,
+        rows: rows
+      });
+    }
+    case PARAMETER_EDIT_CONFIRM: {
+      const rows = cloneDeep(state.rows);
+      const index = findIndex(rows, { id: payload.rowData.id });
+
+      delete rows[index].backup;
+      delete rows[index].newEntry;
+
+      return state.merge({
+        editMode: false,
+        parameterTypes: filterUsedParameterTypes(PARAMETER_TYPES, rows),
+        rows: rows
+      });
+    }
+    case PARAMETER_EDIT_CHANGE: {
+      const rows = cloneDeep(state.rows);
+      const index = findIndex(rows, { id: payload.rowData.id });
+
+      rows[index][payload.property] = payload.value;
+
+      return state.set('rows', rows);
+    }
+    case PARAMETER_EDIT_CANCEL: {
+      const rows = cloneDeep(state.rows);
+      const index = findIndex(rows, { id: payload.rowData.id });
+
+      rows[index] = cloneDeep(rows[index].backup);
+      delete rows[index].backup;
+
+      if (rows[index].newEntry === true) {
+        rows.splice(index, 1);
+      }
+
+      return state.merge({
+        editMode: false,
+        rows: rows
+      });
+    }
+    case PARAMETER_SORT: {
+      const selectedColumn = payload.selectedColumn;
+      return state.set(
+        'sortingColumns',
+        sort.byColumn({
+          sortingColumns: state.sortingColumns,
+          sortingOrder: payload.defaultSortingOrder,
+          selectedColumn
+        })
+      );
+    }
+    case LOAD_PARAMETER_SELECTION_FAILURE: {
+      return state.merge({ error: payload.error, loading: false });
+    }
+    case LOAD_PARAMETER_SELECTION_REQUEST: {
+      return state.set('loading', true);
+    }
+    case LOAD_PARAMETER_SELECTION_SUCCESS: {
+      return state.merge({
+        appDefinition: payload.app_definition,
+        loading: false,
+        rows: JSON.parse(payload.app_definition.parameters),
+        hostgroupId: payload.app_definition.hostgroup_id,
+        foremanData: payload.fdata,
+      });
+    }
+    case LOAD_FOREMAN_DATA_FAILURE: {
+      return state.merge({
+        error: payload.error,
+        loading: false
+      });
+    }
+    case LOAD_FOREMAN_DATA_REQUEST: {
+      var newState = {
+        foremanData: {},
+        hostgroupId: -1,
+        loading: true
+      };
+
+      if (payload.clearRows === true) {
+        Object.assign(newState, { rows: [] });
+      }
+
+      return state.merge(newState);
+    }
+    case LOAD_FOREMAN_DATA_SUCCESS: {
+      return state.merge({
+        loading: false,
+        foremanData: payload,
+        hostgroupId: payload.hostgroup_id,
+      });
+    }
+    default:
+      return state;
+  }
+};
+
+export default parameterSelectionParameters;

data/webpack/components/ParameterSelection/ParameterSelectionSelectors.js

@@ -0,0 +1,15 @@
+import { differenceBy, slice, includes, uniq } from 'lodash';
+import Immutable from 'seamless-immutable';
+import { createSelector } from 'reselect';
+
+const parameterState = state => state.foremanAcd.parameterSelectionParameters;
+
+export const selectLoading = state => parameterState(state).loading;
+export const selectEditMode = state => parameterState(state).editMode;
+export const selectForemanData = state => parameterState(state).foremanData;
+export const selectParameterTypes = state => parameterState(state).parameterTypes;
+export const selectRows = state => parameterState(state).rows;
+export const selectSortingColumns = state => parameterState(state).sortingColumns;
+export const selectColumns = state => parameterState(state).columns;
+export const selectAppDefinition = state => parameterState(state).appDefinition;
+export const selectHostgroupId = state => parameterState(state).hostgroupId;