foreman_acd 0.0.6 → 0.2.1

data/db/migrate/20190625140305_create_app_instances.rb

@@ -7,7 +7,7 @@ class CreateAppInstances < ActiveRecord::Migration[5.2]
       t.string :name, :default => '', :null => false, :limit => 255, :unique => true
       t.column :app_definition_id, :integer, :null => false
       t.text :description
-      t.text :parameters
+      t.text :hosts
       t.timestamps :null => true
     end
     add_foreign_key :app_instances, :app_definitions

data/lib/foreman_acd/plugin.rb

@@ -39,6 +39,16 @@ Foreman::Plugin.register :foreman_acd do
                  :'foreman_acd/api/v2/app_definitions' => [:destroy] },
                :resource_type => 'ForemanAcd::AppDefinition'
 
+    permission :export_app_definitions,
+               { :'foreman_acd/app_definitions' => [:export],
+                 :'foreman_acd/api/v2/app_definitions' => [:export] },
+               :resource_type => 'ForemanAcd::AppDefinition'
+
+    permission :import_app_definitions,
+               { :'foreman_acd/app_definitions' => [:import],
+                 :'foreman_acd/api/v2/app_definitions' => [:import] },
+               :resource_type => 'ForemanAcd::AppDefinition'
+
     permission :create_app_instances,
                { :'foreman_acd/app_instances' => [:new, :create],
                  :'foreman_acd/api/v2/app_instances' => [:create] },
@@ -63,18 +73,25 @@ Foreman::Plugin.register :foreman_acd do
                { :'foreman_acd/app_instances' => [:deploy],
                  :'foreman_acd/api/v2/app_instances' => [:deploy] },
                :resource_type => 'ForemanAcd::AppInstance'
+
+    permission :report_app_instances,
+               { :'foreman_acd/app_instances' => [:report],
+                 :'foreman_acd/api/v2/app_instances' => [:report] },
+               :resource_type => 'ForemanAcd::AppInstance'
   end
 
   # Manager Role
   role 'Application Centric Deployment Manager', [:create_app_definitions,
                                                   :view_app_definitions,
                                                   :edit_app_definitions,
-                                                  :destroy_app_definitions]
+                                                  :export_app_definitions,
+                                                  :import_app_definitions]
 
   # User Role
   role 'Application Centric Deployment User', [:create_app_instances,
                                                :view_app_instances,
                                                :edit_app_instances,
                                                :destroy_app_instances,
-                                               :deploy_app_instances]
+                                               :deploy_app_instances,
+                                               :report_app_instances]
 end

data/lib/foreman_acd/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ForemanAcd
-  VERSION = '0.0.6'
+  VERSION = '0.2.1'
 end

data/webpack/components/ApplicationDefinition/ApplicationDefinition.js

@@ -0,0 +1,261 @@
+import React, { useState } from 'react'
+import PropTypes from 'prop-types';
+import {
+  Icon,
+  Button,
+} from 'patternfly-react';
+import * as resolve from 'table-resolver';
+import ForemanModal from 'foremanReact/components/ForemanModal';
+import Select from 'foremanReact/components/common/forms/Select';
+import ParameterSelection from '../ParameterSelection';
+import AddTableEntry from '../common/AddTableEntry';
+import DeleteTableEntry from '../common/DeleteTableEntry';
+import RailsData from '../common/RailsData'
+
+import {
+  Table,
+  FormControl,
+  inlineEditFormatterFactory,
+} from 'patternfly-react';
+
+class ApplicationDefinition extends React.Component {
+
+  constructor(props) {
+    super(props);
+  }
+
+  isEditing({rowData}) {
+    return (rowData.backup !== undefined);
+  }
+
+  componentDidMount() {
+    const {
+      data: { services, hostgroups },
+      initApplicationDefinition,
+      addApplicationDefinitionService,
+      deleteApplicationDefinitionService,
+      activateEditApplicationDefinitionService,
+      changeEditApplicationDefinitionService,
+      openParameterSelectionModal,
+      closeParameterSelectionModal,
+    } = this.props;
+
+    const inlineEditButtonsFormatter = inlineEditFormatterFactory({
+      isEditing: additionalData => this.props.editMode,
+      renderValue: (value, additionalData) => (
+        <td style={{ padding: '2px' }}>
+          <Button
+            bsStyle="default"
+            onClick={() => activateEditApplicationDefinitionService(additionalData)}
+          >
+            <Icon type="pf" name="edit" />
+          </Button>
+          <Button
+            bsStyle="default"
+            onClick={() => openParameterSelectionModal(additionalData)}
+          >
+            <Icon type="pf" name="settings" />
+          </Button>
+          <DeleteTableEntry
+            hidden={false}
+            disabled={false}
+            onDeleteTableEntry={deleteApplicationDefinitionService}
+            additionalData={additionalData}
+          />
+        </td>
+      ),
+      renderEdit: (value, additionalData) => (
+        <td style={{ padding: '2px' }}>
+          <Button bsStyle="default" disabled>
+            <Icon type="pf" name="edit" />
+          </Button>
+          <Button bsStyle="default" disabled>
+            <Icon type="pf" name="settings" />
+          </Button>
+          <DeleteTableEntry
+            hidden={false}
+            disabled={true}
+            onDeleteTableEntry={deleteApplicationDefinitionService}
+            additionalData={additionalData}
+          />
+        </td>
+      )
+    });
+    this.inlineEditButtonsFormatter = inlineEditButtonsFormatter;
+
+    const headerFormatter = value => <Table.Heading>{value}</Table.Heading>;
+    this.headerFormatter = headerFormatter;
+
+    const inlineEditFormatterImpl = {
+      renderValue: (value, additionalData) => (
+        <td>
+          <span className="static">{value}</span>
+        </td>
+      ),
+      renderEditText: (value, additionalData, subtype='text') => (
+        <td className="editing">
+          <FormControl
+            type={subtype}
+            defaultValue={value}
+            onBlur={e => changeEditApplicationDefinitionService(e.target.value, additionalData) }
+          />
+        </td>
+      ),
+      renderEditSelect: (value, additionalData, options) => (
+        <td className="editing">
+          <Select
+            value={value.toString()}
+            onChange={e => changeEditApplicationDefinitionService(e.target.value, additionalData) }
+            options={options}
+            allowClear
+            key="key"
+          />
+        </td>
+      )
+    };
+
+    const inlineEditFormatter = inlineEditFormatterFactory({
+      isEditing: additionalData => this.isEditing(additionalData),
+      renderValue: (value, additionalData) => {
+        let prettyValue = value;
+        if (additionalData.property == 'hostgroup') {
+          prettyValue = hostgroups[value];
+        }
+        return inlineEditFormatterImpl.renderValue(prettyValue, additionalData)
+      },
+      renderEdit: (value, additionalData) => {
+        if (additionalData.property == 'hostgroup') {
+          if (additionalData.rowData.newEntry === true) {
+            return inlineEditFormatterImpl.renderEditSelect(value, additionalData, hostgroups);
+          }
+          return inlineEditFormatterImpl.renderValue(hostgroups[value], additionalData)
+        }
+        return inlineEditFormatterImpl.renderEditText(value, additionalData);
+      }
+    });
+    this.inlineEditFormatter = inlineEditFormatter;
+
+    initApplicationDefinition(
+      services,
+      this.headerFormatter,
+      this.inlineEditFormatter,
+      this.inlineEditButtonsFormatter,
+    );
+  };
+
+  render() {
+    const {
+      data: { organization, location, loadForemanDataUrl },
+      services,
+      columns,
+      addApplicationDefinitionService,
+      confirmEditApplicationDefinitionService,
+      cancelEditApplicationDefinitionService,
+      openParameterSelectionModal,
+      closeParameterSelectionModal,
+      ParameterSelectionModal,
+    } = this.props;
+
+    return (
+      <span>
+        <div className="form-group">
+          <AddTableEntry
+             hidden={ false }
+             disabled={ this.props.editMode }
+             onAddTableEntry={ addApplicationDefinitionService }
+          />
+          <Table.PfProvider
+            striped
+            bordered
+            hover
+            dataTable
+            inlineEdit
+            columns={columns}
+            components={{
+              body: {
+                row: Table.InlineEditRow,
+                cell: cellProps => cellProps.children
+              }
+            }}
+          >
+            <Table.Header headerRows={resolve.headerRows({ columns })} />
+            <Table.Body
+              rows={services}
+              rowKey="id"
+              onRow={(rowData, { rowIndex }) => ({
+                role: 'row',
+                isEditing: () => this.isEditing({ rowData }),
+                onCancel: () => cancelEditApplicationDefinitionService({ rowData, rowIndex }),
+                onConfirm: () => confirmEditApplicationDefinitionService({ rowData, rowIndex }),
+                last: rowIndex === services.length - 1
+              })}
+            />
+          </Table.PfProvider>
+          <AddTableEntry
+             hidden={ false }
+             disabled={ this.props.editMode }
+             onAddTableEntry={ addApplicationDefinitionService }
+          />
+        </div>
+        <div>
+          <ForemanModal
+            id="AppDefinitionParamSelection"
+            dialogClassName="param_selection_modal"
+            title="Parameter definition for Application Definition"
+          >
+            <ForemanModal.Header closeButton={false}>
+              Parameter definition
+            </ForemanModal.Header>
+            {this.props.parametersData ? (
+              <ParameterSelection
+                location={ location }
+                organization={ organization }
+                loadForemanDataUrl= { loadForemanDataUrl }
+                data={ this.props.parametersData }
+              />
+            ) : (<span>Empty</span>)
+            }
+            <ForemanModal.Footer>
+              <div>
+                <Button bsStyle="primary" onClick={() => closeParameterSelectionModal({ mode: 'save' })}>Save</Button>
+                <Button bsStyle="default" onClick={() => closeParameterSelectionModal({ mode: 'cancel' })}>Cancel</Button>
+              </div>
+            </ForemanModal.Footer>
+          </ForemanModal>
+        </div>
+        <RailsData
+          key='applications_definition'
+          view='app_definition'
+          parameter='services'
+          value={JSON.stringify(this.props.services)}
+        />
+      </span>
+    )};
+}
+
+ApplicationDefinition.defaultProps = {
+  error: {},
+  editMode: false,
+  services: [],
+  parametersData: {},
+  columns: [],
+  editParamsOfRowId: null,
+}
+
+ApplicationDefinition.propTypes = {
+  initApplicationDefinition: PropTypes.func,
+  editMode: PropTypes.bool.isRequired,
+  services: PropTypes.array,
+  columns: PropTypes.array,
+  addApplicationDefinitionService: PropTypes.func,
+  deleteApplicationDefinitionService: PropTypes.func,
+  activateEditApplicationDefinitionService: PropTypes.func,
+  confirmEditApplicationDefinitionService: PropTypes.func,
+  cancelEditApplicationDefinitionService: PropTypes.func,
+  changeEditApplicationDefinitionService: PropTypes.func,
+  openParameterSelectionModal: PropTypes.func,
+  closeParameterSelectionModal: PropTypes.func,
+  parametersData: PropTypes.object,
+};
+
+export default ApplicationDefinition;

data/webpack/components/ApplicationDefinition/ApplicationDefinition.scss

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

data/webpack/components/ApplicationDefinition/ApplicationDefinitionActions.js

@@ -0,0 +1,211 @@
+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_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_PARAMETER_SELECTION_MODAL_OPEN,
+  APPLICATION_DEFINITION_PARAMETER_SELECTION_MODAL_CLOSE,
+} from './ApplicationDefinitionConstants';
+
+export const initApplicationDefinition = (
+  services,
+  headerFormatter,
+  inlineEditFormatter,
+  inlineEditButtonsFormatter,
+) => dispatch => {
+  const initialState = {};
+
+  initialState.columns = [
+    {
+      property: 'name',
+      header: {
+        label: 'Name',
+        formatters: [headerFormatter],
+        props: {
+          index: 0,
+          style: {
+            width: '20%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'description',
+      header: {
+        label: 'Description',
+        formatters: [headerFormatter],
+        props: {
+          index: 1,
+          style: {
+            width: '20%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'hostgroup',
+      header: {
+        label: 'Hostgroup',
+        formatters: [headerFormatter],
+        props: {
+          index: 2,
+          style: {
+            width: '20%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'minCount',
+      header: {
+        label: 'min count',
+        formatters: [headerFormatter],
+        props: {
+          index: 3,
+          style: {
+            width: '10%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'maxCount',
+      header: {
+        label: 'max count',
+        formatters: [headerFormatter],
+        props: {
+          index: 3,
+          style: {
+            width: '10%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditFormatter]
+      }
+    },
+    {
+      property: 'actions',
+      header: {
+        label: 'Actions',
+        formatters: [actionHeaderCellFormatter],
+        props: {
+          index: 4,
+          style: {
+            width: '20%'
+          }
+        },
+      },
+      cell: {
+        formatters: [inlineEditButtonsFormatter]
+      }
+    }
+  ];
+
+  initialState.services = services;
+
+  dispatch({
+    type: APPLICATION_DEFINITION_INIT,
+    payload: initialState,
+  });
+};
+
+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 openParameterSelectionModal = (additionalData) => dispatch => {
+  dispatch({
+    type: APPLICATION_DEFINITION_PARAMETER_SELECTION_MODAL_OPEN,
+    payload: {
+      ...additionalData,
+    }
+  });
+  dispatch(
+    setModalOpen({ id: 'AppDefinitionParamSelection' })
+  );
+}
+
+export const closeParameterSelectionModal = (additionalData) => dispatch => {
+  dispatch({
+    type: APPLICATION_DEFINITION_PARAMETER_SELECTION_MODAL_CLOSE,
+    payload: {
+      ...additionalData,
+    }
+  });
+
+  dispatch(
+    setModalClosed({ id: 'AppDefinitionParamSelection' })
+  );
+}