foreman_leapp 3.3.0 → 4.0.0

data/webpack/components/PreupgradeReportsTable/index.js

@@ -1,163 +1,374 @@
+/* eslint-disable max-lines */
 import PropTypes from 'prop-types';
-import React, { useEffect, useState } from 'react';
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
 import { useDispatch } from 'react-redux';
-import { ExpandableSection, Tooltip } from '@patternfly/react-core';
+import {
+  Button,
+  ExpandableSection,
+  Toolbar,
+  ToolbarContent,
+  ToolbarGroup,
+  ToolbarItem,
+  Tooltip,
+} from '@patternfly/react-core';
 import { ExpandableRowContent, Tbody, Td, Tr } from '@patternfly/react-table';
 import { translate as __ } from 'foremanReact/common/I18n';
+import { foremanUrl } from 'foremanReact/common/helpers';
 import { Table } from 'foremanReact/components/PF4/TableIndexPage/Table/Table';
+import SelectAllCheckbox from 'foremanReact/components/PF4/TableIndexPage/Table/SelectAllCheckbox';
+import { useBulkSelect } from 'foremanReact/components/PF4/TableIndexPage/Table/TableHooks';
+import { RowSelectTd } from 'foremanReact/components/PF4/TableIndexPage/RowSelectTd';
 import { getColumnHelpers } from 'foremanReact/components/PF4/TableIndexPage/Table/helpers';
 import { APIActions } from 'foremanReact/redux/API';
 import { STATUS } from 'foremanReact/constants';
-import { entriesPage } from '../PreupgradeReports/PreupgradeReportsHelpers';
+import {
+  entriesPage,
+  entryFixable,
+} from '../PreupgradeReports/PreupgradeReportsHelpers';
 import ReportDetails, { renderSeverityLabel } from './ReportDetails';
+import './PreupgradeReportsTable.scss';
+
+const LEAPP_TEMPLATE_NAME = 'Run preupgrade via Leapp';
+
+const isRowFixable = entryFixable;
+
+const submitJobInvocation = (
+  dispatch,
+  setError,
+  feature,
+  hostIds,
+  remediationIds
+) => {
+  const payload = {
+    job_invocation: {
+      feature,
+      host_ids: hostIds,
+      ...(remediationIds != null
+        ? { inputs: { remediation_ids: remediationIds } }
+        : {}),
+    },
+  };
+
+  dispatch(
+    APIActions.post({
+      key: `CREATE_JOB_INVOCATION_${feature}`,
+      url: foremanUrl('/api/job_invocations'),
+      params: payload,
+      handleSuccess: response => {
+        const result = response.data || response;
+        if (result?.id) {
+          window.location.assign(foremanUrl(`/job_invocations/${result.id}`));
+        }
+      },
+      handleError: err => setError(err),
+    })
+  );
+};
 
 const PreupgradeReportsTable = ({ data = {} }) => {
   const [error, setError] = useState(null);
-
-  const [isReportExpanded, setIsReportExpanded] = useState(false); // Outer expansion state (Leapp Report Section)
+  const [isReportExpanded, setIsReportExpanded] = useState(false);
   const [pagination, setPagination] = useState({ page: 1, perPage: 5 });
   const [reportData, setReportData] = useState(null);
   const [status, setStatus] = useState(STATUS.RESOLVED);
-  const [expandedRowIds, setExpandedRowIds] = useState(new Set()); // Inner table expansion state (Rows)
+  const [expandedRowIds, setExpandedRowIds] = useState(new Set());
 
   const dispatch = useDispatch();
   // eslint-disable-next-line camelcase
-  const isLeappJob = data?.template_name?.includes('Run preupgrade via Leapp');
+  const isLeappJob = data?.template_name?.includes(LEAPP_TEMPLATE_NAME);
 
-  const columns = {
-    title: {
-      title: __('Title'),
-    },
-    host: {
-      title: __('Host'),
-      wrapper: entry =>
-        entry.hostname || (reportData && reportData.hostname) || '-',
-    },
-    risk_factor: {
-      title: __('Risk Factor'),
-      wrapper: ({ severity }) => renderSeverityLabel(severity),
-    },
-    has_remediation: {
-      title: __('Has Remediation?'),
-      wrapper: entry =>
-        entry.detail && entry.detail.remediations ? __('Yes') : __('No'),
-    },
-    inhibitor: {
-      title: __('Inhibitor?'),
-      wrapper: entry =>
-        entry.flags && entry.flags.some(flag => flag === 'inhibitor') ? (
-          <Tooltip content={__('This issue inhibits the upgrade.')}>
-            <span>{__('Yes')}</span>
-          </Tooltip>
-        ) : (
-          __('No')
-        ),
-    },
-  };
+  // eslint-disable-next-line camelcase
+  const jobStatusLabel = data?.status_label;
+
+  const lastFetchedKeyRef = useRef(null);
+
+  const columns = useMemo(
+    () => ({
+      title: { title: __('Title') },
+      host: {
+        title: __('Host'),
+        wrapper: entry => entry.hostname || reportData?.hostname || '-',
+      },
+      risk_factor: {
+        title: __('Risk Factor'),
+        wrapper: ({ severity }) => renderSeverityLabel(severity),
+      },
+      has_remediation: {
+        title: __('Has Remediation?'),
+        wrapper: entry => (entry.detail?.remediations ? __('Yes') : __('No')),
+      },
+      inhibitor: {
+        title: __('Inhibitor?'),
+        wrapper: entry =>
+          entry.flags?.some(flag => flag === 'inhibitor') ? (
+            <Tooltip content={__('This issue inhibits the upgrade.')}>
+              <span>{__('Yes')}</span>
+            </Tooltip>
+          ) : (
+            __('No')
+          ),
+      },
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [reportData?.hostname]
+  );
 
   useEffect(() => {
     let isMounted = true;
-    if (!isLeappJob || !isReportExpanded || reportData) {
+    const fetchKey = `${data.id}:${jobStatusLabel}`;
+
+    if (
+      !isLeappJob ||
+      !isReportExpanded ||
+      lastFetchedKeyRef.current === fetchKey
+    )
       return undefined;
-    }
-    setStatus(STATUS.PENDING);
 
+    const fail = err => {
+      if (!isMounted) return;
+      setError(err);
+      setStatus(STATUS.ERROR);
+    };
+
+    const succeed = response => {
+      if (!isMounted) return;
+      lastFetchedKeyRef.current = fetchKey;
+      setReportData(response?.data || response || null);
+      setStatus(STATUS.RESOLVED);
+    };
+
+    setStatus(STATUS.PENDING);
     dispatch(
       APIActions.get({
         key: `GET_LEAPP_REPORT_LIST_${data.id}`,
         url: `/api/job_invocations/${data.id}/preupgrade_reports`,
         handleSuccess: listResponse => {
           if (!isMounted) return;
-          const listPayload = listResponse.data || listResponse;
-          const summary = listPayload.results?.[0];
+          const summary = (listResponse.data || listResponse).results?.[0];
           if (summary?.id) {
             dispatch(
               APIActions.get({
                 key: `GET_LEAPP_REPORT_DETAIL_${summary.id}`,
                 url: `/api/preupgrade_reports/${summary.id}`,
-                handleSuccess: detailResponse => {
-                  if (isMounted) {
-                    const detailPayload = detailResponse.data || detailResponse;
-                    setReportData(detailPayload);
-                    setStatus(STATUS.RESOLVED);
-                  }
-                },
-                handleError: err => {
-                  if (isMounted) {
-                    setError(err);
-                    setStatus(STATUS.ERROR);
-                  }
-                },
+                handleSuccess: detailResponse => succeed(detailResponse),
+                handleError: err => fail(err),
               })
             );
-          } else if (isMounted) {
-            setReportData({});
-            setStatus(STATUS.RESOLVED);
-          }
-        },
-        handleError: err => {
-          if (isMounted) {
-            setError(err);
-            setStatus(STATUS.ERROR);
+            return;
           }
+          succeed(null);
         },
+        handleError: err => fail(err),
       })
     );
 
     return () => {
       isMounted = false;
     };
-  }, [isReportExpanded, data.id, isLeappJob, reportData, dispatch]);
+  }, [isReportExpanded, data.id, isLeappJob, dispatch, jobStatusLabel]);
 
   // eslint-disable-next-line camelcase
-  const entries = reportData?.preupgrade_report_entries || [];
-  const pagedEntries = entriesPage(entries, pagination);
+  const entries = useMemo(() => reportData?.preupgrade_report_entries || [], [
+    reportData,
+  ]);
 
-  const handleParamsChange = newParams => {
+  const pagedEntries = useMemo(
+    () => entriesPage(entries, pagination),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [entries, pagination.page, pagination.perPage]
+  );
+
+  const getHostId = useCallback(
+    entry =>
+      entry.host_id ||
+      entry.hostId ||
+      // eslint-disable-next-line camelcase
+      reportData?.host_id ||
+      reportData?.host?.id ||
+      // eslint-disable-next-line camelcase
+      data?.targeting?.host_id,
+    [reportData, data]
+  );
+
+  const handleParamsChange = useCallback(newParams => {
     setPagination(prev => ({
       ...prev,
       page: newParams.page || prev.page,
       perPage: newParams.per_page || prev.perPage,
     }));
     setExpandedRowIds(new Set());
-  };
+  }, []);
 
-  const toggleRowExpansion = (id, isExpanding) => {
+  const toggleRowExpansion = useCallback((id, isExpanding) => {
     setExpandedRowIds(prev => {
-      const newSet = new Set(prev);
-      if (isExpanding) {
-        newSet.add(id);
-      } else {
-        newSet.delete(id);
-      }
-      return newSet;
+      const next = new Set(prev);
+      if (isExpanding) next.add(id);
+      else next.delete(id);
+      return next;
     });
-  };
+  }, []);
+
+  const { inclusionSet, exclusionSet, ...selectAllOptions } = useBulkSelect({
+    results: pagedEntries,
+    metadata: {
+      total: entries.length,
+      page: pagination.page,
+      selectable: entries.length,
+    },
+    initialSearchQuery: '',
+  });
+
+  const {
+    selectAll,
+    selectPage,
+    selectNone,
+    selectOne,
+    areAllRowsSelected,
+    isSelected,
+  } = selectAllOptions;
+
+  const rawSelectedIds =
+    areAllRowsSelected() || exclusionSet.size > 0
+      ? entries.map(e => e.id).filter(id => !exclusionSet.has(id))
+      : Array.from(inclusionSet);
+
+  const validFixableIds = useMemo(
+    () => entries.filter(isRowFixable).map(e => e.id),
+    [entries]
+  );
+
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const selectedIds = useMemo(
+    () => rawSelectedIds.filter(id => validFixableIds.includes(id)),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [rawSelectedIds.join(','), validFixableIds]
+  );
+
+  const pagedFixableEntries = useMemo(() => pagedEntries.filter(isRowFixable), [
+    pagedEntries,
+  ]);
+
+  const areAllPageFixableSelected =
+    pagedFixableEntries.length > 0 &&
+    pagedFixableEntries.every(e => selectedIds.includes(e.id));
+
+  const areAllFixableSelected =
+    validFixableIds.length > 0 &&
+    validFixableIds.every(id => selectedIds.includes(id));
 
   const areAllRowsExpanded =
     pagedEntries.length > 0 &&
     pagedEntries.every(entry => expandedRowIds.has(entry.id));
 
-  const onExpandAll = () => {
-    setExpandedRowIds(() => {
-      if (areAllRowsExpanded) {
-        return new Set();
-      }
-      return new Set(pagedEntries.map(e => e.id));
-    });
-  };
+  const onExpandAll = useCallback(() => {
+    setExpandedRowIds(
+      areAllRowsExpanded ? new Set() : new Set(pagedEntries.map(e => e.id))
+    );
+  }, [areAllRowsExpanded, pagedEntries]);
+
+  const [columnKeys, keysToColumnNames] = useMemo(
+    () => getColumnHelpers(columns),
+    [columns]
+  );
+
+  const hostIdsForSelected = useMemo(
+    () =>
+      Array.from(
+        new Set(
+          entries
+            .filter(e => selectedIds.includes(e.id))
+            .map(getHostId)
+            .filter(Boolean)
+        )
+      ),
+    [entries, selectedIds, getHostId]
+  );
 
-  const [columnKeys, keysToColumnNames] = getColumnHelpers(columns);
+  const allHostIds = useMemo(
+    () => Array.from(new Set(entries.map(getHostId).filter(Boolean))),
+    [entries, getHostId]
+  );
 
   if (!isLeappJob) return null;
 
+  const isFixSelectedDisabled =
+    validFixableIds.length === 0 ||
+    selectedIds.length === 0 ||
+    hostIdsForSelected.length === 0;
+
   return (
     <ExpandableSection
-      className="leapp-report-section"
       isExpanded={isReportExpanded}
       onToggle={(_event, val) => setIsReportExpanded(val)}
       toggleText={__('Leapp preupgrade report')}
     >
+      {entries.length > 0 && status === STATUS.RESOLVED && (
+        <Toolbar ouiaId="leapp-report-toolbar">
+          <ToolbarContent>
+            <ToolbarGroup variant="filter-group">
+              <ToolbarItem>
+                <SelectAllCheckbox
+                  selectAll={selectAll}
+                  selectPage={selectPage}
+                  selectNone={selectNone}
+                  selectedCount={selectedIds.length}
+                  pageRowCount={pagedFixableEntries.length}
+                  totalCount={validFixableIds.length}
+                  areAllRowsOnPageSelected={areAllPageFixableSelected}
+                  areAllRowsSelected={areAllFixableSelected}
+                />
+              </ToolbarItem>
+            </ToolbarGroup>
+            <ToolbarGroup
+              align={{ default: 'alignRight' }}
+              variant="button-group"
+            >
+              <ToolbarItem>
+                <Button
+                  variant="secondary"
+                  isDisabled={isFixSelectedDisabled}
+                  onClick={() =>
+                    submitJobInvocation(
+                      dispatch,
+                      setError,
+                      'leapp_remediation_plan',
+                      hostIdsForSelected,
+                      selectedIds.join(',')
+                    )
+                  }
+                  ouiaId="fix-selected-button"
+                >
+                  {__('Fix Selected')}
+                </Button>
+              </ToolbarItem>
+              <ToolbarItem>
+                <Button
+                  variant="primary"
+                  isDisabled={allHostIds.length === 0}
+                  onClick={() =>
+                    submitJobInvocation(
+                      dispatch,
+                      setError,
+                      'leapp_upgrade',
+                      allHostIds
+                    )
+                  }
+                  ouiaId="run-upgrade-button"
+                >
+                  {__('Run Upgrade')}
+                </Button>
+              </ToolbarItem>
+            </ToolbarGroup>
+          </ToolbarContent>
+        </Toolbar>
+      )}
+
       <Table
         ouiaId="leapp-report-table"
         columns={columns}
@@ -174,20 +385,24 @@ const PreupgradeReportsTable = ({ data = {} }) => {
         errorMessage={
           status === STATUS.ERROR && error?.message ? error.message : null
         }
-        showCheckboxes={false}
+        showCheckboxes
         refreshData={() => {}}
         isDeleteable={false}
         emptyMessage={__('The preupgrade report shows no issues.')}
         setParams={handleParamsChange}
         childrenOutsideTbody
         onExpandAll={onExpandAll}
-        // Inverted per PatternFly implementation to ensure correct toggle icon state
         areAllRowsExpanded={!areAllRowsExpanded}
       >
         {pagedEntries.map((entry, rowIndex) => {
           const isRowExpanded = expandedRowIds.has(entry.id);
+
           return (
-            <Tbody key={entry.id} isExpanded={isRowExpanded}>
+            <Tbody
+              key={entry.id}
+              isExpanded={isRowExpanded}
+              className={isRowExpanded ? 'leapp-expanded-tbody' : ''}
+            >
               <Tr ouiaId={`table-row-${rowIndex}`}>
                 <Td
                   expand={{
@@ -197,6 +412,12 @@ const PreupgradeReportsTable = ({ data = {} }) => {
                       toggleRowExpansion(entry.id, isOpen),
                   }}
                 />
+                <RowSelectTd
+                  rowData={entry}
+                  selectOne={selectOne}
+                  isSelected={id => isRowFixable(entry) && isSelected(id)}
+                  isSelectable={isRowFixable}
+                />
                 {columnKeys.map(key => (
                   <Td key={key} dataLabel={keysToColumnNames[key]}>
                     {columns[key].wrapper
@@ -209,7 +430,7 @@ const PreupgradeReportsTable = ({ data = {} }) => {
                 isExpanded={isRowExpanded}
                 ouiaId={`table-row-details-${rowIndex}`}
               >
-                <Td colSpan={columnKeys.length + 1}>
+                <Td colSpan={columnKeys.length + 2}>
                   <ExpandableRowContent>
                     {isRowExpanded && <ReportDetails entry={entry} />}
                   </ExpandableRowContent>
@@ -226,7 +447,13 @@ const PreupgradeReportsTable = ({ data = {} }) => {
 PreupgradeReportsTable.propTypes = {
   data: PropTypes.shape({
     id: PropTypes.number,
+    // eslint-disable-next-line camelcase
     template_name: PropTypes.string,
+    // eslint-disable-next-line camelcase
+    status_label: PropTypes.string,
+    targeting: PropTypes.shape({
+      host_id: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+    }),
   }),
 };
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foreman_leapp
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Foreman Leapp team
 bindir: bin
 cert_chain: []
-date: 2026-03-10 00:00:00.000000000 Z
+date: 2026-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foreman_remote_execution
@@ -37,20 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.2'
 description: A Foreman plugin to support inplace RHEL upgrades with Leapp utility.
 email:
 - foreman-dev@googlegroups.com
@@ -140,7 +126,6 @@ files:
 - webpack/components/PreupgradeReports/__tests__/PreupgradeReportsHelpers.test.js
 - webpack/components/PreupgradeReports/__tests__/PreupgradeReportsReducer.test.js
 - webpack/components/PreupgradeReports/__tests__/PreupgradeReportsSelectors.test.js
-- webpack/components/PreupgradeReports/__tests__/__snapshots__/PreupgradeReports.test.js.snap
 - webpack/components/PreupgradeReports/__tests__/__snapshots__/PreupgradeReportsHelpers.test.js.snap
 - webpack/components/PreupgradeReports/__tests__/__snapshots__/PreupgradeReportsReducer.test.js.snap
 - webpack/components/PreupgradeReports/__tests__/__snapshots__/PreupgradeReportsSelectors.test.js.snap
@@ -214,7 +199,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A Foreman plugin for Leapp utility.
 test_files:

data/webpack/components/PreupgradeReports/__tests__/__snapshots__/PreupgradeReports.test.js.snap

@@ -1,121 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`PreupgradeReports should render error 1`] = `
-<MessageBox
-  icontype="error-circle-o"
-  key="preupgrade-reports-error"
-  msg="Could not retrieve data: Internal server error - Well, this is embarassing"
-/>
-`;
-
-exports[`PreupgradeReports should render when loaded with reports 1`] = `
-<LoadingState
-  additionalClasses=""
-  loading={false}
-  loadingText="Loading"
-  size="lg"
-  timeout={300}
->
-  <PreupgradeReports
-    csrfToken="xyz"
-    error={Object {}}
-    getPreupgradeReports={[Function]}
-    loading={false}
-    newJobInvocationUrl="/job_invocations/new"
-    preupgradeReports={
-      Array [
-        Object {
-          "entries": Array [
-            Object {
-              "flags": Array [],
-              "hostname": "host.example.com",
-              "id": 42,
-              "severity": "info",
-              "title": "Fix me!",
-            },
-            Object {
-              "flags": Array [],
-              "hostname": "host.example.com",
-              "id": 43,
-              "severity": "medium",
-              "title": "I am broken too",
-            },
-          ],
-          "hostId": 5,
-        },
-        Object {
-          "entries": Array [
-            Object {
-              "flags": Array [
-                "inhibitor",
-              ],
-              "hostname": "foo.example.com",
-              "id": 44,
-              "severity": "high",
-              "title": "Octocat is not happy",
-            },
-            Object {
-              "flags": Array [],
-              "hostname": "foo.example.com",
-              "id": 45,
-              "severity": "low",
-              "title": "Not enough credits",
-            },
-            Object {
-              "flags": Array [],
-              "hostname": "foo.example.com",
-              "id": 46,
-              "severity": "medium",
-              "title": "SELinux is turned off",
-            },
-            Object {
-              "flags": Array [],
-              "hostname": "foo.example.com",
-              "id": 47,
-              "severity": "medium",
-              "title": "Root password is too short",
-            },
-            Object {
-              "flags": Array [],
-              "hostname": "foo.example.com",
-              "id": 49,
-              "severity": "high",
-              "title": "No chocolate chip cookies in cookie jar",
-            },
-          ],
-          "hostId": 6,
-        },
-      ]
-    }
-    reportsExpected={true}
-  />
-</LoadingState>
-`;
-
-exports[`PreupgradeReports should render when loaded without reports 1`] = `
-<LoadingState
-  additionalClasses=""
-  loading={false}
-  loadingText="Loading"
-  size="lg"
-  timeout={300}
->
-  <NoReports
-    reportsExpected={true}
-  />
-</LoadingState>
-`;
-
-exports[`PreupgradeReports should render when loading 1`] = `
-<LoadingState
-  additionalClasses=""
-  loading={true}
-  loadingText="Loading"
-  size="lg"
-  timeout={300}
->
-  <NoReports
-    reportsExpected={false}
-  />
-</LoadingState>
-`;