foreman_acd 0.0.4 → 0.4.0

data/webpack/components/ApplicationDefinition/ApplicationDefinition.scss

@@ -0,0 +1 @@
+@import '~@theforeman/vendor/scss/variables';

data/webpack/components/ApplicationDefinition/ApplicationDefinitionActions.js

@@ -0,0 +1,295 @@
+import React from 'react';
+import api from 'foremanReact/API';
+
+import {
+  setModalOpen,
+  setModalClosed,
+} from 'foremanReact/components/ForemanModal/ForemanModalActions';
+
+import {
+  actionHeaderCellFormatter,
+} from 'patternfly-react';
+
+import {
+  propsToSnakeCase,
+  propsToCamelCase,
+} from 'foremanReact/common/helpers';
+
+import {
+  APPLICATION_DEFINITION_INIT,
+  APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_REQUEST,
+  APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_SUCCESS,
+  APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_FAILURE,
+  APPLICATION_DEFINITION_SERVICE_DELETE,
+  APPLICATION_DEFINITION_SERVICE_ADD,
+  APPLICATION_DEFINITION_SERVICE_EDIT_ACTIVATE,
+  APPLICATION_DEFINITION_SERVICE_EDIT_CONFIRM,
+  APPLICATION_DEFINITION_SERVICE_EDIT_CHANGE,
+  APPLICATION_DEFINITION_SERVICE_EDIT_CANCEL,
+  APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_OPEN,
+  APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_CLOSE,
+  APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_OPEN,
+  APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_CLOSE,
+} from './ApplicationDefinitionConstants';
+
+import {
+  transformAnsiblePlaybook,
+} from './ApplicationDefinitionHelper';
+
+export const initApplicationDefinition = (
+  ansiblePlaybook,
+  services,
+  ansibleVarsAll,
+  headerFormatter,
+  inlineEditFormatter,
+  inlineEditButtonsFormatter,
+) => dispatch => {
+  const initialState = {};
+
+  initialState.columns = [
+    {
+      property: 'name',
+      header: {
+        label: 'Name',
+        formatters: [headerFormatter],
+        props: {
+          index: 0,
+          style: {
+            width: '15%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'description',
+      header: {
+        label: 'Description',
+        formatters: [headerFormatter],
+        props: {
+          index: 1,
+          style: {
+            width: '10%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'hostgroup',
+      header: {
+        label: 'Hostgroup',
+        formatters: [headerFormatter],
+        props: {
+          index: 2,
+          style: {
+            width: '20%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'ansibleGroup',
+      header: {
+        label: 'Ansible Group',
+        formatters: [headerFormatter],
+        props: {
+          index: 3,
+          style: {
+            width: '20%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'minCount',
+      header: {
+        label: 'min count',
+        formatters: [headerFormatter],
+        props: {
+          index: 4,
+          style: {
+            width: '10%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'maxCount',
+      header: {
+        label: 'max count',
+        formatters: [headerFormatter],
+        props: {
+          index: 5,
+          style: {
+            width: '10%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'actions',
+      header: {
+        label: 'Actions',
+        formatters: [actionHeaderCellFormatter],
+        props: {
+          index: 6,
+          style: {
+            width: '15%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditButtonsFormatter]
+      }
+    }
+  ];
+
+  if (ansiblePlaybook !== undefined) {
+    initialState.ansiblePlaybook = transformAnsiblePlaybook(ansiblePlaybook);
+  }
+  initialState.services = services;
+  initialState.ansibleVarsAll = ansibleVarsAll;
+
+  dispatch({
+    type: APPLICATION_DEFINITION_INIT,
+    payload: initialState,
+  });
+};
+
+const errorHandler = (msg, err) => {
+  const error = {
+    errorMsg: 'Failed to fetch data from server.',
+    statusText: err,
+  };
+  return { type: msg, payload: { error } };
+};
+
+export const loadAnsibleData = (
+  ansiblePlaybookId,
+  additionalData
+) => dispatch => {
+  dispatch({ type: APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_REQUEST });
+
+  const baseUrl = additionalData.url;
+  const realUrl = baseUrl.replace("__id__", ansiblePlaybookId);
+
+  return api
+    .get(realUrl, {}, {})
+    .then(({ data }) =>
+      dispatch({
+        type: APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_SUCCESS,
+        payload: { ...data }
+      })
+    )
+    .catch(error => dispatch(errorHandler(APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_FAILURE, error)));
+};
+
+export const addApplicationDefinitionService = (additionalData) => ({
+  type: APPLICATION_DEFINITION_SERVICE_ADD,
+  payload: {
+    ...additionalData,
+  },
+});
+
+export const deleteApplicationDefinitionService = (additionalData) => ({
+  type: APPLICATION_DEFINITION_SERVICE_DELETE,
+  payload: {
+    ...additionalData,
+  },
+});
+
+export const activateEditApplicationDefinitionService = (additionalData) => ({
+  type: APPLICATION_DEFINITION_SERVICE_EDIT_ACTIVATE,
+  payload: {
+    ...additionalData,
+  },
+});
+
+export const confirmEditApplicationDefinitionService = (rowData) => ({
+  type: APPLICATION_DEFINITION_SERVICE_EDIT_CONFIRM,
+  payload: {
+    ...rowData,
+  },
+});
+
+export const cancelEditApplicationDefinitionService = (rowData) => ({
+  type: APPLICATION_DEFINITION_SERVICE_EDIT_CANCEL,
+  payload: {
+    ...rowData,
+  },
+});
+
+export const changeEditApplicationDefinitionService = (value, additionalData) => ({
+  type: APPLICATION_DEFINITION_SERVICE_EDIT_CHANGE,
+  payload: {
+    value,
+    ...additionalData,
+  },
+});
+
+export const openForemanParameterSelectionModal = (additionalData) => dispatch => {
+  dispatch({
+    type: APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_OPEN,
+    payload: {
+      ...additionalData,
+    }
+  });
+  dispatch(
+    setModalOpen({ id: 'AppDefinitionForemanParamSelection' })
+  );
+}
+
+export const closeForemanParameterSelectionModal = (additionalData) => dispatch => {
+  dispatch({
+    type: APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_CLOSE,
+    payload: {
+      ...additionalData,
+    }
+  });
+
+  dispatch(
+    setModalClosed({ id: 'AppDefinitionForemanParamSelection' })
+  );
+}
+
+export const openAnsibleParameterSelectionModal = (additionalData) => dispatch => {
+  dispatch({
+    type: APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_OPEN,
+    payload: {
+      ...additionalData,
+    }
+  });
+  dispatch(
+    setModalOpen({ id: 'AppDefinitionAnsibleParamSelection' })
+  );
+}
+
+export const closeAnsibleParameterSelectionModal = (additionalData) => dispatch => {
+  dispatch({
+    type: APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_CLOSE,
+    payload: {
+      ...additionalData,
+    }
+  });
+
+  dispatch(
+    setModalClosed({ id: 'AppDefinitionAnsibleParamSelection' })
+  );
+}

data/webpack/components/ApplicationDefinition/ApplicationDefinitionConstants.js

@@ -0,0 +1,14 @@
+export const APPLICATION_DEFINITION_INIT = 'INIT_APPLICATION_DEFINITION_INIT';
+export const APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_REQUEST = 'APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_REQUEST';
+export const APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_SUCCESS = 'APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_SUCCESS';
+export const APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_FAILURE = 'APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_FAILURE';
+export const APPLICATION_DEFINITION_SERVICE_DELETE = 'APPLICATION_DEFINITION_SERVICE_DELETE';
+export const APPLICATION_DEFINITION_SERVICE_ADD = 'APPLICATION_DEFINITION_SERVICE_ADD';
+export const APPLICATION_DEFINITION_SERVICE_EDIT_ACTIVATE = 'APPLICATION_DEFINITION_SERVICE_EDIT_ACTIVATE';
+export const APPLICATION_DEFINITION_SERVICE_EDIT_CONFIRM = 'APPLICATION_DEFINITION_SERVICE_EDIT_CONFIRM';
+export const APPLICATION_DEFINITION_SERVICE_EDIT_CHANGE = 'APPLICATION_DEFINITION_SERVICE_EDIT_CHANGE';
+export const APPLICATION_DEFINITION_SERVICE_EDIT_CANCEL = 'APPLICATION_DEFINITION_SERVICE_EDIT_CANCEL';
+export const APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_OPEN = 'APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_OPEN';
+export const APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_CLOSE = 'APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_CLOSE';
+export const APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_OPEN = 'APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_OPEN';
+export const APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_CLOSE = 'APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_CLOSE';

data/webpack/components/ApplicationDefinition/ApplicationDefinitionHelper.js

@@ -0,0 +1,26 @@
+export function transformAnsiblePlaybook(playbook) {
+
+  const ansiblePlaybook = new Object;
+  ansiblePlaybook.id = playbook.id;
+  ansiblePlaybook.name = playbook.name;
+  ansiblePlaybook.groups = {};
+
+  if (playbook.hasOwnProperty('groups')) {
+    Object.entries(playbook.groups).forEach(([group_name,group_vars]) => {
+      ansiblePlaybook.groups[group_name] = [];
+
+      let id=0;
+      Object.entries(group_vars).forEach(([var_name,var_value]) => {
+        let entry = {
+          id: id,
+          name: var_name,
+          value: var_value
+        }
+        ansiblePlaybook.groups[group_name].push(entry);
+        id += 1;
+      });
+    });
+  }
+
+  return ansiblePlaybook;
+}

data/webpack/components/ApplicationDefinition/ApplicationDefinitionReducer.js

@@ -0,0 +1,243 @@
+import Immutable from 'seamless-immutable';
+
+import {
+  cloneDeep,
+  findIndex,
+  findLastIndex,
+} from 'lodash';
+
+import {
+  APPLICATION_DEFINITION_INIT,
+  APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_REQUEST,
+  APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_SUCCESS,
+  APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_FAILURE,
+  APPLICATION_DEFINITION_SERVICE_DELETE,
+  APPLICATION_DEFINITION_SERVICE_ADD,
+  APPLICATION_DEFINITION_SERVICE_EDIT_ACTIVATE,
+  APPLICATION_DEFINITION_SERVICE_EDIT_CONFIRM,
+  APPLICATION_DEFINITION_SERVICE_EDIT_CHANGE,
+  APPLICATION_DEFINITION_SERVICE_EDIT_CANCEL,
+  APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_OPEN,
+  APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_CLOSE,
+  APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_OPEN,
+  APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_CLOSE,
+} from './ApplicationDefinitionConstants';
+
+import {
+  PARAMETER_SELECTION_PARAM_TYPE_FOREMAN,
+  PARAMETER_SELECTION_PARAM_TYPE_ANSIBLE,
+} from '../ParameterSelection/ParameterSelectionConstants';
+
+import {
+  transformAnsiblePlaybook,
+} from './ApplicationDefinitionHelper';
+
+export const initialState = Immutable({
+  name: false,
+  error: { errorMsg: '', status: '', statusText: '' },
+});
+
+const applicationDefinitionConf = (state = initialState, action) => {
+  const { payload } = action;
+
+  switch (action.type) {
+    case APPLICATION_DEFINITION_INIT: {
+      return state.merge(payload);
+    }
+
+   case APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_FAILURE: {
+      return state.merge({ error: payload.error, loading: false });
+    }
+    case APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_REQUEST: {
+      return state.set('loading', true);
+    }
+    case APPLICATION_DEFINITION_LOAD_ANSIBLE_DATA_SUCCESS: {
+      let newState = {};
+      let allVars = [];
+
+      const ansiblePlaybook = transformAnsiblePlaybook(payload);
+
+      if (ansiblePlaybook.hasOwnProperty('groups')) {
+        allVars = ansiblePlaybook.groups['all']
+      }
+
+      newState = {
+        ansiblePlaybook: ansiblePlaybook,
+        ansibleVarsAll: allVars
+      }
+
+      return state.merge(newState);
+    }
+    case APPLICATION_DEFINITION_SERVICE_ADD: {
+      let services = [];
+      let index = 1;
+
+      if ('services' in state && state.services !== undefined && state.services.length > 0) {
+        services = cloneDeep(state.services);
+        index = Math.max(...services.map(e => e.id)) + 1;
+      }
+
+      const newRow = { id: index, name: "", description: '', hostgroup: '',
+                       ansibleGroup: '', minCount: '', maxCount: '',
+                       foremanParameters: [], ansibleParameters: [], newEntry: true };
+      newRow.backup = cloneDeep(newRow)
+      services.push(newRow);
+
+      return state.merge({
+        editMode: true,
+        services: services
+      });
+    }
+    case APPLICATION_DEFINITION_SERVICE_DELETE: {
+      const services = state.services.filter(v => v.id !== payload.rowData.id);
+      return state.merge({
+        services: services,
+      })
+    }
+    case APPLICATION_DEFINITION_SERVICE_EDIT_ACTIVATE: {
+      const services = cloneDeep(state.services);
+      const index = findIndex(services, { id: payload.rowData.id });
+
+      services[index].backup = cloneDeep(services[index]);
+
+      return state.merge({
+        editMode: true,
+        services: services
+      });
+    }
+    case APPLICATION_DEFINITION_SERVICE_EDIT_CONFIRM: {
+      const services = cloneDeep(state.services);
+      const index = findIndex(services, { id: payload.rowData.id });
+
+      delete services[index].backup;
+      delete services[index].newEntry;
+
+      let ansibleParameters = [];
+      const selectedGroup = services[index].ansibleGroup;
+
+      if (selectedGroup) {
+        services[index].ansibleParameters = state.ansiblePlaybook.groups[selectedGroup];
+      }
+
+      return state.merge({
+        editMode: false,
+        services: services,
+      });
+    }
+    case APPLICATION_DEFINITION_SERVICE_EDIT_CHANGE: {
+      const services = cloneDeep(state.services);
+      const index = findIndex(services, { id: payload.rowData.id });
+
+      services[index][payload.property] = payload.value;
+
+      return state.set('services', services);
+    }
+    case APPLICATION_DEFINITION_SERVICE_EDIT_CANCEL: {
+      const services = cloneDeep(state.services);
+      const index = findIndex(services, { id: payload.rowData.id });
+
+      services[index] = cloneDeep(services[index].backup);
+      delete services[index].backup;
+
+      if (services[index].newEntry === true) {
+        services.splice(index, 1);
+      }
+
+      return state.merge({
+        editMode: false,
+        services: services
+      });
+    }
+    case APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_OPEN: {
+      let parametersData = {};
+
+      parametersData.paramDefinition = {
+        id: payload.rowData.id,
+        name: payload.rowData.name,
+        dataId: payload.rowData.hostgroup
+      }
+
+      parametersData.type = PARAMETER_SELECTION_PARAM_TYPE_FOREMAN;
+      parametersData.parameters = payload.rowData.foremanParameters;
+      parametersData.useDefaultValue = true;
+      parametersData.allowRowAdjustment = true;
+      parametersData.allowNameAdjustment = true;
+      parametersData.allowDescriptionAdjustment = true;
+
+      return state.merge({
+        parametersData: parametersData,
+      });
+    }
+    case APPLICATION_DEFINITION_FOREMAN_PARAMETER_SELECTION_MODAL_CLOSE: {
+      if (payload.mode == 'save') {
+        const services = cloneDeep(state.services);
+        const index = findIndex(services, { id: state.parametersData.paramDefinition.id });
+        services[index].foremanParameters = cloneDeep(payload.parameterSelection);
+
+        return state.merge({
+          parametersData: null,
+          services: services,
+        });
+      } else {
+        return state.merge({
+          parametersData: null,
+        });
+      }
+    }
+    case APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_OPEN: {
+      let parametersData = {};
+
+      if ((payload.hasOwnProperty('isAllGroup')) && (payload.isAllGroup == true)) {
+        parametersData.parameters = state.ansibleVarsAll;
+        parametersData.paramDefinition = {
+          isAllGroup: true,
+        }
+      } else  {
+        parametersData.parameters = payload.rowData.ansibleParameters;
+        parametersData.paramDefinition = {
+          id: payload.rowData.id,
+          name: payload.rowData.name,
+        }
+      }
+
+      parametersData.type = PARAMETER_SELECTION_PARAM_TYPE_ANSIBLE;
+      parametersData.useDefaultValue = false;
+      parametersData.allowRowAdjustment = true;
+      parametersData.allowNameAdjustment = true;
+      parametersData.allowDescriptionAdjustment = true;
+
+      return state.merge({
+        parametersData: parametersData,
+      });
+    }
+    case APPLICATION_DEFINITION_ANSIBLE_PARAMETER_SELECTION_MODAL_CLOSE: {
+      let newState = {};
+      if (payload.mode == 'save') {
+        if ((state.parametersData.paramDefinition.hasOwnProperty('isAllGroup')) && (state.parametersData.paramDefinition.isAllGroup == true)) {
+          newState = {
+            parametersData: null,
+            ansibleVarsAll: cloneDeep(payload.parameterSelection),
+          };
+        } else {
+          const services = cloneDeep(state.services);
+          const index = findIndex(services, { id: state.parametersData.paramDefinition.id });
+          services[index].ansibleParameters = cloneDeep(payload.parameterSelection);
+
+          newState = {
+            parametersData: null,
+            services: services,
+          };
+        }
+      } else {
+        newState = {
+          parametersData: null,
+        };
+      }
+      return state.merge(newState);
+    }
+    default:
+      return state;
+  }
+};
+
+export default applicationDefinitionConf;