foreman_openscap 13.1.3 → 13.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55a7bad4db31425c475beef24f3e4b59bc75012eac8aa688c44fa6160cea8830
-  data.tar.gz: d3eec8f2d7b76787f7ca02ede989f9a9774e09600fa62afe5e9f3d2249d4d605
+  metadata.gz: 2c87d1f5b2553990c35d7307969efd773d1a29a29f7871f91aafca638789c746
+  data.tar.gz: c9bebdf6c2008237cad80975e5c675e708b031f4167c1b75abcf28a1d77d7e21
 SHA512:
-  metadata.gz: 4bca688480801ce9ba18c1d6cb9ddab0c5e50a89e8a34689bdcf3a21d40fd1a6cc0bb1380c0cdedf5f5adf05476affcffd75179bb7fedcb0ddb89e4109dae5e6
-  data.tar.gz: 3b3caeaa4a54b5b004814228e2212505ee7121a3fce4e1d7e34a6da645b8e4c23f353a44d4a57b0e5b6e4b02cd74b71b778e77955429abe6e5eb509c12c14d13
+  metadata.gz: bb4f58ffa8e0d4b7ee9142be81f4193fce8f72f130ebef4ff0d1fc2f54b980983b27835cbe020b1bc2ba11cf5e89d3e56bb2dcdfce50b567d46f5162c275733b
+  data.tar.gz: 4773b95b988c447e2db42f6974b0dc893ce8fcb4350615f124698db83a203f26cdc428fcebd25591635b0841ad5d7441130548fd6f3b85457979e9f5d624dc27

data/app/controllers/api/v2/compliance/hosts_bulk_actions_controller.rb

@@ -7,9 +7,10 @@ module Api::V2
         render_error(:custom_error, :status => :unprocessable_entity, :locals => { :message => exception.message })
       end
 
-      before_action :find_editable_hosts, only: [:change_openscap_proxy]
+      before_action :find_editable_hosts, only: [:change_openscap_proxy, :assign_compliance_policy, :unassign_compliance_policy]
       before_action :find_openscap_proxy, only: [:change_openscap_proxy]
       before_action :validate_openscap_proxy_feature, only: [:change_openscap_proxy]
+      before_action :find_compliance_policy, only: [:assign_compliance_policy, :unassign_compliance_policy]
 
       def_param_group :bulk_host_ids do
         param :included, Hash, :desc => N_("Hosts to include in the action"), :required => true, :action_aware => true do
@@ -23,6 +24,33 @@ module Api::V2
         end
       end
 
+      api :PUT, "/compliance/hosts/bulk/assign_compliance_policy", N_("Assign compliance policy to multiple hosts")
+      param_group :bulk_host_ids
+      param :policy_id, :number, :required => true, :desc => N_("ID of the compliance policy to assign to the hosts")
+      def assign_compliance_policy
+        @policy.host_ids = @policy.host_ids + @hosts.pluck(:id)
+        if @policy.save
+          message = _("Assigned with compliance policy: %s") % @policy.name
+          process_response(true, {
+            :message => n_("Updated host: #{message}", "Updated hosts: #{message}", @hosts.count),
+          })
+        else
+          render_error(:custom_error, :status => :unprocessable_entity,
+                       :locals => { :message => @policy.errors.full_messages.to_sentence })
+        end
+      end
+
+      api :PUT, "/compliance/hosts/bulk/unassign_compliance_policy", N_("Unassign compliance policy from multiple hosts")
+      param_group :bulk_host_ids
+      param :policy_id, :number, :required => true, :desc => N_("ID of the compliance policy to unassign from the hosts")
+      def unassign_compliance_policy
+        @policy.unassign_hosts(@hosts)
+        message = _("Unassigned from compliance policy '%s'") % @policy.name
+        process_response(true, {
+          :message => n_("Updated host: #{message}", "Updated hosts: #{message}", @hosts.count),
+        })
+      end
+
       api :PUT, "/hosts/bulk/change_openscap_proxy", N_("Assign OpenSCAP Proxy to multiple hosts")
       param_group :bulk_host_ids
       param :openscap_proxy_id, :number, :required => true, :desc => N_("ID of the OpenSCAP Proxy to assign to the hosts")
@@ -84,6 +112,15 @@ module Api::V2
         render_error(:custom_error, :status => :unprocessable_entity,
                      :locals => { :message => _("The selected OpenSCAP Proxy does not have the OpenSCAP feature enabled.") })
       end
+
+      def find_compliance_policy
+        @policy = ::ForemanOpenscap::Policy.authorized(:assign_policies)
+          .find_by(:id => params.require(:policy_id))
+        return if @policy
+
+        render_error(:custom_error, :status => :unprocessable_entity,
+                     :locals => { :message => _("Compliance policy with id %s not found") % params[:policy_id] })
+      end
     end
   end
 end

data/app/controllers/policies_controller.rb

@@ -83,7 +83,7 @@ class PoliciesController < ApplicationController
       if policy.save
         success _("Updated hosts: Assigned with compliance policy: %s") % policy.name
         # We prefer to go back as this does not lose the current search
-        return redirect_to hosts_path
+        redirect_to hosts_path
       else
         return process_error :object => policy, :redirect => hosts_path
       end

data/config/routes.rb

@@ -105,6 +105,8 @@ Rails.application.routes.draw do
       end
 
       match 'hosts/bulk/change_openscap_proxy', :to => 'compliance/hosts_bulk_actions#change_openscap_proxy', :via => [:put]
+      match 'compliance/hosts/bulk/assign_compliance_policy', :to => 'compliance/hosts_bulk_actions#assign_compliance_policy', :via => [:put]
+      match 'compliance/hosts/bulk/unassign_compliance_policy', :to => 'compliance/hosts_bulk_actions#unassign_compliance_policy', :via => [:put]
     end
   end
 end

data/lib/foreman_openscap/engine.rb

@@ -76,7 +76,9 @@ module ForemanOpenscap
                       :resource_type => 'ForemanOpenscap::Policy'
             permission :assign_policies, { :policies => %i[select_multiple_hosts update_multiple_hosts
                                                           disassociate_multiple_hosts
-                                                          remove_policy_from_multiple_hosts] },
+                                                          remove_policy_from_multiple_hosts],
+                                          'api/v2/compliance/hosts_bulk_actions' => %i[assign_compliance_policy
+                                                                                       unassign_compliance_policy] },
                       :resource_type => 'ForemanOpenscap::Policy'
             permission :view_scap_contents, { :scap_contents => %i[index show auto_complete_search],
                                               'api/v2/compliance/scap_contents' => %i[index show xml],

data/lib/foreman_openscap/version.rb

@@ -1,3 +1,3 @@
 module ForemanOpenscap
-  VERSION = '13.1.3'.freeze
+  VERSION = '13.2.0'.freeze
 end

data/test/functional/api/v2/compliance/hosts_bulk_actions_controller_test.rb

@@ -3,7 +3,7 @@ require 'test_plugin_helper'
 class Api::V2::Compliance::HostsBulkActionsControllerTest < ActionController::TestCase
   tests Api::V2::Compliance::HostsBulkActionsController
 
-  def setup
+  setup do
     as_admin do
       @organization = FactoryBot.create(:organization)
       @location = FactoryBot.create(:location)
@@ -17,6 +17,10 @@ class Api::V2::Compliance::HostsBulkActionsControllerTest < ActionController::Te
                                  :organization => @organization,
                                  :location => @location)
       @host_ids = [@host1.id, @host2.id]
+      @policy = FactoryBot.create(:policy,
+                                  :organizations => [@organization],
+                                  :locations => [@location])
+      @policy.scap_content.update(:organization_ids => [@organization.id], :location_ids => [@location.id])
     end
   end
 
@@ -129,4 +133,174 @@ class Api::V2::Compliance::HostsBulkActionsControllerTest < ActionController::Te
     refute_match(/Successfully updated/, response['error']['message'])
     assert_equal @host_ids.sort, response['error']['failed_host_ids'].sort
   end
+
+  test "should assign compliance policy to selected hosts" do
+    put :assign_compliance_policy,
+        params: valid_bulk_params.merge(:policy_id => @policy.id),
+        session: set_session_user
+
+    assert_response :success
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/Updated hosts: Assigned with compliance policy/, response['message'])
+    assert_includes response['message'], @policy.name
+
+    @policy.reload
+    assert_includes @policy.hosts.map(&:id), @host1.id
+    assert_includes @policy.hosts.map(&:id), @host2.id
+  end
+
+  test "should assign compliance policy to a single host" do
+    put :assign_compliance_policy,
+        params: valid_bulk_params([@host1.id]).merge(:policy_id => @policy.id),
+        session: set_session_user
+
+    assert_response :success
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/Updated host: Assigned with compliance policy/, response['message'])
+
+    @policy.reload
+    assert_includes @policy.hosts.map(&:id), @host1.id
+    refute_includes @policy.hosts.map(&:id), @host2.id
+  end
+
+  test "should require policy_id for assign" do
+    put :assign_compliance_policy,
+        params: valid_bulk_params,
+        session: set_session_user
+
+    assert_response :unprocessable_entity
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/policy_id/, response['error']['message'])
+  end
+
+  test "should return error when policy is not found for assign" do
+    put :assign_compliance_policy,
+        params: valid_bulk_params.merge(:policy_id => 0),
+        session: set_session_user
+
+    assert_response :unprocessable_entity
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/Compliance policy with id .* not found/, response['error']['message'])
+  end
+
+  test "should unassign compliance policy from selected hosts" do
+    as_admin do
+      @host1.policies = [@policy]
+      @host1.save!
+      @host2.policies = [@policy]
+      @host2.save!
+    end
+
+    put :unassign_compliance_policy,
+        params: valid_bulk_params.merge(:policy_id => @policy.id),
+        session: set_session_user
+
+    assert_response :success
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/Updated hosts: Unassigned from compliance policy/, response['message'])
+    assert_includes response['message'], @policy.name
+
+    @policy.reload
+    refute_includes @policy.hosts.map(&:id), @host1.id
+    refute_includes @policy.hosts.map(&:id), @host2.id
+  end
+
+  test "should unassign compliance policy from a single host" do
+    as_admin do
+      @host1.policies = [@policy]
+      @host1.save!
+      @host2.policies = [@policy]
+      @host2.save!
+    end
+
+    put :unassign_compliance_policy,
+        params: valid_bulk_params([@host1.id]).merge(:policy_id => @policy.id),
+        session: set_session_user
+
+    assert_response :success
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/Updated host: Unassigned from compliance policy/, response['message'])
+
+    @policy.reload
+    refute_includes @policy.hosts.map(&:id), @host1.id
+    assert_includes @policy.hosts.map(&:id), @host2.id
+  end
+
+  test "should require policy_id for unassign" do
+    put :unassign_compliance_policy,
+        params: valid_bulk_params,
+        session: set_session_user
+
+    assert_response :unprocessable_entity
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/policy_id/, response['error']['message'])
+  end
+
+  test "should return error when policy is not found for unassign" do
+    put :unassign_compliance_policy,
+        params: valid_bulk_params.merge(:policy_id => 0),
+        session: set_session_user
+
+    assert_response :unprocessable_entity
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_match(/Compliance policy with id .* not found/, response['error']['message'])
+  end
+
+  context "forbidden user" do
+    setup do
+      @user = FactoryBot.create(:user, :admin => false,
+                                :organizations => [@organization],
+                                :locations => [@location])
+    end
+
+    test "should forbid assign compliance policy without assign_policies permission" do
+      setup_user('edit', 'hosts', nil, @user)
+
+      put :assign_compliance_policy,
+          params: valid_bulk_params.merge(:policy_id => @policy.id),
+          session: set_session_user(@user)
+
+      assert_forbidden_missing_permission('assign_policies')
+    end
+
+    test "should forbid unassign compliance policy without assign_policies permission" do
+      setup_user('edit', 'hosts', nil, @user)
+
+      put :unassign_compliance_policy,
+          params: valid_bulk_params.merge(:policy_id => @policy.id),
+          session: set_session_user(@user)
+
+      assert_forbidden_missing_permission('assign_policies')
+    end
+
+    test "should forbid change openscap proxy without edit_hosts permission" do
+      setup_user('assign', 'policies', nil, @user)
+
+      put :change_openscap_proxy,
+          params: valid_bulk_params.merge(:openscap_proxy_id => @proxy.id),
+          session: set_session_user(@user)
+
+      assert_forbidden_missing_permission('edit_hosts')
+    end
+
+    test "should forbid assign compliance policy when user cannot edit hosts" do
+      setup_user('assign', 'policies', nil, @user)
+
+      put :assign_compliance_policy,
+          params: valid_bulk_params.merge(:policy_id => @policy.id),
+          session: set_session_user(@user)
+
+      assert_response :forbidden
+      response = ActiveSupport::JSON.decode(@response.body)
+      assert_match(/No hosts matched search, or action unauthorized for selected hosts/, response['error']['message'])
+    end
+  end
+
+  private
+
+  def assert_forbidden_missing_permission(permission)
+    assert_response :forbidden
+    response = ActiveSupport::JSON.decode(@response.body)
+    assert_includes response['error']['missing_permissions'], permission
+  end
 end

data/webpack/components/BulkActions/compliancePolicy/BulkCompliancePolicyMenuItems.js

@@ -0,0 +1,49 @@
+import React, { useContext } from 'react';
+import { MenuItem } from '@patternfly/react-core';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { openBulkModal } from 'foremanReact/common/BulkModalStateHelper';
+import { usePermissions } from 'foremanReact/common/hooks/Permissions/permissionHooks';
+import { EDIT_HOSTS } from 'foremanReact/permissions';
+import { ForemanHostsIndexActionsBarContext } from 'foremanReact/components/HostsIndex';
+import {
+  ASSIGN_POLICY_MODAL_ID,
+  UNASSIGN_POLICY_MODAL_ID,
+  ASSIGN_POLICIES,
+} from './constants';
+
+const BulkCompliancePolicyMenuItems = () => {
+  const { selectedCount } = useContext(ForemanHostsIndexActionsBarContext);
+
+  const hasPermission = usePermissions([ASSIGN_POLICIES, EDIT_HOSTS]);
+
+  const handleAssignClick = () => openBulkModal(ASSIGN_POLICY_MODAL_ID, true);
+  const handleUnassignClick = () =>
+    openBulkModal(UNASSIGN_POLICY_MODAL_ID, true);
+
+  if (!hasPermission) {
+    return null;
+  }
+
+  return (
+    <>
+      <MenuItem
+        itemId="assign-compliance-policy-dropdown-item"
+        key="assign-compliance-policy-dropdown-item"
+        onClick={handleAssignClick}
+        isDisabled={selectedCount === 0}
+      >
+        {__('Assign compliance policy')}
+      </MenuItem>
+      <MenuItem
+        itemId="unassign-compliance-policy-dropdown-item"
+        key="unassign-compliance-policy-dropdown-item"
+        onClick={handleUnassignClick}
+        isDisabled={selectedCount === 0}
+      >
+        {__('Unassign compliance policy')}
+      </MenuItem>
+    </>
+  );
+};
+
+export default BulkCompliancePolicyMenuItems;

data/webpack/components/BulkActions/compliancePolicy/BulkCompliancePolicyModal.js

@@ -0,0 +1,304 @@
+import React, { useState, useEffect } from 'react';
+import PropTypes from 'prop-types';
+import { FormattedMessage } from 'react-intl';
+import { useDispatch, useSelector } from 'react-redux';
+import {
+  Modal,
+  Button,
+  TextContent,
+  Text,
+  Select,
+  SelectOption,
+  SelectList,
+  MenuToggle,
+  Spinner,
+  EmptyState,
+  EmptyStateHeader,
+  EmptyStateIcon,
+  EmptyStateBody,
+  Flex,
+  FlexItem,
+} from '@patternfly/react-core';
+import { ExclamationCircleIcon, SearchIcon } from '@patternfly/react-icons';
+import { STATUS } from 'foremanReact/constants';
+import { addToast } from 'foremanReact/components/ToastsList/slice';
+import { translate as __ } from 'foremanReact/common/I18n';
+import {
+  selectAPIStatus,
+  selectAPIResponse,
+} from 'foremanReact/redux/API/APISelectors';
+import {
+  buildBulkRequestBody,
+  bulkErrorToastParams,
+} from 'foremanReact/components/HostsIndex/BulkActions/helpers';
+import { fetchPolicies, bulkAssignPolicy, bulkUnassignPolicy } from './actions';
+import {
+  POLICIES_KEY,
+  BULK_ASSIGN_POLICY_KEY,
+  BULK_UNASSIGN_POLICY_KEY,
+} from './constants';
+
+const BulkCompliancePolicyModal = ({
+  isOpen,
+  closeModal,
+  mode,
+  selectAllHostsMode,
+  selectedCount,
+  fetchBulkParams,
+  organizationId,
+  locationId,
+  onSuccess: onSuccessCallback,
+}) => {
+  const dispatch = useDispatch();
+  const [policyId, setPolicyId] = useState('');
+  const [policySelectOpen, setPolicySelectOpen] = useState(false);
+
+  useEffect(() => {
+    if (isOpen) {
+      dispatch(fetchPolicies());
+    }
+  }, [dispatch, isOpen]);
+
+  const isAssignMode = mode === 'assign';
+  const actionKey = isAssignMode
+    ? BULK_ASSIGN_POLICY_KEY
+    : BULK_UNASSIGN_POLICY_KEY;
+
+  const policies = useSelector(state => selectAPIResponse(state, POLICIES_KEY));
+  const policiesStatus = useSelector(state =>
+    selectAPIStatus(state, POLICIES_KEY)
+  );
+  const policiesError = useSelector(
+    state => state.API?.[POLICIES_KEY]?.error?.message
+  );
+  const hostUpdateStatus = useSelector(state =>
+    selectAPIStatus(state, actionKey)
+  );
+
+  const onToggleClick = () => {
+    setPolicySelectOpen(!policySelectOpen);
+  };
+
+  const handlePolicySelect = (event, selection) => {
+    setPolicyId(selection);
+    setPolicySelectOpen(false);
+  };
+
+  const getPolicyLabel = id =>
+    policies?.results?.find(p => p.id.toString() === id)?.name ||
+    __('Select a policy');
+
+  const toggle = toggleRef => (
+    <MenuToggle
+      ref={toggleRef}
+      ouiaId="bulk-compliance-policy-toggle"
+      onClick={onToggleClick}
+      isExpanded={policySelectOpen}
+      style={{ width: '100%' }}
+    >
+      {policyId ? getPolicyLabel(policyId) : __('Select a policy')}
+    </MenuToggle>
+  );
+
+  const handleModalClose = () => {
+    setPolicyId('');
+    setPolicySelectOpen(false);
+    closeModal();
+  };
+
+  const handleError = error => {
+    handleModalClose();
+    dispatch(addToast(bulkErrorToastParams(error, actionKey)));
+  };
+
+  const handleSuccess = response => {
+    dispatch(
+      addToast({
+        type: 'success',
+        message: response.data.message,
+      })
+    );
+    if (onSuccessCallback) onSuccessCallback();
+    handleModalClose();
+  };
+
+  const handleConfirm = () => {
+    const requestBody = buildBulkRequestBody({
+      fetchBulkParams,
+      organizationId,
+      locationId,
+      policy_id: policyId,
+    });
+
+    if (mode === 'assign') {
+      dispatch(bulkAssignPolicy(requestBody, handleSuccess, handleError));
+    } else {
+      dispatch(bulkUnassignPolicy(requestBody, handleSuccess, handleError));
+    }
+  };
+
+  const title = isAssignMode
+    ? __('Assign Compliance Policy')
+    : __('Unassign Compliance Policy');
+  const confirmButtonText = isAssignMode
+    ? __('Assign policy')
+    : __('Unassign policy');
+
+  const modalActions = [
+    <Button
+      key="confirm"
+      ouiaId="bulk-compliance-policy-modal-confirm-button"
+      variant="primary"
+      onClick={handleConfirm}
+      isDisabled={hostUpdateStatus === STATUS.PENDING || policyId === ''}
+      isLoading={hostUpdateStatus === STATUS.PENDING}
+    >
+      {confirmButtonText}
+    </Button>,
+    <Button
+      key="cancel"
+      ouiaId="bulk-compliance-policy-modal-cancel-button"
+      variant="link"
+      onClick={handleModalClose}
+    >
+      {__('Cancel')}
+    </Button>,
+  ];
+
+  const warningMessage = isAssignMode
+    ? __(
+        'The selected policy will be assigned to the selected hosts. Some hosts may already be assigned to this policy.'
+      )
+    : __(
+        'The selected policy will be unassigned from the selected hosts. Some hosts may not be assigned to this policy.'
+      );
+
+  return (
+    <Modal
+      isOpen={isOpen}
+      onClose={handleModalClose}
+      onEscapePress={handleModalClose}
+      title={title}
+      variant="medium"
+      position="top"
+      actions={modalActions}
+      id="bulk-compliance-policy-modal"
+      key="bulk-compliance-policy-modal"
+      ouiaId="bulk-compliance-policy-modal"
+    >
+      <TextContent>
+        <Text ouiaId="bulk-compliance-policy-count">
+          {selectAllHostsMode ? (
+            <FormattedMessage
+              id="bulk-compliance-policy-all-hosts"
+              defaultMessage="{action} will affect {boldCount} selected hosts."
+              values={{
+                action: isAssignMode ? __('Assigning') : __('Unassigning'),
+                boldCount: <strong>{__('All')}</strong>,
+              }}
+            />
+          ) : (
+            <FormattedMessage
+              id="bulk-compliance-policy-selected-hosts"
+              defaultMessage="{action} will affect {boldCount} selected {count, plural, one {host} other {hosts}}."
+              values={{
+                action: isAssignMode ? __('Assigning') : __('Unassigning'),
+                count: selectedCount,
+                boldCount: <strong>{selectedCount}</strong>,
+              }}
+            />
+          )}
+        </Text>
+        <Text ouiaId="bulk-compliance-policy-warning">{warningMessage}</Text>
+      </TextContent>
+
+      {policiesStatus === STATUS.PENDING && (
+        <Flex
+          direction={{ default: 'column' }}
+          alignItems={{ default: 'alignItemsCenter' }}
+          spaceItems={{ default: 'spaceItemsSm' }}
+        >
+          <FlexItem>
+            <Spinner size="lg" aria-label={__('Loading policies')} />
+          </FlexItem>
+          <FlexItem>
+            <Text ouiaId="loading-policies-text">
+              {__('Loading policies...')}
+            </Text>
+          </FlexItem>
+        </Flex>
+      )}
+
+      {policiesStatus === STATUS.ERROR && (
+        <EmptyState>
+          <EmptyStateHeader
+            titleText={__('Failed to load policies')}
+            icon={<EmptyStateIcon icon={ExclamationCircleIcon} />}
+            headingLevel="h4"
+          />
+          <EmptyStateBody>
+            {policiesError || __('An error occurred while fetching policies.')}
+          </EmptyStateBody>
+        </EmptyState>
+      )}
+
+      {policiesStatus === STATUS.RESOLVED && policies?.results?.length === 0 && (
+        <EmptyState>
+          <EmptyStateHeader
+            titleText={__('No policies available')}
+            icon={<EmptyStateIcon icon={SearchIcon} />}
+            headingLevel="h4"
+          />
+          <EmptyStateBody>
+            {__(
+              'There are no compliance policies available in your current organization and location.'
+            )}
+          </EmptyStateBody>
+        </EmptyState>
+      )}
+
+      {policiesStatus === STATUS.RESOLVED && policies?.results?.length > 0 && (
+        <Select
+          id="compliance-policy-select"
+          isOpen={policySelectOpen}
+          selected={policyId}
+          onSelect={handlePolicySelect}
+          onOpenChange={isSelectOpen => setPolicySelectOpen(isSelectOpen)}
+          toggle={toggle}
+          shouldFocusToggleOnSelect
+          ouiaId="bulk-compliance-policy-select"
+        >
+          <SelectList>
+            {policies.results.map(policy => (
+              <SelectOption key={policy.id} value={policy.id.toString()}>
+                {policy.name}
+              </SelectOption>
+            ))}
+          </SelectList>
+        </Select>
+      )}
+    </Modal>
+  );
+};
+
+BulkCompliancePolicyModal.propTypes = {
+  isOpen: PropTypes.bool,
+  closeModal: PropTypes.func,
+  mode: PropTypes.oneOf(['assign', 'unassign']).isRequired,
+  fetchBulkParams: PropTypes.func.isRequired,
+  selectedCount: PropTypes.number.isRequired,
+  selectAllHostsMode: PropTypes.bool.isRequired,
+  organizationId: PropTypes.number,
+  locationId: PropTypes.number,
+  onSuccess: PropTypes.func,
+};
+
+BulkCompliancePolicyModal.defaultProps = {
+  isOpen: false,
+  closeModal: () => {},
+  organizationId: undefined,
+  locationId: undefined,
+  onSuccess: undefined,
+};
+
+export default BulkCompliancePolicyModal;

data/webpack/components/BulkActions/compliancePolicy/BulkCompliancePolicyModalScene.js

@@ -0,0 +1,65 @@
+import React, { useContext } from 'react';
+import { ForemanActionsBarContext } from 'foremanReact/components/HostDetails/ActionsBar';
+import { useBulkModalOpen } from 'foremanReact/common/BulkModalStateHelper';
+import BulkCompliancePolicyModal from './BulkCompliancePolicyModal';
+import { ASSIGN_POLICY_MODAL_ID, UNASSIGN_POLICY_MODAL_ID } from './constants';
+
+export const BulkAssignPolicyModalScene = () => {
+  const {
+    selectAllHostsMode,
+    selectedCount,
+    fetchBulkParams,
+    organizationId,
+    locationId,
+    refreshTableData,
+  } = useContext(ForemanActionsBarContext) || {};
+
+  const { isOpen, close: closeModal } = useBulkModalOpen(
+    ASSIGN_POLICY_MODAL_ID
+  );
+
+  return (
+    <BulkCompliancePolicyModal
+      key="bulk-assign-compliance-policy-modal"
+      selectAllHostsMode={selectAllHostsMode}
+      selectedCount={selectedCount}
+      fetchBulkParams={fetchBulkParams}
+      organizationId={organizationId}
+      locationId={locationId}
+      isOpen={isOpen}
+      closeModal={closeModal}
+      mode="assign"
+      onSuccess={refreshTableData}
+    />
+  );
+};
+
+export const BulkUnassignPolicyModalScene = () => {
+  const {
+    selectAllHostsMode,
+    selectedCount,
+    fetchBulkParams,
+    organizationId,
+    locationId,
+    refreshTableData,
+  } = useContext(ForemanActionsBarContext) || {};
+
+  const { isOpen, close: closeModal } = useBulkModalOpen(
+    UNASSIGN_POLICY_MODAL_ID
+  );
+
+  return (
+    <BulkCompliancePolicyModal
+      key="bulk-unassign-compliance-policy-modal"
+      selectAllHostsMode={selectAllHostsMode}
+      selectedCount={selectedCount}
+      fetchBulkParams={fetchBulkParams}
+      organizationId={organizationId}
+      locationId={locationId}
+      isOpen={isOpen}
+      closeModal={closeModal}
+      mode="unassign"
+      onSuccess={refreshTableData}
+    />
+  );
+};

data/webpack/components/BulkActions/compliancePolicy/__tests__/actions.test.js

@@ -0,0 +1,121 @@
+import { APIActions } from 'foremanReact/redux/API';
+
+import {
+  fetchPolicies,
+  bulkAssignPolicy,
+  bulkUnassignPolicy,
+} from '../actions';
+import {
+  POLICIES_KEY,
+  BULK_ASSIGN_POLICY_KEY,
+  BULK_UNASSIGN_POLICY_KEY,
+} from '../constants';
+
+jest.mock('foremanReact/redux/API', () => ({
+  APIActions: {
+    get: jest.fn(params => ({
+      type: 'API_GET',
+      params,
+    })),
+    put: jest.fn(params => ({
+      type: 'API_PUT',
+      params,
+    })),
+  },
+}));
+
+jest.mock('foremanReact/common/helpers', () => ({
+  foremanUrl: jest.fn(path => path),
+}));
+
+jest.mock('foremanReact/common/I18n', () => ({
+  translate: jest.fn(text => text),
+}));
+
+describe('Compliance Policy Actions', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    APIActions.put.mockReturnValue({ type: 'API_PUT' });
+  });
+
+  describe('fetchPolicies', () => {
+    it('dispatches GET request to compliance policies API', () => {
+      const action = fetchPolicies();
+
+      expect(APIActions.get).toHaveBeenCalledWith({
+        url: '/api/v2/compliance/policies',
+        key: POLICIES_KEY,
+        params: { per_page: 'all' },
+      });
+      expect(action.type).toBe('API_GET');
+    });
+  });
+
+  describe('bulkAssignPolicy', () => {
+    const requestBody = {
+      included: {
+        search: 'id ^ (1,2,3)',
+      },
+      policy_id: '5',
+      organization_id: 1,
+      location_id: 2,
+    };
+    const handleSuccess = jest.fn();
+    const handleError = jest.fn();
+
+    it('dispatches PUT request to assign policy endpoint', () => {
+      bulkAssignPolicy(requestBody, handleSuccess, handleError);
+
+      expect(APIActions.put).toHaveBeenCalledTimes(1);
+      const callArgs = APIActions.put.mock.calls[0][0];
+
+      expect(callArgs.key).toBe(BULK_ASSIGN_POLICY_KEY);
+      expect(callArgs.url).toContain(
+        '/api/v2/compliance/hosts/bulk/assign_compliance_policy'
+      );
+      expect(callArgs.params).toEqual(requestBody);
+      expect(callArgs.handleSuccess).toBe(handleSuccess);
+      expect(callArgs.handleError).toBe(handleError);
+    });
+
+    it('passes error handler callback', () => {
+      bulkAssignPolicy(requestBody, handleSuccess, handleError);
+      const callArgs = APIActions.put.mock.calls[0][0];
+      expect(callArgs.handleError).toBe(handleError);
+    });
+  });
+
+  describe('bulkUnassignPolicy', () => {
+    const requestBody = {
+      included: {
+        search: 'name ~ test',
+      },
+      policy_id: '3',
+      organization_id: 1,
+      location_id: 2,
+    };
+    const handleSuccess = jest.fn();
+    const handleError = jest.fn();
+
+    it('dispatches PUT request to unassign policy endpoint', () => {
+      bulkUnassignPolicy(requestBody, handleSuccess, handleError);
+
+      expect(APIActions.put).toHaveBeenCalledTimes(1);
+      const callArgs = APIActions.put.mock.calls[0][0];
+
+      expect(callArgs.key).toBe(BULK_UNASSIGN_POLICY_KEY);
+      expect(callArgs.url).toContain(
+        '/api/v2/compliance/hosts/bulk/unassign_compliance_policy'
+      );
+      expect(callArgs.params).toEqual(requestBody);
+      expect(callArgs.handleSuccess).toBe(handleSuccess);
+      expect(callArgs.handleError).toBe(handleError);
+    });
+
+    it('passes error handler callback', () => {
+      bulkUnassignPolicy(requestBody, handleSuccess, handleError);
+      const callArgs = APIActions.put.mock.calls[0][0];
+      expect(callArgs.handleError).toBe(handleError);
+    });
+  });
+});

data/webpack/components/BulkActions/compliancePolicy/actions.js

@@ -0,0 +1,32 @@
+import { APIActions } from 'foremanReact/redux/API';
+import { foremanUrl } from 'foremanReact/common/helpers';
+import {
+  POLICIES_KEY,
+  BULK_ASSIGN_POLICY_KEY,
+  BULK_UNASSIGN_POLICY_KEY,
+} from './constants';
+
+export const fetchPolicies = () =>
+  APIActions.get({
+    url: foremanUrl('/api/v2/compliance/policies'),
+    key: POLICIES_KEY,
+    params: { per_page: 'all' },
+  });
+
+export const bulkAssignPolicy = (params, handleSuccess, handleError) =>
+  APIActions.put({
+    url: foremanUrl('/api/v2/compliance/hosts/bulk/assign_compliance_policy'),
+    key: BULK_ASSIGN_POLICY_KEY,
+    params,
+    handleSuccess,
+    handleError,
+  });
+
+export const bulkUnassignPolicy = (params, handleSuccess, handleError) =>
+  APIActions.put({
+    url: foremanUrl('/api/v2/compliance/hosts/bulk/unassign_compliance_policy'),
+    key: BULK_UNASSIGN_POLICY_KEY,
+    params,
+    handleSuccess,
+    handleError,
+  });

data/webpack/components/BulkActions/compliancePolicy/constants.js

@@ -0,0 +1,8 @@
+export const POLICIES_KEY = 'COMPLIANCE_POLICIES';
+export const BULK_ASSIGN_POLICY_KEY = 'BULK_ASSIGN_COMPLIANCE_POLICY';
+export const BULK_UNASSIGN_POLICY_KEY = 'BULK_UNASSIGN_COMPLIANCE_POLICY';
+
+export const ASSIGN_POLICY_MODAL_ID = 'assign-compliance-policy-modal';
+export const UNASSIGN_POLICY_MODAL_ID = 'unassign-compliance-policy-modal';
+
+export const ASSIGN_POLICIES = 'assign_policies';

data/webpack/global_index.js

@@ -4,10 +4,15 @@ import HostKebabItems from './components/HostExtentions/HostKebabItems';
 import BulkChangeOpenscapProxyModalScene, {
   ChangeOpenscapProxyMenuItem,
 } from './components/HostsIndex/ChangeOpenscapProxyAction';
+import BulkCompliancePolicyMenuItems from './components/BulkActions/compliancePolicy/BulkCompliancePolicyMenuItems';
+import {
+  BulkAssignPolicyModalScene,
+  BulkUnassignPolicyModalScene,
+} from './components/BulkActions/compliancePolicy/BulkCompliancePolicyModalScene';
 
 const HOST_ASSOCIATIONS_WEIGHT = 1212;
 const BULK_MODAL_WEIGHT = 100;
-
+const BULK_POLICY_MODAL_WEIGHT = 200;
 const OPENSCAP_KEBAB_WEIGHT = 400;
 
 addGlobalFill(
@@ -30,3 +35,24 @@ addGlobalFill(
   <BulkChangeOpenscapProxyModalScene key="bulk-change-openscap-proxy-modal" />,
   BULK_MODAL_WEIGHT
 );
+
+addGlobalFill(
+  '_host-associations',
+  'compliance-policy-bulk-actions',
+  <BulkCompliancePolicyMenuItems key="compliance-policy-menu-items" />,
+  BULK_POLICY_MODAL_WEIGHT
+);
+
+addGlobalFill(
+  '_all-hosts-modals',
+  'assign-compliance-policy-modal',
+  <BulkAssignPolicyModalScene key="bulk-assign-policy-modal" />,
+  BULK_POLICY_MODAL_WEIGHT
+);
+
+addGlobalFill(
+  '_all-hosts-modals',
+  'unassign-compliance-policy-modal',
+  <BulkUnassignPolicyModalScene key="bulk-unassign-policy-modal" />,
+  BULK_POLICY_MODAL_WEIGHT
+);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman_openscap
 version: !ruby/object:Gem::Version
-  version: 13.1.3
+  version: 13.2.0
 platform: ruby
 authors:
 - slukasik@redhat.com
@@ -366,6 +366,12 @@ files:
 - test/unit/services/lookup_key_overrider_test.rb
 - test/unit/services/report_dashboard/data_test.rb
 - test/unit/tailoring_file_test.rb
+- webpack/components/BulkActions/compliancePolicy/BulkCompliancePolicyMenuItems.js
+- webpack/components/BulkActions/compliancePolicy/BulkCompliancePolicyModal.js
+- webpack/components/BulkActions/compliancePolicy/BulkCompliancePolicyModalScene.js
+- webpack/components/BulkActions/compliancePolicy/__tests__/actions.test.js
+- webpack/components/BulkActions/compliancePolicy/actions.js
+- webpack/components/BulkActions/compliancePolicy/constants.js
 - webpack/components/EmptyState.js
 - webpack/components/HostExtentions/HostKebabItems.js
 - webpack/components/HostsIndex/BulkActions/changeOpenscapProxy/BulkChangeOpenscapProxyModal.js