foreman_acd 0.0.5 → 0.5.0

data/webpack/components/ParameterSelection/ParameterSelection.scss

@@ -1 +1,10 @@
 @import '~@theforeman/vendor/scss/variables';
+
+.param_selection_modal {
+    margin-top: 0;
+    margin-bottom: 0;
+    height: 100%;
+    width: 80%;
+    max-width: none !important;
+}
+

data/webpack/components/ParameterSelection/ParameterSelectionActions.js

@@ -16,37 +16,34 @@ import {
 } 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,
+  PARAMETER_SELECTION_INIT,
+  PARAMETER_SELECTION_TYPES,
+  PARAMETER_SELECTION_LOCK,
+  PARAMETER_SELECTION_DELETE,
+  PARAMETER_SELECTION_ADD,
+  PARAMETER_SELECTION_EDIT_ACTIVATE,
+  PARAMETER_SELECTION_EDIT_CONFIRM,
+  PARAMETER_SELECTION_EDIT_CHANGE,
+  PARAMETER_SELECTION_EDIT_CANCEL,
+  PARAMETER_SELECTION_SORT,
+  PARAMETER_SELECTION_PARAM_TYPE_FOREMAN,
+  PARAMETER_SELECTION_PARAM_TYPE_ANSIBLE,
+  PARAMETER_SELECTION_LOAD_PARAM_DATA_REQUEST,
+  PARAMETER_SELECTION_LOAD_PARAM_DATA_SUCCESS,
+  PARAMETER_SELECTION_LOAD_PARAM_DATA_FAILURE,
 } from './ParameterSelectionConstants';
 
 export const initParameterSelection = (
-  mode,
-  appDefinition,
+  paramType,
+  paramDefinition,
   parameters,
+  useDefaultValue,
+  allowNameAdjustment,
+  allowDescriptionAdjustment,
   sortingFormatter,
   sortableTransform,
   inlineEditFormatter,
@@ -60,23 +57,28 @@ export const initParameterSelection = (
         position: 0
     }
   };
-  initialState.appDefinition = appDefinition;
+  initialState.paramDefinition = paramDefinition;
 
-  var valueLabel = 'Value';
-  if (isDefinition(mode)) {
+  let valueLabel = 'Value';
+  if (useDefaultValue) {
     valueLabel = 'Default value';
   }
 
-  initialState.columns = [
-    {
+  initialState.columns = []
+  const addToColumns = (obj, idx) => {
+    obj.header.props.index = idx;
+    initialState.columns.push(obj);
+  }
+
+  let idx = 0;
+  addToColumns( {
       property: 'name',
       header: {
         label: 'Name',
         props: {
-          index: 0,
           sort: true,
           style: {
-            width: '20%'
+            width: '25%'
           }
         },
         transforms: [sortableTransform],
@@ -84,15 +86,15 @@ export const initParameterSelection = (
         customFormatters: [sortableHeaderCellFormatter]
       },
       cell: {
-        formatters: [isDefinition(mode) ? inlineEditFormatter : tableCellFormatter]
+        formatters: [allowNameAdjustment ? inlineEditFormatter : tableCellFormatter]
       }
-    },
-    {
+    }, idx++);
+
+  addToColumns( {
       property: 'description',
       header: {
         label: 'Description',
         props: {
-          index: 1,
           sort: true,
           style: {
             width: '25%'
@@ -106,15 +108,16 @@ export const initParameterSelection = (
         props: {
           index: 1
         },
-        formatters: [isDefinition(mode) ? inlineEditFormatter : tableCellFormatter]
+        formatters: [allowDescriptionAdjustment ? inlineEditFormatter : tableCellFormatter]
       }
-    },
-    {
+    }, idx++);
+
+  if (paramType == PARAMETER_SELECTION_PARAM_TYPE_FOREMAN) {
+    addToColumns( {
       property: 'type',
       header: {
         label: 'Type',
         props: {
-          index: 2,
           sort: true,
           style: {
             width: '20%'
@@ -125,23 +128,21 @@ export const initParameterSelection = (
         customFormatters: [sortableHeaderCellFormatter]
       },
       cell: {
-        props: {
-          index: 2
-        },
         // we are always using the inlineEditFormatter so that
         // the well formatted type name is shown
         formatters: [inlineEditFormatter]
       }
-    },
-    {
+    }, idx++);
+  }
+
+  addToColumns( {
       property: 'value',
       header: {
         label: valueLabel,
         props: {
-          index: 3,
           sort: true,
           style: {
-            width: '25%'
+            width: '20%'
           }
         },
         transforms: [sortableTransform],
@@ -149,47 +150,34 @@ export const initParameterSelection = (
         customFormatters: [sortableHeaderCellFormatter]
       },
       cell: {
-        props: {
-          index: 3
-        },
         formatters: [inlineEditFormatter]
       }
-    },
-    {
+    }, idx++);
+
+  addToColumns( {
       property: 'actions',
       header: {
         label: 'Actions',
         props: {
-          index: 4
+          style: {
+            width: '10%'
+          }
         },
         formatters: [actionHeaderCellFormatter]
       },
       cell: {
-        props: {
-          index: 4
-        },
         formatters: [inlineEditButtonsFormatter]
       }
-    }
-  ];
+    }, idx++);
 
-  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
-  }
+  initialState.parameters = parameters;
 
-  if (isNewDefinition(mode) || isNewInstance(mode)) {
-    initialState.parameterTypes = PARAMETER_TYPES;
-  } else {
-    initialState.parameterTypes = filterUsedParameterTypes(PARAMETER_TYPES, parameters);
+  if ((paramType == PARAMETER_SELECTION_PARAM_TYPE_FOREMAN) && (parameters)) {
+    initialState.parameterTypes = filterUsedParameterTypes(PARAMETER_SELECTION_TYPES, parameters);
   }
 
   dispatch({
-    type: INIT_PARAMETER_SELECTION,
+    type: PARAMETER_SELECTION_INIT,
     payload: initialState,
   });
 }
@@ -202,43 +190,50 @@ const errorHandler = (msg, err) => {
   return { type: msg, payload: { error } };
 };
 
+export const lockParameter = (additionalData) => ({
+  type: PARAMETER_SELECTION_LOCK,
+  payload: {
+    ...additionalData,
+  },
+});
+
 export const addParameter = (additionalData) => ({
-  type: PARAMETER_ADD,
+  type: PARAMETER_SELECTION_ADD,
   payload: {
     ...additionalData,
   },
 });
 
 export const deleteParameter = (additionalData) => ({
-  type: PARAMETER_DELETE,
+  type: PARAMETER_SELECTION_DELETE,
   payload: {
     ...additionalData,
   },
 });
 
 export const activateEditParameter = (additionalData) => ({
-  type: PARAMETER_EDIT_ACTIVATE,
+  type: PARAMETER_SELECTION_EDIT_ACTIVATE,
   payload: {
     ...additionalData,
   },
 });
 
 export const confirmEditParameter = (rowData) => ({
-  type: PARAMETER_EDIT_CONFIRM,
+  type: PARAMETER_SELECTION_EDIT_CONFIRM,
   payload: {
     ...rowData,
   },
 });
 
 export const cancelEditParameter = (rowData) => ({
-  type: PARAMETER_EDIT_CANCEL,
+  type: PARAMETER_SELECTION_EDIT_CANCEL,
   payload: {
     ...rowData,
   },
 });
 
 export const changeEditParameter = (value, additionalData) => ({
-  type: PARAMETER_EDIT_CHANGE,
+  type: PARAMETER_SELECTION_EDIT_CHANGE,
   payload: {
     value,
     ...additionalData,
@@ -246,49 +241,30 @@ export const changeEditParameter = (value, additionalData) => ({
 });
 
 export const sortParameter = (selectedColumn, defaultSortingOrder) => ({
-  type: PARAMETER_SORT,
+  type: PARAMETER_SELECTION_SORT,
   payload: {
     selectedColumn,
     defaultSortingOrder,
   },
 });
 
-export const loadParameterSelection = (
-  url,
-  applicationDefinitionId
-) => dispatch => {
-  dispatch({ type: LOAD_PARAMETER_SELECTION_REQUEST });
+export const loadParamData = (attr) => dispatch => {
+  dispatch( { type: PARAMETER_SELECTION_LOAD_PARAM_DATA_REQUEST, payload: { dataType: attr.dataType, clearParameters: attr.clearParameters } });
 
-  var realUrl = url.replace("__id__", applicationDefinitionId);
+  let realUrl = attr.url.replace("__id__", attr.paramDefinition.dataId);
 
-  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);
+  if (attr.paramDefinition.hasOwnProperty('dataSubId')) {
+    realUrl = realUrl.replace("__subid__", attr.paramDefinition.dataSubId);
+  }
 
   return api
     .get(realUrl, {}, {})
     .then(({ data }) =>
       dispatch({
-        type: LOAD_FOREMAN_DATA_SUCCESS,
-        payload: data,
+        type: PARAMETER_SELECTION_LOAD_PARAM_DATA_SUCCESS,
+        payload: { ...data, dataType: attr.dataType }
       })
     )
-    .catch(error => dispatch(errorHandler(LOAD_FOREMAN_DATA_FAILURE, error)));
+    .catch(error => dispatch(errorHandler(PARAMETER_SELECTION_LOAD_PARAM_DATA_FAILURE, error)));
 };
 

data/webpack/components/ParameterSelection/ParameterSelectionConstants.js

@@ -1,27 +1,23 @@
-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';
+export const PARAMETER_SELECTION_INIT = 'INIT_PARAMETER_SELECTION_INIT';
+export const PARAMETER_SELECTION_LOCK = 'PARAMETER_SELECTION_LOCK';
+export const PARAMETER_SELECTION_DELETE = 'PARAMETER_SELECTION_DELETE';
+export const PARAMETER_SELECTION_ADD = 'PARAMETER_SELECTION_ADD';
+export const PARAMETER_SELECTION_EDIT_ACTIVATE = 'PARAMETER_SELECTION_EDIT_ACTIVATE';
+export const PARAMETER_SELECTION_EDIT_CONFIRM = 'PARAMETER_SELECTION_EDIT_CONFIRM';
+export const PARAMETER_SELECTION_EDIT_CHANGE = 'PARAMETER_SELECTION_EDIT_CHANGE';
+export const PARAMETER_SELECTION_EDIT_CANCEL = 'PARAMETER_SELECTION_EDIT_CANCEL';
+export const PARAMETER_SELECTION_SORT = 'PARAMETER_SELECTION_SORT';
+export const PARAMETER_SELECTION_LOAD_PARAM_DATA_REQUEST = 'PARAMETER_SELECTION_LOAD_PARAM_DATA_REQUEST';
+export const PARAMETER_SELECTION_LOAD_PARAM_DATA_SUCCESS = 'PARAMETER_SELECTION_LOAD_PARAM_DATA_SUCCESS';
+export const PARAMETER_SELECTION_LOAD_PARAM_DATA_FAILURE = 'PARAMETER_SELECTION_LOAD_PARAM_DATA_FAILURE';
+export const PARAMETER_SELECTION_PARAM_TYPE_FOREMAN = 'PARAMETER_SELECTION_PARAM_TYPE_FOREMAN';
+export const PARAMETER_SELECTION_PARAM_TYPE_ANSIBLE = 'PARAMETER_SELECTION_PARAM_TYPE_ANSIBLE';
 
 // Make sure the object is sorted by value
 //   (Compute Profile -> Partition table -> Root password)
-export const PARAMETER_TYPES = {
+export const PARAMETER_SELECTION_TYPES = {
   computeprofile: 'Compute profile',
   domain: 'Domain',
-  hostname: 'Hostname',
   hostparam: 'Host parameter',
   ip: 'IP',
   lifecycleenv: 'Lifecycle environment',

data/webpack/components/ParameterSelection/ParameterSelectionHelper.js

@@ -2,51 +2,19 @@ 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 = {};
+  const result = {};
   fdata.map(item => result[item.id] = item.name)
   return (result);
 }
 
 export const filterUsedParameterTypes = (options, parameters) => {
-  var newOptions = cloneDeep(options);
+  const newOptions = cloneDeep(options);
   // hostparam can be used multiple times
-  var alreadyUsed = parameters.map(item => item["type"]).filter(item => item != 'hostparam');
+  const alreadyUsed = parameters.map(item => item["type"]).filter(item => item != 'hostparam');
   alreadyUsed.forEach(item => delete newOptions[item])
   return newOptions;
 }

data/webpack/components/ParameterSelection/ParameterSelectionReducer.js

@@ -13,23 +13,27 @@ import {
 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,
+  PARAMETER_SELECTION_INIT,
+  PARAMETER_SELECTION_TYPES,
+  PARAMETER_SELECTION_LOCK,
+  PARAMETER_SELECTION_DELETE,
+  PARAMETER_SELECTION_ADD,
+  PARAMETER_SELECTION_EDIT_ACTIVATE,
+  PARAMETER_SELECTION_EDIT_CONFIRM,
+  PARAMETER_SELECTION_EDIT_CHANGE,
+  PARAMETER_SELECTION_EDIT_CANCEL,
+  PARAMETER_SELECTION_SORT,
+  PARAMETER_SELECTION_PARAM_TYPE_FOREMAN,
+  PARAMETER_SELECTION_PARAM_TYPE_ANSIBLE,
+  PARAMETER_SELECTION_LOAD_PARAM_DATA_REQUEST,
+  PARAMETER_SELECTION_LOAD_PARAM_DATA_SUCCESS,
+  PARAMETER_SELECTION_LOAD_PARAM_DATA_FAILURE,
 } from './ParameterSelectionConstants';
 
+import {
+  APPLICATION_DEFINITION_PARAMETER_SELECTION_MODAL_CLOSE,
+} from '../ApplicationDefinition/ApplicationDefinitionConstants';
+
 export const initialState = Immutable({
   editMode: false,
   error: { errorMsg: '', status: '', statusText: '' },
@@ -39,83 +43,97 @@ const parameterSelectionParameters = (state = initialState, action) => {
   const { payload } = action;
 
   switch (action.type) {
-    case INIT_PARAMETER_SELECTION: {
+    case PARAMETER_SELECTION_INIT: {
       return state.merge(payload);
     }
-    case PARAMETER_ADD: {
-      var rows = [];
-      var index = 0;
+    case PARAMETER_SELECTION_ADD: {
+      let parameters = [];
+      let index = 1;
 
-      if ('rows' in state && state.rows !== undefined && state.rows.length > 0) {
-        rows = cloneDeep(state.rows);
-        index = Math.max(...rows.map(e => e.id)) + 1;
+      if ('parameters' in state && state.parameters !== undefined && state.parameters.length > 0) {
+        parameters = cloneDeep(state.parameters);
+        index = Math.max(...parameters.map(e => e.id)) + 1;
       }
 
-      const newRow = {id: index, name: "", description: '', type: '', value: '', newEntry: true };
+      const newRow = {id: index, locked: false, name: "", description: '', type: '', value: '', newEntry: true };
       newRow.backup = cloneDeep(newRow)
-      rows.push(newRow);
+      parameters.push(newRow);
 
       return state.merge({
         editMode: true,
-        rows: rows
+        parameters: parameters
       });
     }
-    case PARAMETER_DELETE: {
-      var rows = state.rows.filter(v => v.id !== payload.rowData.id);
+    case PARAMETER_SELECTION_LOCK: {
+      const parameters = cloneDeep(state.parameters);
+      const index = findIndex(parameters, { id: payload.rowData.id });
+
+      if (parameters[index].locked !== undefined) {
+        parameters[index].locked = !parameters[index].locked;
+      } else {
+        parameters[index].locked = true;
+      }
+
       return state.merge({
-        rows: rows,
-        parameterTypes: filterUsedParameterTypes(PARAMETER_TYPES, rows),
+        parameters: parameters
+      });
+    }
+    case PARAMETER_SELECTION_DELETE: {
+      const parameters = state.parameters.filter(v => v.id !== payload.rowData.id);
+      return state.merge({
+        parameters: parameters,
+        parameterTypes: filterUsedParameterTypes(PARAMETER_SELECTION_TYPES, parameters),
       })
     }
-    case PARAMETER_EDIT_ACTIVATE: {
-      const rows = cloneDeep(state.rows);
-      const index = findIndex(rows, { id: payload.rowData.id });
+    case PARAMETER_SELECTION_EDIT_ACTIVATE: {
+      const parameters = cloneDeep(state.parameters);
+      const index = findIndex(parameters, { id: payload.rowData.id });
 
-      rows[index].backup = cloneDeep(rows[index]);
+      parameters[index].backup = cloneDeep(parameters[index]);
 
       return state.merge({
         editMode: true,
-        rows: rows
+        parameters: parameters
       });
     }
-    case PARAMETER_EDIT_CONFIRM: {
-      const rows = cloneDeep(state.rows);
-      const index = findIndex(rows, { id: payload.rowData.id });
+    case PARAMETER_SELECTION_EDIT_CONFIRM: {
+      const parameters = cloneDeep(state.parameters);
+      const index = findIndex(parameters, { id: payload.rowData.id });
 
-      delete rows[index].backup;
-      delete rows[index].newEntry;
+      delete parameters[index].backup;
+      delete parameters[index].newEntry;
 
       return state.merge({
         editMode: false,
-        parameterTypes: filterUsedParameterTypes(PARAMETER_TYPES, rows),
-        rows: rows
+        parameterTypes: filterUsedParameterTypes(PARAMETER_SELECTION_TYPES, parameters),
+        parameters: parameters
       });
     }
-    case PARAMETER_EDIT_CHANGE: {
-      const rows = cloneDeep(state.rows);
-      const index = findIndex(rows, { id: payload.rowData.id });
+    case PARAMETER_SELECTION_EDIT_CHANGE: {
+      const parameters = cloneDeep(state.parameters);
+      const index = findIndex(parameters, { id: payload.rowData.id });
 
-      rows[index][payload.property] = payload.value;
+      parameters[index][payload.property] = payload.value;
 
-      return state.set('rows', rows);
+      return state.set('parameters', parameters);
     }
-    case PARAMETER_EDIT_CANCEL: {
-      const rows = cloneDeep(state.rows);
-      const index = findIndex(rows, { id: payload.rowData.id });
+    case PARAMETER_SELECTION_EDIT_CANCEL: {
+      const parameters = cloneDeep(state.parameters);
+      const index = findIndex(parameters, { id: payload.rowData.id });
 
-      rows[index] = cloneDeep(rows[index].backup);
-      delete rows[index].backup;
+      parameters[index] = cloneDeep(parameters[index].backup);
+      delete parameters[index].backup;
 
-      if (rows[index].newEntry === true) {
-        rows.splice(index, 1);
+      if (parameters[index].newEntry === true) {
+        parameters.splice(index, 1);
       }
 
       return state.merge({
         editMode: false,
-        rows: rows
+        parameters: parameters
       });
     }
-    case PARAMETER_SORT: {
+    case PARAMETER_SELECTION_SORT: {
       const selectedColumn = payload.selectedColumn;
       return state.set(
         'sortingColumns',
@@ -126,45 +144,59 @@ const parameterSelectionParameters = (state = initialState, action) => {
         })
       );
     }
-    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: {
+    case PARAMETER_SELECTION_LOAD_PARAM_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: [] });
+    case PARAMETER_SELECTION_LOAD_PARAM_DATA_REQUEST: {
+      let newState = {};
+
+      if (payload.dataType == PARAMETER_SELECTION_PARAM_TYPE_FOREMAN) {
+        newState = {
+          paramData: {},
+          hostgroupId: -1,
+          loading: true
+        };
+      } else if (payload.dataType == PARAMETER_SELECTION_PARAM_TYPE_ANSIBLE) {
+        newState = {
+          loading: true
+        };
+      }
+
+      if (payload.clearParameters === true) {
+        Object.assign(newState, { parameters: [] });
+      }
+
+      return state.merge(newState);
+    }
+    case PARAMETER_SELECTION_LOAD_PARAM_DATA_SUCCESS: {
+      let newState = {};
+
+      if (payload.dataType == PARAMETER_SELECTION_PARAM_TYPE_FOREMAN) {
+        newState = {
+          loading: false,
+          paramData: payload,
+          hostgroupId: payload.hostgroup_id,
+        };
       }
 
       return state.merge(newState);
     }
-    case LOAD_FOREMAN_DATA_SUCCESS: {
+    case APPLICATION_DEFINITION_PARAMETER_SELECTION_MODAL_CLOSE: {
+      const parameters = cloneDeep(state.parameters);
+
+      parameters.forEach((param, index) => {
+        delete parameters[index].backup;
+        if (parameters[index].newEntry === true) {
+          parameters.splice(index, 1);
+        }
+      });
+
       return state.merge({
-        loading: false,
-        foremanData: payload,
-        hostgroupId: payload.hostgroup_id,
+        editMode: false,
+        parameters: parameters
       });
     }
     default: