foreman_acd 0.0.1

data/test/controllers/app_definitions_controller_test.rb

@@ -0,0 +1,24 @@
+require 'test_plugin_helper'
+require 'nokogiri'
+
+module ForemanAcd
+  class AppDefinitionsControllerTest < ActionController::TestCase
+    setup do
+      as_admin { FactoryBot.create(:app_definition) }
+      @model = ForemanAcd::AppDefinition.first
+    end
+
+    basic_index_test('app_definitions')
+    basic_new_test
+    basic_edit_test('app_definition')
+
+    test 'should destroy app definition' do
+      assert_difference('AppDefinition.count', -1) do
+      delete :destroy,
+             :params => { :id => @model.id },
+             :session => set_session_user
+      end
+      assert_redirected_to app_definitions_url
+    end
+  end
+end

data/test/controllers/app_instances_controller_test.rb

@@ -0,0 +1,24 @@
+require 'test_plugin_helper'
+require 'nokogiri'
+
+module ForemanAcd
+  class AppInstancesControllerTest < ActionController::TestCase
+    setup do
+      as_admin { FactoryBot.create(:app_instance) }
+      @model = ForemanAcd::AppInstance.first
+    end
+
+    basic_index_test('app_instances')
+    basic_new_test
+    basic_edit_test('app_instance')
+
+    test 'should destroy app instance' do
+      assert_difference('AppInstance.count', -1) do
+      delete :destroy,
+             :params => { :id => @model.id },
+             :session => set_session_user
+      end
+      assert_redirected_to app_instances_url
+    end
+  end
+end

data/test/controllers/ui_acd_controller_test.rb

@@ -0,0 +1,26 @@
+require 'test_plugin_helper'
+require 'nokogiri'
+
+class UiAcdControllerTest < ActionController::TestCase
+  test 'get app json' do
+    app_def = FactoryBot.create(:app_definition)
+    get :app, params: { :id => app_def.id }, session: set_session_user
+    assert_response :success
+
+    assert_equal app_def.name, json_response['app_definition']['name']
+    assert_equal app_def.hostgroup_id, json_response['fdata']['hostgroup_id']
+    assert_equal app_def.hostgroup.domain.name, json_response['fdata']['domains'][0]['name']
+    assert_equal app_def.hostgroup.environment.name, json_response['fdata']['environments'][0]['name']
+    assert_equal app_def.hostgroup.ptable.name, json_response['fdata']['ptables'][0]['name']
+  end
+
+  test 'get fdata json' do
+    hostgroup = FactoryBot.create(:hostgroup, :with_domain, :with_os, :with_environment)
+    get :fdata, params: { :id => hostgroup.id }, session: set_session_user
+    assert_response :success
+
+    assert_equal hostgroup.environment.name, json_response['environments'][0]['name']
+    assert_equal hostgroup.domain.name, json_response['domains'][0]['name']
+    assert_equal hostgroup.ptable.name, json_response['ptables'][0]['name']
+  end
+end

data/test/factories/foreman_acd_factories.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :app_definition, :class => 'ForemanAcd::AppDefinition' do
+    sequence(:name) { |n| "app_definition#{n}" }
+    sequence(:description) {|n| "description#{n}" }
+    hostgroup { FactoryBot.create(:hostgroup, :with_domain, :with_os, :with_environment ) }
+    parameters { "[{\"id\":0,\"name\":\"Hostname\",\"description\":\"\",\"type\":\"hostname\",\"value\":\"mysqllinux\"},{\"id\":1,\"name\":\"RootPW\",\"description\":\"\",\"type\":\"password\",\"value\":\"sesam12345\"},{\"id\":2,\"name\":\"ansible_root\",\"description\":\"\",\"type\":\"hostparam\",\"value\":\"/root/ansible\"}]" }
+  end
+
+  factory :app_instance, :class => 'ForemanAcd::AppInstance' do
+    sequence(:name) { |n| "app_instance#{n}" }
+    app_definition { FactoryBot.create(:app_definition) }
+    sequence(:description) {|n| "description#{n}" }
+    parameters { "[{\"id\":0,\"name\":\"Hostname\",\"description\":\"\",\"type\":\"hostname\",\"value\":\"mysqllinux\"},{\"id\":1,\"name\":\"RootPW\",\"description\":\"\",\"type\":\"password\",\"value\":\"sesam12345\"},{\"id\":2,\"name\":\"ansible_root\",\"description\":\"\",\"type\":\"hostparam\",\"value\":\"/root/ansible\"}]" }
+  end
+end

data/test/models/app_definition_test.rb

@@ -0,0 +1,11 @@
+require 'test_plugin_helper'
+
+module ForemanAcd
+  class AppDefinitionTest < ActiveSupport::TestCase
+    should validate_presence_of(:name)
+    should validate_uniqueness_of(:name)
+    should belong_to(:hostgroup)
+    should have_many(:app_instances).dependent(:destroy)
+
+  end
+end

data/test/models/app_instance_test.rb

@@ -0,0 +1,8 @@
+require 'test_plugin_helper'
+
+module ForemanAcd
+  class AppInstanceTest < ActiveSupport::TestCase
+    should validate_presence_of(:name)
+    should belong_to(:app_definition)
+  end
+end

data/test/test_plugin_helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This calls the main test_helper in Foreman-core
+require 'test_helper'
+
+# Add plugin to FactoryBot's paths
+FactoryBot.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
+FactoryBot.reload

data/webpack/__mocks__/foremanReact/components/common/forms/Select.js

@@ -0,0 +1,2 @@
+const Select = () => jest.fn();
+export default Select;

data/webpack/components/ParameterSelection/ParameterSelection.js

@@ -0,0 +1,468 @@
+import $ from 'jquery';
+import React from 'react';
+import PropTypes from 'prop-types';
+import * as sort from 'sortabular';
+import { orderBy } from 'lodash';
+import * as resolve from 'table-resolver';
+import Select from 'foremanReact/components/common/forms/Select';
+
+import {
+  isNewDefinition,
+  isEditDefinition,
+  isDefinition,
+  isNewInstance,
+  isEditInstance,
+  isInstance,
+  transformForemanData,
+} from './ParameterSelectionHelper';
+
+import {
+  dropRight,
+  findIndex,
+  cloneDeep,
+} from 'lodash';
+
+
+import {
+  PARAMETER_TYPES,
+} from './ParameterSelectionConstants';
+
+import {
+  Icon,
+  Button,
+  Table,
+  FormControl,
+  defaultSortingOrder,
+  customHeaderFormattersDefinition,
+  inlineEditFormatterFactory,
+} from 'patternfly-react';
+
+const theme = {
+  scheme: 'foreman',
+  backgroundColor: 'rgba(0, 0, 0, 255)',
+  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);
+  }
+
+  // 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 },
+      initParameterSelection,
+      sortParameter,
+      deleteParameter,
+      activateEditParameter,
+      changeEditParameter,
+      loadForemanData,
+    } = this.props;
+
+    if (isEditDefinition(mode) || isEditInstance(mode)) {
+       loadForemanData(loadForemanDataUrl, appDefinition.hostgroup_id);
+    }
+
+    if (isInstance(mode)) {
+      $('input[type="submit"][name="commit"]').on('click', () => this.validateRows());
+    }
+
+    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)}
+        </td>
+      ),
+      renderEdit: (value, additionalData) => (
+        <td style={{ padding: '2px' }}>
+          <Button bsStyle="default" disabled>
+            <Icon type="pf" name="edit" />
+          </Button>
+          {this.renderDeleteButton(mode, deleteParameter, additionalData, true)}
+        </td>
+      )
+    });
+    this.inlineEditButtonsFormatter = inlineEditButtonsFormatter;
+
+    const getSortingColumns = () => this.props.sortingColumns || {};
+
+    const sortableTransform = sort.sort({
+      getSortingColumns,
+      onSort: (selectedColumn, defaultSortingOrder) => sortParameter(selectedColumn, defaultSortingOrder),
+      strategy: sort.strategies.byProperty,
+    });
+    this.sortableTransform = sortableTransform;
+
+    const sortingFormatter = sort.header({
+      sortableTransform,
+      getSortingColumns,
+      strategy: sort.strategies.byProperty,
+    });
+    this.sortingFormatter = sortingFormatter;
+
+    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 => changeEditParameter(e.target.value, additionalData) }
+          />
+        </td>
+      ),
+      renderEditSelect: (value, additionalData, options) => (
+        <td className="editing">
+          <Select
+            value={value.toString()}
+            onChange={e => changeEditParameter(e.target.value, additionalData) }
+            options={options}
+            allowClear
+            key="key"
+          />
+        </td>
+      ),
+    };
+
+    const inlineEditFormatter = inlineEditFormatterFactory({
+      isEditing: additionalData => this.isEditing(additionalData),
+      renderValue: (value, additionalData) => {
+        var prettyValue = value;
+        if (additionalData.property == 'type') {
+          prettyValue = PARAMETER_TYPES[value];
+        } else if (additionalData.property == 'value') {
+          switch (additionalData.rowData.type) {
+            case 'computeprofile':
+              prettyValue = transformForemanData(this.props.foremanData['computeprofiles'])[value]
+              break;
+            case 'domain':
+              prettyValue = transformForemanData(this.props.foremanData['domains'])[value]
+              break;
+            case 'lifecycleenv':
+              prettyValue = transformForemanData(this.props.foremanData['lifecycle_environments'])[value]
+              break;
+            case 'ptable':
+              prettyValue = transformForemanData(this.props.foremanData['ptables'])[value]
+              break;
+            case 'puppetenv':
+              prettyValue = transformForemanData(this.props.foremanData['environments'])[value]
+              break;
+          }
+        }
+        return inlineEditFormatterImpl.renderValue(prettyValue, additionalData)
+      },
+      renderEdit: (value, additionalData) => {
+        switch (additionalData.property) {
+          case 'type':
+            if (additionalData.rowData.newEntry === true) {
+              return inlineEditFormatterImpl.renderEditSelect(value, additionalData, this.props.parameterTypes);
+            }
+            return inlineEditFormatterImpl.renderValue(PARAMETER_TYPES[value], additionalData)
+          case 'value':
+            switch (additionalData.rowData.type) {
+              case 'computeprofile':
+                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.foremanData['computeprofiles']));
+              case 'domain':
+                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.foremanData['domains']));
+              case 'lifecycleenv':
+                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.foremanData['lifecycle_environments']));
+              case 'puppetenv':
+                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.foremanData['environments']));
+              case 'ptable':
+                return inlineEditFormatterImpl.renderEditSelect(value, additionalData, transformForemanData(this.props.foremanData['ptables']));
+              case 'text':
+              default:
+                return inlineEditFormatterImpl.renderEditText(value, additionalData);
+            }
+          default:
+            return inlineEditFormatterImpl.renderEditText(value, additionalData)
+        }
+      }
+    });
+    this.inlineEditFormatter = inlineEditFormatter;
+
+    initParameterSelection(
+      mode,
+      appDefinition,
+      parameters,
+      this.sortingFormatter,
+      this.sortableTransform,
+      this.inlineEditFormatter,
+      this.inlineEditButtonsFormatter,
+    );
+  }
+
+  // workaround because Recompose JS doesn't work -> webpack issues
+  compose = (...funcs) => funcs.reduce((a, b) => (...args) => a(b(...args)), arg => arg)
+
+  render() {
+    const {
+      data: { mode, applications, hostgroups, loadParameterSelectionUrl, loadForemanDataUrl },
+      rows,
+      columns,
+      sortingColumns,
+      loading,
+      addParameter,
+      confirmEditParameter,
+      cancelEditParameter,
+      loadParameterSelection,
+      loadForemanData,
+      appDefinition,
+      hostgroupId,
+    } = this.props;
+
+    var sortedRows;
+    var newEntryIndex = findIndex(rows, 'newEntry');
+
+    if (newEntryIndex >= 0) {
+      let newEntry = rows[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(
+        sort.sorter({
+          columns,
+          sortingColumns,
+          sort: orderBy,
+          strategy: sort.strategies.byProperty
+        })
+      )(tmpRows);
+      sortedRows.push(newEntry);
+    } else {
+      sortedRows = this.compose(
+        sort.sorter({
+          columns,
+          sortingColumns,
+          sort: orderBy,
+          strategy: sort.strategies.byProperty
+        })
+      )(rows);
+    }
+
+    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
+              hover
+              dataTable
+              inlineEdit
+              columns={columns}
+              components={{
+                header: {
+                  cell: cellProps =>
+                    this.customHeaderFormatters({
+                      cellProps,
+                      columns,
+                      sortingColumns
+                    })
+                },
+                body: {
+                  row: Table.InlineEditRow,
+                  cell: cellProps => cellProps.children
+                }
+              }}
+            >
+              <Table.Header headerRows={resolve.headerRows({ columns })} />
+              <Table.Body
+                rows={sortedRows}
+                rowKey="id"
+                onRow={(rowData, { rowIndex }) => ({
+                  role: 'row',
+                  isEditing: () => this.isEditing({ rowData }),
+                  onCancel: () => cancelEditParameter({ rowData, rowIndex }),
+                  onConfirm: () => confirmEditParameter({ rowData, rowIndex }),
+                  last: rowIndex === sortedRows.length - 1
+                })}
+              />
+            </Table.PfProvider>
+            {this.renderAddButton(mode, addParameter)}
+          </div>
+          {this.renderRailsInputHidden(isDefinition(mode) ? 'app_definition' : 'app_instance', 'parameters', JSON.stringify(this.props.rows))}
+        </div>
+      </div>
+    );
+  }
+}
+
+ParameterSelection.defaultProps = {
+  error: {},
+  editMode: false,
+  loading: false,
+  foremanData: {},
+  rows: [],
+  columns: [],
+  sortingColumns: {},
+  appDefinition: { "id": '', "name": '', "hostgroup_id": '', "parameters": [] },
+  hostgroupId: -1,
+};
+
+ParameterSelection.propTypes = {
+  data: PropTypes.shape({
+    mode: PropTypes.string.isRequired,
+    location: PropTypes.string.isRequired,
+    organization: PropTypes.string.isRequired,
+    parameters: PropTypes.array,
+    appDefinition: PropTypes.object,
+    applications: PropTypes.object,
+    hostgroups: PropTypes.object,
+    loadParameterSelectionUrl: PropTypes.string,
+    loadForemanDataUrl: PropTypes.string,
+  }).isRequired,
+  initParameterSelection: PropTypes.func,
+  editMode: PropTypes.bool.isRequired,
+  loading: PropTypes.bool.isRequired,
+  foremanData: PropTypes.object.isRequired,
+  parameterTypes: PropTypes.object,
+  rows: PropTypes.array,
+  sortingColumns: PropTypes.object,
+  columns: PropTypes.array,
+  sortParameter: PropTypes.func,
+  addParameter: PropTypes.func,
+  deleteParameter: 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,
+};
+
+export default ParameterSelection;

data/webpack/components/ParameterSelection/ParameterSelection.scss

@@ -0,0 +1,3 @@
+@import '~patternfly/dist/sass/patternfly/_variables';
+@import '~patternfly/dist/sass/patternfly/_loading-state';
+@import '~patternfly-react/dist/sass/_inline-edit';