foreman_acd 0.0.6 → 0.6.0

data/webpack/components/ApplicationInstanceReport/ApplicationInstanceReportSelectors.js

@@ -0,0 +1,4 @@
+const applicationInstanceReport = state => state.foremanAcd.applicationInstanceReport;
+
+export const selectHosts = state => applicationInstanceReport(state).hosts;
+export const selectActiveHostId = state => applicationInstanceReport(state).activeHostId;

data/webpack/components/ApplicationInstanceReport/components/ReportViewer.js

@@ -0,0 +1,26 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+const ReportViewer= ({
+  hidden,
+  report,
+}) =>{
+  if (hidden) {
+    return null;
+  }
+
+  if (report === undefined) {
+    return null;
+  }
+
+  return report.map((task, id) => (
+    <div key={"report_task_"+id} className="report_task">{task.name} -- {task.status}</div>
+  ));
+};
+
+ReportViewer.propTypes = {
+  hidden: PropTypes.bool,
+  report: PropTypes.array,
+};
+
+export default ReportViewer;

data/webpack/components/ApplicationInstanceReport/index.js

@@ -0,0 +1,25 @@
+import { bindActionCreators } from 'redux';
+import { connect } from 'react-redux';
+
+import './ApplicationInstanceReport.scss';
+import ApplicationInstanceReport from './ApplicationInstanceReport';
+import * as ApplicationInstanceReportActions from './ApplicationInstanceReportActions';
+
+import {
+  selectHosts,
+  selectActiveHostId,
+} from './ApplicationInstanceReportSelectors';
+
+const mapStateToProps = state => ({
+  hosts: selectHosts(state),
+  activeHostId: selectActiveHostId(state),
+});
+
+const mapDispatchToProps = dispatch =>
+  bindActionCreators(ApplicationInstanceReportActions, dispatch);
+
+export default connect(
+  mapStateToProps,
+  mapDispatchToProps
+)(ApplicationInstanceReport);
+

data/webpack/components/ParameterSelection/ParameterSelection.js

@@ -5,14 +5,13 @@ import * as sort from 'sortabular';
 import { orderBy } from 'lodash';
 import * as resolve from 'table-resolver';
 import Select from 'foremanReact/components/common/forms/Select';
+import AddTableEntry from '../common/AddTableEntry';
+import EditTableEntry from '../common/EditTableEntry';
+import DeleteTableEntry from '../common/DeleteTableEntry';
+import LockTableEntry from '../common/LockTableEntry';
+import ExtSelect from '../common/ExtSelect';
 
 import {
-  isNewDefinition,
-  isEditDefinition,
-  isDefinition,
-  isNewInstance,
-  isEditInstance,
-  isInstance,
   transformForemanData,
 } from './ParameterSelectionHelper';
 
@@ -22,9 +21,10 @@ import {
   cloneDeep,
 } from 'lodash';
 
-
 import {
-  PARAMETER_TYPES,
+  PARAMETER_SELECTION_TYPES,
+  PARAMETER_SELECTION_PARAM_TYPE_FOREMAN,
+  PARAMETER_SELECTION_PARAM_TYPE_ANSIBLE,
 } from './ParameterSelectionConstants';
 
 import {
@@ -43,86 +43,12 @@ const theme = {
   base00: 'rgba(0, 0, 0, 0)',
 };
 
-
 class ParameterSelection extends React.Component {
 
   constructor(props) {
     super(props);
   }
 
-  renderAddButton(mode, addParameter) {
-    if (isInstance(mode))
-      return null;
-
-    return (
-      <Button bsStyle="default" disabled={ this.props.editMode || this.props.hostgroupId <= 0 } onClick={() => addParameter()}>
-        <Icon type="fa" name="plus" />
-      </Button>
-    );
-  }
-
-  renderDeleteButton(mode, deleteParameter, additionalData, disabled=false) {
-    if (isInstance(mode))
-      return null;
-
-    return (
-      <span>
-      &nbsp;
-      <Button
-        bsStyle="default"
-        disabled={disabled}
-        onClick={() => window.confirm("Are you sure you wish to delete this item?") && deleteParameter(additionalData) }
-      >
-        <Icon type="pf" name="delete" />
-      </Button>
-      </span>
-    );
-  }
-
-  renderSelectApplication(applications, url, loadParameterSelection, appDefinition) {
-    return (
-      <Select
-         value={appDefinition.id.toString()}
-         onChange={e => loadParameterSelection(url, e.target.value) }
-         options={applications}
-         allowClear
-         key="key"
-      />
-    );
-  }
-
-  renderSelectHostgroup(hostgroups, url, loadForemanData, hostgroupId) {
-    return (
-      <Select
-         value={hostgroupId.toString()}
-         onChange={e => loadForemanData(url, e.target.value, true) }
-         options={hostgroups}
-         allowClear
-         key="key"
-      />
-    );
-  }
-
-  renderRailsInputHidden(view, parameter, value) {
-    var id = "foreman_acd_"+ view +"_"+ parameter;
-    var name = "foreman_acd_"+ view +"["+ parameter +"]";
-
-    return (
-      <input
-        id={id}
-        name={name}
-        value={value}
-        type="hidden"
-      />
-    );
-  }
-
-  renderShowDivText(text) {
-    return (
-      <div>{text}</div>
-    );
-  }
-
   isEditing({rowData}) {
     return (rowData.backup !== undefined);
   }
@@ -130,52 +56,79 @@ class ParameterSelection extends React.Component {
   // enables our custom header formatters extensions to reactabular
   customHeaderFormatters = customHeaderFormattersDefinition;
 
-  validateRows() {
-    var result = (this.props.rows.map(e => e.value).filter(i => i == "").length == 0);
-    if (result === false) {
-      window.alert("All parameters need to have a value!");
-    }
-    return result;
-  }
-
   componentDidMount() {
     const {
-      data: { mode, appDefinition, location, organization, loadForemanDataUrl, parameters },
+      data: { useDefaultValue, allowRowAdjustment, allowNameAdjustment, allowDescriptionAdjustment, parameters, paramDefinition },
+      location,
+      organization,
+      paramType,
+      paramDataUrl,
       initParameterSelection,
       sortParameter,
       deleteParameter,
+      lockParameter,
       activateEditParameter,
       changeEditParameter,
-      loadForemanData,
+      loadParamData,
     } = this.props;
 
-    if (isEditDefinition(mode) || isEditInstance(mode)) {
-       loadForemanData(loadForemanDataUrl, appDefinition.hostgroup_id);
-    }
-
-    if (isInstance(mode)) {
-      $('input[type="submit"][name="commit"]').on('click', () => this.validateRows());
+    if (paramDataUrl !== undefined) {
+      switch (paramType) {
+        case PARAMETER_SELECTION_PARAM_TYPE_FOREMAN: {
+          loadParamData({ paramDefinition: paramDefinition, url: paramDataUrl, dataType: paramType, clearParameters: false });
+          break;
+        }
+        default: { }
+      }
     }
 
     const inlineEditButtonsFormatter = inlineEditFormatterFactory({
       isEditing: additionalData => this.props.editMode,
       renderValue: (value, additionalData) => (
         <td style={{ padding: '2px' }}>
-          <Button
-            bsStyle="default"
-            onClick={() => activateEditParameter(additionalData)}
-          >
-            <Icon type="pf" name="edit" />
-          </Button>
-          {this.renderDeleteButton(mode, deleteParameter, additionalData)}
+          <EditTableEntry
+            disabled={false}
+            handleLocking={!allowRowAdjustment}
+            onEditTableEntry={() => activateEditParameter(additionalData)}
+            additionalData={additionalData}
+          />
+          &nbsp;
+          <LockTableEntry
+            hidden={!allowRowAdjustment}
+            disabled={!allowRowAdjustment}
+            onLockTableEntry={lockParameter}
+            additionalData={additionalData}
+          />
+          &nbsp;
+          <DeleteTableEntry
+            hidden={!allowRowAdjustment}
+            disabled={false}
+            onDeleteTableEntry={deleteParameter}
+            additionalData={additionalData}
+          />
         </td>
       ),
       renderEdit: (value, additionalData) => (
         <td style={{ padding: '2px' }}>
-          <Button bsStyle="default" disabled>
-            <Icon type="pf" name="edit" />
-          </Button>
-          {this.renderDeleteButton(mode, deleteParameter, additionalData, true)}
+          <EditTableEntry
+            disabled={true}
+            onEditTableEntry={() => activateEditParameter(additionalData)}
+            additionalData={additionalData}
+          />
+          &nbsp;
+          <LockTableEntry
+            hidden={!allowRowAdjustment}
+            disabled={true}
+            onLockTableEntry={lockParameter}
+            additionalData={additionalData}
+          />
+          &nbsp;
+          <DeleteTableEntry
+            hidden={!allowRowAdjustment}
+            disabled={true}
+            onDeleteTableEntry={deleteParameter}
+            additionalData={additionalData}
+          />
         </td>
       )
     });
@@ -225,28 +178,36 @@ class ParameterSelection extends React.Component {
       ),
     };
 
+    // TODO: should we differentiate between paramType FOREMAN and ANSIBLE?
+
     const inlineEditFormatter = inlineEditFormatterFactory({
       isEditing: additionalData => this.isEditing(additionalData),
       renderValue: (value, additionalData) => {
-        var prettyValue = value;
+        let prettyValue = value;
         if (additionalData.property == 'type') {
-          prettyValue = PARAMETER_TYPES[value];
+          prettyValue = PARAMETER_SELECTION_TYPES[value];
         } else if (additionalData.property == 'value') {
           switch (additionalData.rowData.type) {
             case 'computeprofile':
-              prettyValue = transformForemanData(this.props.foremanData['computeprofiles'])[value]
+              prettyValue = transformForemanData(this.props.paramData['computeprofiles'])[value]
               break;
             case 'domain':
-              prettyValue = transformForemanData(this.props.foremanData['domains'])[value]
+              prettyValue = transformForemanData(this.props.paramData['domains'])[value]
               break;
             case 'lifecycleenv':
-              prettyValue = transformForemanData(this.props.foremanData['lifecycle_environments'])[value]
+              prettyValue = transformForemanData(this.props.paramData['lifecycle_environments'])[value]
               break;
             case 'ptable':
-              prettyValue = transformForemanData(this.props.foremanData['ptables'])[value]
+              prettyValue = transformForemanData(this.props.paramData['ptables'])[value]
+              break;
+            case 'password':
+              prettyValue = '****************'
               break;
             case 'puppetenv':
-              prettyValue = transformForemanData(this.props.foremanData['environments'])[value]
+              prettyValue = transformForemanData(this.props.paramData['environments'])[value]
+              break;
+            case 'text':
+              prettyValue = value
               break;
           }
         }
@@ -258,19 +219,21 @@ class ParameterSelection extends React.Component {
             if (additionalData.rowData.newEntry === true) {
               return inlineEditFormatterImpl.renderEditSelect(value, additionalData, this.props.parameterTypes);
             }
-            return inlineEditFormatterImpl.renderValue(PARAMETER_TYPES[value], additionalData)
+            return inlineEditFormatterImpl.renderValue(PARAMETER_SELECTION_TYPES[value], additionalData)
           case 'value':
             switch (additionalData.rowData.type) {
               case 'computeprofile':
-                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.foremanData['computeprofiles']));
+                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.paramData['computeprofiles']));
               case 'domain':
-                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.foremanData['domains']));
+                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.paramData['domains']));
               case 'lifecycleenv':
-                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.foremanData['lifecycle_environments']));
+                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.paramData['lifecycle_environments']));
               case 'puppetenv':
-                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.foremanData['environments']));
+                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.paramData['environments']));
               case 'ptable':
-                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.foremanData['ptables']));
+                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.paramData['ptables']));
+              case 'password':
+                return inlineEditFormatterImpl.renderEditText(value, additionalData, 'password');
               case 'text':
               default:
                 return inlineEditFormatterImpl.renderEditText(value, additionalData);
@@ -283,9 +246,12 @@ class ParameterSelection extends React.Component {
     this.inlineEditFormatter = inlineEditFormatter;
 
     initParameterSelection(
-      mode,
-      appDefinition,
+      paramType,
+      paramDefinition,
       parameters,
+      useDefaultValue,
+      allowNameAdjustment,
+      allowDescriptionAdjustment,
       this.sortingFormatter,
       this.sortableTransform,
       this.inlineEditFormatter,
@@ -298,84 +264,58 @@ class ParameterSelection extends React.Component {
 
   render() {
     const {
-      data: { mode, applications, hostgroups, loadParameterSelectionUrl, loadForemanDataUrl },
-      rows,
+      data: { allowRowAdjustment, applications },
+      location,
+      organization,
+      parameters,
       columns,
       sortingColumns,
       loading,
       addParameter,
       confirmEditParameter,
       cancelEditParameter,
-      loadParameterSelection,
-      loadForemanData,
-      appDefinition,
-      hostgroupId,
+      editModeCallback,
     } = this.props;
 
-    var sortedRows;
-    var newEntryIndex = findIndex(rows, 'newEntry');
+    let sortedParameters;
+    const newEntryIndex = findIndex(parameters, 'newEntry');
 
     if (newEntryIndex >= 0) {
-      let newEntry = rows[newEntryIndex];
+      const newEntry = parameters[newEntryIndex];
       // sort all elements, besides the newEntry which will be
       // added to the end of the Array
-      var tmpRows = cloneDeep(rows);
-      tmpRows.splice(newEntryIndex, 1);
-      sortedRows = this.compose(
+      const tmpParameters = cloneDeep(parameters);
+      tmpParameters.splice(newEntryIndex, 1);
+      sortedParameters = this.compose(
         sort.sorter({
           columns,
           sortingColumns,
           sort: orderBy,
           strategy: sort.strategies.byProperty
         })
-      )(tmpRows);
-      sortedRows.push(newEntry);
+      )(tmpParameters);
+      sortedParameters.push(newEntry);
     } else {
-      sortedRows = this.compose(
+      sortedParameters = this.compose(
         sort.sorter({
           columns,
           sortingColumns,
           sort: orderBy,
           strategy: sort.strategies.byProperty
         })
-      )(rows);
+      )(parameters);
+    }
+
+    // Make sure that the component which includes the
+    // ParameterSelection is aware of the current editMode state
+    if (editModeCallback !== undefined) {
+      editModeCallback(this.props.editMode);
     }
 
     return(
       <div>
-        {isDefinition(mode) ? (
-        <div className="clearfix">
-          <div className="form-group">
-            <label className="col-md-2 control-label">Host Group</label>
-            <div className="col-md-4">
-              {isNewDefinition(mode) && this.renderSelectHostgroup(hostgroups, loadForemanDataUrl, loadForemanData, hostgroupId) }
-              {isEditDefinition(mode) && this.renderShowDivText(hostgroups[hostgroupId]) }
-              {this.renderRailsInputHidden('app_definition', 'hostgroup_id', hostgroupId) }
-            </div>
-          </div>
-        </div>
-        ) : (
-        <div className="clearfix">
-          <div className="form-group">
-            <label className="col-md-2 control-label">Application Definition</label>
-            <div className="col-md-4">
-              {isNewInstance(mode) && this.renderSelectApplication(applications, loadParameterSelectionUrl, loadParameterSelection, appDefinition)}
-              {isEditInstance(mode) && this.renderShowDivText(appDefinition.name)}
-              {isInstance(mode) && this.renderRailsInputHidden('app_instance', 'app_definition_id', appDefinition.id)}
-            </div>
-          </div>
-        </div>
-        )}
-        <div className="clearfix">
-          <div className="form-group">
-            <label className="col-md-1 control-label">Application parameters</label>
-            <div className="col-md-5">&nbsp;</div>
-          </div>
-        </div>
-
         <div className="clearfix">
           <div className="form-group">
-            {this.renderAddButton(mode, addParameter)}
             <Table.PfProvider
               striped
               bordered
@@ -400,20 +340,23 @@ class ParameterSelection extends React.Component {
             >
               <Table.Header headerRows={resolve.headerRows({ columns })} />
               <Table.Body
-                rows={sortedRows}
+                rows={sortedParameters}
                 rowKey="id"
                 onRow={(rowData, { rowIndex }) => ({
                   role: 'row',
                   isEditing: () => this.isEditing({ rowData }),
                   onCancel: () => cancelEditParameter({ rowData, rowIndex }),
                   onConfirm: () => confirmEditParameter({ rowData, rowIndex }),
-                  last: rowIndex === sortedRows.length - 1
+                  last: rowIndex === sortedParameters.length - 1
                 })}
               />
             </Table.PfProvider>
-            {this.renderAddButton(mode, addParameter)}
+            <AddTableEntry
+               hidden={!allowRowAdjustment}
+               disabled={ this.props.editMode }
+               onAddTableEntry={ addParameter }
+            />
           </div>
-          {this.renderRailsInputHidden(isDefinition(mode) ? 'app_definition' : 'app_instance', 'parameters', JSON.stringify(this.props.rows))}
         </div>
       </div>
     );
@@ -424,45 +367,41 @@ ParameterSelection.defaultProps = {
   error: {},
   editMode: false,
   loading: false,
-  foremanData: {},
-  rows: [],
+  paramData: {},
+  parameters: [],
   columns: [],
   sortingColumns: {},
-  appDefinition: { "id": '', "name": '', "hostgroup_id": '', "parameters": [] },
-  hostgroupId: -1,
+  editModeCallback: undefined,
 };
 
 ParameterSelection.propTypes = {
   data: PropTypes.shape({
-    mode: PropTypes.string.isRequired,
-    location: PropTypes.string.isRequired,
-    organization: PropTypes.string.isRequired,
     parameters: PropTypes.array,
-    appDefinition: PropTypes.object,
+    paramDefinition: PropTypes.object,
     applications: PropTypes.object,
-    hostgroups: PropTypes.object,
-    loadParameterSelectionUrl: PropTypes.string,
-    loadForemanDataUrl: PropTypes.string,
   }).isRequired,
+  location: PropTypes.string.isRequired,
+  organization: PropTypes.string.isRequired,
+  paramDataUrl: PropTypes.string,
   initParameterSelection: PropTypes.func,
   editMode: PropTypes.bool.isRequired,
   loading: PropTypes.bool.isRequired,
-  foremanData: PropTypes.object.isRequired,
+  paramData: PropTypes.object.isRequired,
   parameterTypes: PropTypes.object,
-  rows: PropTypes.array,
+  parameters: PropTypes.array,
   sortingColumns: PropTypes.object,
+  editModeCallback: PropTypes.func,
   columns: PropTypes.array,
   sortParameter: PropTypes.func,
   addParameter: PropTypes.func,
   deleteParameter: PropTypes.func,
+  lockParameter: PropTypes.func,
   activateEditParameter: PropTypes.func,
   confirmEditParameter: PropTypes.func,
   cancelEditParameter: PropTypes.func,
   changeEditParameter: PropTypes.func,
-  loadParameterSelection: PropTypes.func,
-  loadForemanData: PropTypes.func,
-  appDefinition: PropTypes.object,
-  hostgroupId: PropTypes.number,
+  loadParamData: PropTypes.func,
+  paramDefinition: PropTypes.object,
 };
 
 export default ParameterSelection;