JobInvocationActions.js

import { translate as __, sprintf } from 'foremanReact/common/I18n';
import { addToast } from 'foremanReact/components/ToastsList';
import { APIActions, get } from 'foremanReact/redux/API';
import {
  CANCEL_JOB,
  CANCEL_RECURRING_LOGIC,
  CHANGE_ENABLED_RECURRING_LOGIC,
  JOB_INVOCATION_KEY,
  STATUS,
} from './JobInvocationConstants';

const FINISHED_STATUSES = [STATUS.FAILED, STATUS.SUCCEEDED, STATUS.CANCELLED];

export const isJobFinished = statusLabel =>
  FINISHED_STATUSES.includes(statusLabel);

const extractErrorMessage = response =>
  // eslint-disable-next-line camelcase
  response?.data?.error?.full_messages?.[0] ||
  response?.data?.error?.message ||
  'Unknown error.';

const fetchJobInvocation = (dispatch, url, params = {}, pollTimeoutRef = { current: null }) => {
  dispatch(
    get({
      key: JOB_INVOCATION_KEY,
      params: { include_hosts: false, include_permissions: true, ...params },
      url,
      handleSuccess: ({ data }) => {
        if (!isJobFinished(data.status_label)) {
          pollTimeoutRef.current = setTimeout(
            () => fetchJobInvocation(dispatch, url, {}, pollTimeoutRef),
            5000
          );
        } else {
          pollTimeoutRef.current = null;
        }
      },
      handleError: () => {
        pollTimeoutRef.current = null;
      },
      errorToast: ({ response }) => extractErrorMessage(response),
    })
  );
};

export const getJobInvocation = (url, pollTimeoutRef) => dispatch => {
  stopJobInvocationPolling(pollTimeoutRef);
  fetchJobInvocation(dispatch, url, { include_permissions: true }, pollTimeoutRef);
};

export const stopJobInvocationPolling = pollTimeoutRef => {
  clearTimeout(pollTimeoutRef.current);
  pollTimeoutRef.current = null;
};

export const cancelJob = (jobId, force) => dispatch => {
  const infoToast = () =>
    force
      ? sprintf(__('Trying to abort the job %s.'), jobId)
      : sprintf(__('Trying to cancel the job %s.'), jobId);
  const errorToast = response =>
    force
      ? sprintf(__('Could not abort the job %s: %s'), jobId, response)
      : sprintf(__('Could not cancel the job %s: %s'), jobId, response);
  const url = force
    ? `/job_invocations/${jobId}/cancel?force=true`
    : `/job_invocations/${jobId}/cancel`;

  dispatch(
    APIActions.post({
      url,
      key: CANCEL_JOB,
      errorToast: ({ response }) => errorToast(extractErrorMessage(response)),
      handleSuccess: () => {
        dispatch(
          addToast({
            key: `cancel-job-error`,
            type: 'info',
            message: infoToast(),
          })
        );
      },
    })
  );
};

export const enableRecurringLogic = (
  recurrenceId,
  enabled,
  jobId
) => dispatch => {
  const successToast = () =>
    enabled
      ? sprintf(__('Recurring logic %s disabled successfully.'), recurrenceId)
      : sprintf(__('Recurring logic %s enabled successfully.'), recurrenceId);
  const errorToast = response =>
    enabled
      ? sprintf(
          __(`Could not disable recurring logic %s: ${response}`),
          recurrenceId
        )
      : sprintf(
          __(`Could not enable recurring logic %s: ${response}`),
          recurrenceId
        );
  const url = `/foreman_tasks/api/recurring_logics/${recurrenceId}`;
  dispatch(
    APIActions.put({
      url,
      key: CHANGE_ENABLED_RECURRING_LOGIC,
      params: { recurring_logic: { enabled: !enabled } },
      successToast,
      errorToast: ({ response }) => errorToast(extractErrorMessage(response)),
      handleSuccess: () => {
        fetchJobInvocation(dispatch, `/api/job_invocations/${jobId}`);
      },
    })
  );
};

export const cancelRecurringLogic = recurrenceId => dispatch => {
  const successToast = () =>
    sprintf(__('Recurring logic %s cancelled successfully.'), recurrenceId);
  const errorToast = response =>
    sprintf(
      __(`Could not cancel recurring logic %s: ${response}`),
      recurrenceId
    );
  const url = `/foreman_tasks/recurring_logics/${recurrenceId}/cancel`;
  dispatch(
    APIActions.post({
      url,
      key: CANCEL_RECURRING_LOGIC,
      successToast,
      errorToast: ({ response }) => errorToast(extractErrorMessage(response)),
    })
  );
};