foreman-tasks 1.0.1 → 1.1.0

data/test/unit/task_test.rb

@@ -1,97 +1,133 @@
 require 'foreman_tasks_test_helper'
 
 class TasksTest < ActiveSupport::TestCase
-  describe 'filtering by current user' do
-    before do
-      @original_current_user = User.current
-      @user_one = FactoryBot.create(:user)
-      @user_two = FactoryBot.create(:user)
+  describe 'search' do
+    describe 'by current user' do
+      before do
+        @original_current_user = User.current
+        @user_one = FactoryBot.create(:user)
+        @user_two = FactoryBot.create(:user)
 
-      @task_one = FactoryBot.create(:some_task, :user => @user_one)
-      FactoryBot.create(:some_task, :user => @user_two)
+        @task_one = FactoryBot.create(:some_task, :user => @user_one)
+        FactoryBot.create(:some_task, :user => @user_two)
 
-      User.current = @user_one
-    end
-    after { User.current = @original_current_user }
+        User.current = @user_one
+      end
+      after { User.current = @original_current_user }
 
-    test 'can search the tasks by current_user' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for('owner.id = current_user')
-    end
+      test 'can search the tasks by current_user' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for('owner.id = current_user')
+      end
 
-    test 'can search by implicit search' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for(@task_one.label)
-    end
+      test 'can search by implicit search' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for(@task_one.label)
+      end
 
-    test 'can search the tasks by current_user in combination with implicit search' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id = current_user AND #{@task_one.label}")
-    end
+      test 'can search the tasks by current_user in combination with implicit search' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id = current_user AND #{@task_one.label}")
+      end
 
-    test 'can search the tasks by user' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user = #{@user_one.login}")
-    end
+      test 'can search the tasks by user' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user = #{@user_one.login}")
+      end
 
-    test 'cannot search by arbitrary key' do
-      proc { ForemanTasks::Task.search_for('user.my_key ~ 5') }.must_raise(ScopedSearch::QueryNotSupported)
-      proc { ForemanTasks::Task.search_for('user. = 5') }.must_raise(ScopedSearch::QueryNotSupported)
-    end
+      test 'cannot search by arbitrary key' do
+        proc { ForemanTasks::Task.search_for('user.my_key ~ 5') }.must_raise(ScopedSearch::QueryNotSupported)
+        proc { ForemanTasks::Task.search_for('user. = 5') }.must_raise(ScopedSearch::QueryNotSupported)
+      end
 
-    test 'can search the tasks by negated user' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user != #{@user_two.login}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user <> #{@user_two.login}")
-      SecureRandom.stubs(:hex).returns('abc')
-      assert_equal ForemanTasks::Task.search_for("user != #{@user_two.login}").to_sql,
-                   ForemanTasks::Task.search_for("user <> #{@user_two.login}").to_sql
-    end
+      test 'can search the tasks by negated user' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user != #{@user_two.login}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user <> #{@user_two.login}")
+        SecureRandom.stubs(:hex).returns('abc')
+        assert_equal ForemanTasks::Task.search_for("user != #{@user_two.login}").to_sql,
+                     ForemanTasks::Task.search_for("user <> #{@user_two.login}").to_sql
+      end
 
-    test 'can search the tasks by user\'s id' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user.id = #{@user_one.id}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id = #{@user_one.id}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user.id != #{@user_two.id}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id != #{@user_two.id}")
-    end
+      test 'can search the tasks by user\'s id' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user.id = #{@user_one.id}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id = #{@user_one.id}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user.id != #{@user_two.id}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id != #{@user_two.id}")
+      end
 
-    test 'can search by array of user ids' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user.id ^ (#{@user_one.id})")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id ^ (#{@user_one.id})")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user.id !^ (#{@user_two.id})")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id !^ (#{@user_two.id})")
-    end
+      test 'can search by array of user ids' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user.id ^ (#{@user_one.id})")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id ^ (#{@user_one.id})")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user.id !^ (#{@user_two.id})")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("owner.id !^ (#{@user_two.id})")
+      end
 
-    test 'cannot glob on user\'s id' do
-      proc { ForemanTasks::Task.search_for("user.id ~ something") }.must_raise(ScopedSearch::QueryNotSupported)
-      proc { ForemanTasks::Task.search_for("user.id ~ 5") }.must_raise(ScopedSearch::QueryNotSupported)
-    end
+      test 'cannot glob on user\'s id' do
+        proc { ForemanTasks::Task.search_for("user.id ~ something") }.must_raise(ScopedSearch::QueryNotSupported)
+        proc { ForemanTasks::Task.search_for("user.id ~ 5") }.must_raise(ScopedSearch::QueryNotSupported)
+      end
 
-    test 'can search the tasks by user with wildcards' do
-      part = @user_one.login[1..-1] # search for '*ser1' if login is 'user1'
-      # The following two should be equivalent
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user ~ #{part}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user ~ *#{part}*")
-      SecureRandom.stubs(:hex).returns('abc')
-      assert_equal ForemanTasks::Task.search_for("user ~ #{part}").to_sql,
-                   ForemanTasks::Task.search_for("user ~ *#{part}*").to_sql
-    end
+      test 'can search the tasks by user with wildcards' do
+        part = @user_one.login[1..-1] # search for '*ser1' if login is 'user1'
+        # The following two should be equivalent
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user ~ #{part}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user ~ *#{part}*")
+        SecureRandom.stubs(:hex).returns('abc')
+        assert_equal ForemanTasks::Task.search_for("user ~ #{part}").to_sql,
+                     ForemanTasks::Task.search_for("user ~ *#{part}*").to_sql
+      end
 
-    test 'can search the tasks by user with negated wildcards' do
-      part = @user_two.login[1..-1] # search for '*ser1' if login is 'user1'
-      # The following two should be equivalent
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user !~ #{part}")
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user !~ *#{part}*")
-      SecureRandom.stubs(:hex).returns('abc')
-      assert_equal ForemanTasks::Task.search_for("user !~ #{part}").to_sql,
-                   ForemanTasks::Task.search_for("user !~ *#{part}*").to_sql
-    end
+      test 'can search the tasks by user with negated wildcards' do
+        part = @user_two.login[1..-1] # search for '*ser1' if login is 'user1'
+        # The following two should be equivalent
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user !~ #{part}")
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user !~ *#{part}*")
+        SecureRandom.stubs(:hex).returns('abc')
+        assert_equal ForemanTasks::Task.search_for("user !~ #{part}").to_sql,
+                     ForemanTasks::Task.search_for("user !~ *#{part}*").to_sql
+      end
 
-    test 'can search the tasks by array' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user ^ (this_user, #{@user_one.login}, that_user)")
-    end
+      test 'can search the tasks by array' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user ^ (this_user, #{@user_one.login}, that_user)")
+      end
+
+      test 'can search the tasks by negated array' do
+        assert_equal [@task_one], ForemanTasks::Task.search_for("user !^ (this_user, #{@user_two.login}, that_user)")
+      end
 
-    test 'can search the tasks by negated array' do
-      assert_equal [@task_one], ForemanTasks::Task.search_for("user !^ (this_user, #{@user_two.login}, that_user)")
+      test 'properly returns username' do
+        assert_equal @task_one.username, @user_one.login
+      end
     end
 
-    test 'properly returns username' do
-      assert_equal @task_one.username, @user_one.login
+    describe 'by duration' do
+      before do
+        @task_one, @task_two = FactoryBot.create_list(:dynflow_task, 2).sort_by(&:id)
+      end
+
+      let(:scope) { ForemanTasks::Task.order(:id) }
+
+      it 'can search by seconds ' do
+        skip unless on_postgresql?
+        _(scope.search_for('duration < 2')).must_be :empty?
+        _(scope.search_for('duration = 2')).must_equal [@task_one, @task_two]
+        _(scope.search_for('duration < "2 seconds"')).must_be :empty?
+        _(scope.search_for('duration > "2 seconds"')).must_be :empty?
+        _(scope.search_for('duration = "2 seconds"')).must_equal [@task_one, @task_two]
+        _(scope.search_for('duration <= "2 seconds"')).must_equal [@task_one, @task_two]
+        _(scope.search_for('duration >= "2 seconds"')).must_equal [@task_one, @task_two]
+      end
+
+      it 'can search by other time intervals' do
+        skip unless on_postgresql?
+        %w[minutes hours days months years].each do |interval|
+          _(scope.search_for("duration < \"2 #{interval}\"")).must_equal [@task_one, @task_two]
+          _(scope.search_for("duration > \"2 #{interval}\"")).must_be :empty?
+          _(scope.search_for("duration = \"2 #{interval}\"")).must_be :empty?
+          _(scope.search_for("duration <= \"2 #{interval}\"")).must_equal [@task_one, @task_two]
+          _(scope.search_for("duration >= \"2 #{interval}\"")).must_be :empty?
+        end
+      end
+
+      it 'raises an exception if duration is unknown' do
+        proc { ForemanTasks::Task.search_for('duration = "25 potatoes"') }.must_raise ScopedSearch::QueryNotSupported
+      end
     end
   end
 
@@ -248,4 +284,54 @@ class TasksTest < ActiveSupport::TestCase
       task.execution_type.must_equal 'Delayed'
     end
   end
+
+  describe 'search for resource_ids' do
+    it 'finds tasks' do
+      label = 'label1'
+      resource_ids = [1, 2]
+      resource_type = 'restype1'
+
+      task1_old = FactoryBot.create(
+        :task_with_locks,
+        started_at: '2019-10-01 11:15:55',
+        ended_at: '2019-10-01 11:15:57',
+        resource_id: 1,
+        label: label,
+        resource_type: resource_type
+      )
+      task1_new = FactoryBot.create(
+        :task_with_locks,
+        started_at: '2019-10-02 11:15:55',
+        ended_at: '2019-10-02 11:15:57',
+        resource_id: 1,
+        label: label,
+        resource_type: resource_type
+      )
+      task2 = FactoryBot.create(
+        :task_with_locks,
+        started_at: '2019-10-03 11:15:55',
+        ended_at: '2019-10-03 11:15:57',
+        resource_id: 2,
+        label: label,
+        resource_type: resource_type
+      )
+      task3 = FactoryBot.create(
+        :task_with_locks,
+        started_at: '2019-10-03 11:15:55',
+        ended_at: '2019-10-03 11:15:57',
+        resource_id: 3,
+        label: label,
+        resource_type: 'another_type'
+      )
+
+      result = ForemanTasks::Task.search_for(
+        "resource_id ^ (#{resource_ids.join(',')}) and resource_type = #{resource_type}"
+      ).distinct
+      assert_equal 3, result.length
+      assert_includes result, task1_old
+      assert_includes result, task1_new
+      assert_includes result, task2
+      assert_not_includes result, task3
+    end
+  end
 end

data/webpack/ForemanTasks/Components/TaskDetails/Components/Task.js

@@ -42,6 +42,7 @@ class Task extends Component {
       cancelTaskRequest,
       resumeTaskRequest,
       action,
+      dynflowEnableConsole,
     } = this.props;
     const modalUnlock = (
       <ClickConfirmation
@@ -99,6 +100,7 @@ class Task extends Component {
               <Button
                 bsSize="small"
                 href={`/foreman_tasks/dynflow/${externalId}`}
+                disabled={!dynflowEnableConsole}
               >
                 {__('Dynflow console')}
               </Button>
@@ -188,6 +190,7 @@ Task.propTypes = {
   toggleForceUnlockModal: PropTypes.func,
   cancelTaskRequest: PropTypes.func,
   resumeTaskRequest: PropTypes.func,
+  dynflowEnableConsole: PropTypes.bool,
 };
 
 Task.defaultProps = {
@@ -210,6 +213,7 @@ Task.defaultProps = {
   toggleForceUnlockModal: () => null,
   cancelTaskRequest: () => null,
   resumeTaskRequest: () => null,
+  dynflowEnableConsole: false,
 };
 
 export default Task;

data/webpack/ForemanTasks/Components/TaskDetails/Components/TaskInfo.js

@@ -2,8 +2,8 @@ import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 import { Grid, Row, Col, ProgressBar } from 'patternfly-react';
 import { translate as __ } from 'foremanReact/common/I18n';
-import EllipsisWithTooltip from 'react-ellipsis-with-tooltip';
 import RelativeDateTime from 'foremanReact/components/common/dates/RelativeDateTime';
+import ReactHtmlParser from 'react-html-parser';
 
 class TaskInfo extends Component {
   isDelayed = () => {
@@ -69,9 +69,7 @@ class TaskInfo extends Component {
       [
         {
           title: 'Name',
-          value: (
-            <EllipsisWithTooltip>{action || __('N/A')}</EllipsisWithTooltip>
-          ),
+          value: action || __('N/A'),
         },
         {
           title: 'Start at',
@@ -173,14 +171,7 @@ class TaskInfo extends Component {
                   <b>{__('Troubleshooting')}</b>
                 </span>
               </p>
-              <p>
-                {help.split('\n').map((item, i) => (
-                  <React.Fragment key={i}>
-                    {item}
-                    <br />
-                  </React.Fragment>
-                ))}
-              </p>
+              <p>{ReactHtmlParser(help)}</p>
             </Col>
           </Row>
         )}

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/Task.test.js

@@ -9,6 +9,7 @@ const fixtures = {
     state: 'paused',
     hasSubTasks: true,
     allowDangerousActions: true,
+    dynflowEnableConsole: true,
   },
 };
 

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/__snapshots__/Task.test.js.snap

@@ -115,6 +115,7 @@ exports[`Task rendering render with some Props 1`] = `
       allowDangerousActions={true}
       cancelTaskRequest={[Function]}
       cancellable={false}
+      dynflowEnableConsole={true}
       endedAt=""
       error={Array []}
       externalId=""
@@ -205,7 +206,7 @@ exports[`Task rendering render without Props 1`] = `
           bsClass="btn"
           bsSize="small"
           bsStyle="default"
-          disabled={false}
+          disabled={true}
           href="/foreman_tasks/dynflow/"
         >
           Dynflow console
@@ -229,6 +230,7 @@ exports[`Task rendering render without Props 1`] = `
       allowDangerousActions={false}
       cancelTaskRequest={[Function]}
       cancellable={false}
+      dynflowEnableConsole={false}
       endedAt=""
       error={Array []}
       externalId=""

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/__snapshots__/TaskInfo.test.js.snap

@@ -32,9 +32,7 @@ exports[`TaskInfo rendering render with Props 1`] = `
       sm={6}
     >
       <span>
-        <EllipisWithTooltip>
-          Monitor Event Queue
-        </EllipisWithTooltip>
+        Monitor Event Queue
       </span>
     </Col>
     <Col
@@ -335,9 +333,7 @@ exports[`TaskInfo rendering render without Props 1`] = `
       sm={6}
     >
       <span>
-        <EllipisWithTooltip>
-          N/A
-        </EllipisWithTooltip>
+        N/A
       </span>
     </Col>
     <Col

data/webpack/ForemanTasks/Components/TaskDetails/TaskDetailsSelectors.js

@@ -30,7 +30,7 @@ export const selectErrors = state => {
 
 export const selectProgress = state =>
   selectTaskDetails(state).progress
-    ? selectTaskDetails(state).progress.toFixed(4) * 100
+    ? parseFloat((selectTaskDetails(state).progress * 100).toFixed(2))
     : 0;
 
 export const selectUsername = state =>
@@ -83,3 +83,6 @@ export const selectShowForceUnlockModal = state =>
 
 export const selectExternalId = state =>
   selectTaskDetails(state).external_id || null;
+
+export const selectDynflowEnableConsole = state =>
+  selectTaskDetails(state).dynflow_enable_console || false;

data/webpack/ForemanTasks/Components/TaskDetails/__tests__/__snapshots__/TaskDetails.test.js.snap

@@ -18,6 +18,7 @@ exports[`TaskDetails rendering render without Props 1`] = `
         allowDangerousActions={false}
         cancelTaskRequest={[Function]}
         cancellable={false}
+        dynflowEnableConsole={false}
         endedAt=""
         error={Array []}
         executionPlan={Object {}}

data/webpack/ForemanTasks/Components/TaskDetails/index.js

@@ -33,6 +33,7 @@ import {
   selectShowUnlockModal,
   selectShowForceUnlockModal,
   selectExternalId,
+  selectDynflowEnableConsole,
 } from './TaskDetailsSelectors';
 
 const mapStateToProps = state => ({
@@ -65,6 +66,7 @@ const mapStateToProps = state => ({
   showUnlockModal: selectShowUnlockModal(state),
   showForceUnlockModal: selectShowForceUnlockModal(state),
   externalId: selectExternalId(state),
+  dynflowEnableConsole: selectDynflowEnableConsole(state),
 });
 
 const mapDispatchToProps = dispatch => bindActionCreators(actions, dispatch);

data/webpack/ForemanTasks/Components/TasksTable/SubTasksPage.js

@@ -1,6 +1,6 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import { translate as __ } from 'foremanReact/common/I18n';
+import { sprintf, translate as __ } from 'foremanReact/common/I18n';
 import TasksTablePage from './';
 
 export const SubTasksPage = props => {
@@ -15,10 +15,12 @@ export const SubTasksPage = props => {
       { caption: __('Sub tasks') },
     ],
   });
+  const createHeader = actionName => actionName ? sprintf(__('Sub tasks of %s'), actionName) : __('Sub tasks');
   return (
     <TasksTablePage
       getBreadcrumbs={getBreadcrumbs}
       parentTaskID={parentTaskID}
+      createHeader={createHeader}
       {...props}
     />
   );

data/webpack/ForemanTasks/Components/TasksTable/TasksTableActions.js

@@ -2,15 +2,17 @@ import { getURIQuery } from 'foremanReact/common/helpers';
 import { getTableItemsAction } from 'foremanReact/components/common/table';
 import API from 'foremanReact/API';
 import { addToast } from 'foremanReact/redux/actions/toasts';
-import { translate as __ } from 'foremanReact/common/I18n';
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import URI from 'urijs';
 import {
   TASKS_TABLE_ID,
   SELECT_ROWS,
   UNSELECT_ALL_ROWS,
   UNSELECT_ROWS,
-  RESUME,
-  CANCEL,
   UPDATE_CLICKED,
+  TASKS_RESUME_REQUEST,
+  TASKS_RESUME_SUCCESS,
+  TASKS_RESUME_FAILURE,
 } from './TasksTableConstants';
 import { getApiPathname } from './TasksTableHelpers';
 import { fetchTasksSummary } from '../TasksDashboard/TasksDashboardActions';
@@ -18,8 +20,13 @@ import { fetchTasksSummary } from '../TasksDashboard/TasksDashboardActions';
 export const getTableItems = url =>
   getTableItemsAction(TASKS_TABLE_ID, getURIQuery(url), getApiPathname(url));
 
-export const cancelTask = (id, name, url, parentTaskID) => async dispatch => {
-  await dispatch(cancelTaskRequest(id, name));
+export const cancelTask = ({
+  taskId,
+  taskName,
+  url,
+  parentTaskID,
+}) => async dispatch => {
+  await dispatch(cancelTaskRequest(taskId, taskName));
   dispatch(getTableItems(url));
   dispatch(fetchTasksSummary(getURIQuery(url).time, parentTaskID));
 };
@@ -49,8 +56,13 @@ export const cancelTaskRequest = (id, name) => async dispatch => {
   }
 };
 
-export const resumeTask = (id, name, url, parentTaskID) => async dispatch => {
-  await dispatch(resumeTaskRequest(id, name));
+export const resumeTask = ({
+  taskId,
+  taskName,
+  url,
+  parentTaskID,
+}) => async dispatch => {
+  await dispatch(resumeTaskRequest(taskId, taskName));
   dispatch(getTableItems(url));
   dispatch(fetchTasksSummary(getURIQuery(url).time), parentTaskID);
 };
@@ -93,34 +105,88 @@ export const unselectRow = id => ({
   payload: id,
 });
 
-export const actionSelected = (
-  actionType,
+export const bulkResumeRequest = resumeTasks => {
+  const ids = resumeTasks.map(task => task.id);
+  const url = new URI('/foreman_tasks/api/tasks/bulk_resume');
+  url.setSearch('task_ids[]', ids);
+  return API.post(url);
+};
+
+export const bulkResume = ({
+  selected,
+  url,
+  parentTaskID,
+}) => async dispatch => {
+  const resumeTasks = selected.filter(task => task.isResumable);
+  if (resumeTasks.length < selected.length)
+    dispatch(
+      addToast({
+        type: 'warning',
+        message: __('Not all the selected tasks can be resumed'),
+      })
+    );
+  if (resumeTasks.length) {
+    try {
+      dispatch({ type: TASKS_RESUME_REQUEST });
+      const { data } = await bulkResumeRequest(resumeTasks);
+      dispatch({ type: TASKS_RESUME_SUCCESS });
+      const toastInfo = {
+        resumed: { type: 'success', text: 'was resumed' },
+        failed: { type: 'error', text: 'could not be resumed' },
+      };
+      const toastDispatch = (type, name) =>
+        dispatch(
+          addToast({
+            type: toastInfo[type].type,
+            message: sprintf(__('%(name)s Task execution %(type)s'), {
+              name,
+              type: toastInfo[type].text,
+            }),
+          })
+        );
+
+      ['resumed', 'failed'].forEach(type => {
+        data[type].forEach(task => {
+          toastDispatch(type, task.action);
+        });
+      });
+      if (data.resumed.length) {
+        dispatch(getTableItems(url));
+        dispatch(fetchTasksSummary(getURIQuery(url).time, parentTaskID));
+      }
+    } catch (error) {
+      dispatch({ type: TASKS_RESUME_FAILURE, error });
+      dispatch(
+        addToast({
+          type: 'error',
+          message: `${__(`Cannot resume tasks at the moment`)} ${error}`,
+        })
+      );
+    }
+  }
+};
+
+export const bulkCancel = ({
   selected,
   url,
-  parentTaskID
-) => async dispatch => {
+  parentTaskID,
+}) => async dispatch => {
   let notAllActionable = false;
   let someActionable = false;
   const promises = selected.map(task => {
-    if (actionType === RESUME && task.isResumeble) {
+    if (task.isCancellable) {
       someActionable = true;
-      return dispatch(resumeTaskRequest(task.id, task.name, url));
-    } else if (actionType === CANCEL && task.isCancelleble) {
-      someActionable = true;
-      return dispatch(cancelTaskRequest(task.id, task.name, url));
+      return dispatch(cancelTaskRequest(task.id, task.name));
     }
     notAllActionable = true;
     return null;
   });
+
   if (notAllActionable)
     dispatch(
       addToast({
         type: 'warning',
-        message: __(
-          `Not all the selected tasks can be ${
-            actionType === RESUME ? 'resumed' : 'canceled'
-          }`
-        ),
+        message: __('Not all the selected tasks can be canceled'),
       })
     );
   if (someActionable) {