Paginate filter sort pccmin results

src/components/computing-status/use-all-computing-status.ts

@@ -109,6 +109,7 @@ export const dynamicSimulationResultInvalidations = [NotificationType.DYNAMIC_SI
 export const dynamicSecurityAnalysisResultInvalidations = [NotificationType.DYNAMIC_SECURITY_ANALYSIS_RESULT];
 export const voltageInitResultInvalidations = [NotificationType.VOLTAGE_INIT_RESULT];
 export const stateEstimationResultInvalidations = [NotificationType.STATE_ESTIMATION_RESULT];
+export const pccMinResultInvalidations = [NotificationType.PCC_MIN_RESULT];
 
 // this hook loads all current computation status into redux then keeps them up to date according to notifications
 export const useAllComputingStatus = (studyUuid: UUID, currentNodeUuid: UUID, currentRootNetworkUuid: UUID): void => {

src/components/graph/tree-node.type.ts

@@ -60,6 +60,7 @@ export type NetworkModificationNodeData = AbstractNode & {
     sensitivityAnalysisResultUuid?: UUID;
     dynamicSimulationResultUuid?: UUID;
     stateEstimationResultUuid?: UUID;
+    pccMinResultUuid?: UUID;
     nodeBuildStatus?: NodeBuildStatus;
     nodeType?: NetworkModificationNodeType;
 };

src/components/result-view-tab.tsx

@@ -29,6 +29,7 @@ import { ComputingType, type MuiStyles, usePrevious } from '@gridsuite/commons-u
 import { useParameterState } from './dialogs/parameters/use-parameters-state';
 import { IService } from './result-view-tab.type';
 import { CurrentTreeNode } from './graph/tree-node.type';
+import { PccMinResultTab } from './results/pccmin/pcc-min-result-tab';
 
 const styles = {
     table: {
@@ -85,6 +86,7 @@ export const ResultViewTab: FunctionComponent<IResultViewTabProps> = ({
     const voltageInitAvailability = useOptionalServiceStatus(OptionalServicesNames.VoltageInit);
     const shortCircuitAvailability = useOptionalServiceStatus(OptionalServicesNames.ShortCircuit);
     const stateEstimationAvailability = useOptionalServiceStatus(OptionalServicesNames.StateEstimation);
+    const pccMinAvailability = useOptionalServiceStatus(OptionalServicesNames.PccMin);
 
     const renderLoadFlowResult = useMemo(() => {
         return (
@@ -186,6 +188,18 @@ export const ResultViewTab: FunctionComponent<IResultViewTabProps> = ({
         );
     }, [studyUuid, currentNode, currentRootNetworkUuid]);
 
+    const renderPccMinResult = useMemo(() => {
+        return (
+            <Paper sx={styles.analysisResult}>
+                <PccMinResultTab
+                    studyUuid={studyUuid}
+                    nodeUuid={currentNode?.id}
+                    currentRootNetworkUuid={currentRootNetworkUuid}
+                />
+            </Paper>
+        );
+    }, [currentNode?.id, currentRootNetworkUuid, studyUuid]);
+
     const services: IService[] = useMemo(() => {
         return [
             {
@@ -236,24 +250,32 @@ export const ResultViewTab: FunctionComponent<IResultViewTabProps> = ({
                 displayed: enableDeveloperMode && stateEstimationAvailability === OptionalServicesStatus.Up,
                 renderResult: renderStateEstimationResult,
             },
+            {
+                id: 'PccMin',
+                computingType: [ComputingType.PCC_MIN],
+                displayed: enableDeveloperMode && pccMinAvailability === OptionalServicesStatus.Up,
+                renderResult: renderPccMinResult,
+            },
         ].filter(({ displayed }: IService) => displayed);
     }, [
-        sensitivityAnalysisUnavailability,
+        renderLoadFlowResult,
         securityAnalysisAvailability,
-        dynamicSimulationAvailability,
-        dynamicSecurityAnalysisAvailability,
-        voltageInitAvailability,
+        renderSecurityAnalysisResult,
+        sensitivityAnalysisUnavailability,
+        renderSensitivityAnalysisResult,
         shortCircuitAvailability,
-        stateEstimationAvailability,
+        renderShortCircuitAnalysisResult,
         enableDeveloperMode,
+        dynamicSimulationAvailability,
         renderDynamicSimulationResult,
+        dynamicSecurityAnalysisAvailability,
         renderDynamicSecurityAnalysisResult,
-        renderSecurityAnalysisResult,
-        renderSensitivityAnalysisResult,
-        renderShortCircuitAnalysisResult,
+        voltageInitAvailability,
         renderVoltageInitResult,
-        renderLoadFlowResult,
+        stateEstimationAvailability,
         renderStateEstimationResult,
+        pccMinAvailability,
+        renderPccMinResult,
     ]);
 
     const resultTabIndexRedirection = useMemo<ResultTabIndexRedirection>(

src/components/results/common/utils.ts

@@ -7,6 +7,7 @@
 import { NA_Value } from 'components/custom-aggrid/utils/format-values-utils';
 import { IntlShape } from 'react-intl';
 import type { MuiStyles } from '@gridsuite/commons-ui';
+import { FilterConfig, SortConfig } from 'types/custom-aggrid-types';
 
 export const PERMANENT_LIMIT_NAME = 'permanent';
 
@@ -39,8 +40,48 @@ export enum FilterType {
     SUBSTATION_PROPERTY = 'substationProperty',
 }
 
+export interface Selector {
+    page: number;
+    size: number;
+    filter: FilterConfig[] | null;
+    sort: SortConfig[];
+}
+
 export const resultsStyles = {
     sldLink: {
         color: 'node.background',
     },
 } as const satisfies MuiStyles;
+
+export type Pageable = {
+    offset?: number;
+    pageNumber?: number;
+    pageSize?: number;
+    paged?: boolean;
+    sort?: Sort;
+    unpaged?: boolean;
+};
+
+export type Sort = {
+    empty?: boolean;
+    sorted?: boolean;
+    unsorted?: boolean;
+};
+
+export interface Page<ResultType> {
+    content: ResultType[];
+    pageable: Pageable;
+    last: boolean;
+    totalPages: number;
+    totalElements: number;
+    first: boolean;
+    size: number;
+    number: number;
+    sort: {
+        sorted: boolean;
+        empty: boolean;
+        unsorted: boolean;
+    };
+    numberOfElements: number;
+    empty: boolean;
+}

src/components/results/loadflow/load-flow-result-utils.ts

@@ -26,12 +26,16 @@ import { AppState } from 'redux/reducer';
 import RunningStatus from 'components/utils/running-status';
 import { CustomAggridComparatorFilter } from '../../custom-aggrid/custom-aggrid-filters/custom-aggrid-comparator-filter';
 import CustomAggridDurationFilter from '../../custom-aggrid/custom-aggrid-filters/custom-aggrid-duration-filter';
-import { FilterConfig, FilterType as AgGridFilterType } from '../../../types/custom-aggrid-types';
+import {
+    FilterConfig,
+    FilterType as AgGridFilterType,
+    textFilterParams,
+    numericFilterParams,
+} from '../../../types/custom-aggrid-types';
 import { CustomAggridAutocompleteFilter } from '../../custom-aggrid/custom-aggrid-filters/custom-aggrid-autocomplete-filter';
 import {
     ColumnContext,
     FILTER_DATA_TYPES,
-    FILTER_NUMBER_COMPARATORS,
     FILTER_TEXT_COMPARATORS,
     FilterEnumsType,
 } from '../../custom-aggrid/custom-aggrid-filters/custom-aggrid-filter.type';
@@ -74,21 +78,11 @@ export const FROM_COLUMN_TO_FIELD_LOADFLOW_RESULT: Record<string, string> = {
     distributedActivePower: 'distributedActivePower',
 };
 
-const textFilterParams = {
-    dataType: FILTER_DATA_TYPES.TEXT,
-    comparators: [FILTER_TEXT_COMPARATORS.STARTS_WITH, FILTER_TEXT_COMPARATORS.CONTAINS],
-};
-
 const translatedFilterParams = {
     dataType: FILTER_DATA_TYPES.TEXT,
     comparators: [FILTER_TEXT_COMPARATORS.EQUALS],
 };
 
-const numericFilterParams = {
-    dataType: FILTER_DATA_TYPES.NUMBER,
-    comparators: Object.values(FILTER_NUMBER_COMPARATORS),
-};
-
 export const mappingFields = (index: number): Record<string, string> => {
     switch (index) {
         case 0:

src/components/results/pccmin/pcc-min-result-tab.tsx

@@ -0,0 +1,114 @@
+/**
+ * Copyright (c) 2025, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { Box, LinearProgress, Tab, Tabs } from '@mui/material';
+import { FunctionComponent, useCallback, useEffect, useMemo, useState } from 'react';
+import { FormattedMessage } from 'react-intl';
+import { ComputationReportViewer } from '../common/computation-report-viewer';
+
+import { useSelector } from 'react-redux';
+import { AppState } from '../../../redux/reducer';
+import { ComputingType } from '@gridsuite/commons-ui';
+import { RunningStatus } from '../../utils/running-status';
+import { useOpenLoaderShortWait } from '../../dialogs/commons/handle-loader';
+import { RESULTS_LOADING_DELAY } from '../../network/constants';
+import GlobalFilterSelector from '../common/global-filter/global-filter-selector';
+import { EQUIPMENT_TYPES } from '../../utils/equipment-types';
+import useGlobalFilters, { isGlobalFilterParameter } from '../common/global-filter/use-global-filters';
+import { useGlobalFilterOptions } from '../common/global-filter/use-global-filter-options';
+import { PccMinResultTabProps } from './pcc-min-result.type';
+import { PccMinResult } from './pcc-min-result';
+
+export const PccMinResultTab: FunctionComponent<PccMinResultTabProps> = ({
+    studyUuid,
+    nodeUuid,
+    currentRootNetworkUuid,
+}) => {
+    const [resultOrLogIndex, setResultOrLogIndex] = useState(0);
+
+    const pccMinStatus = useSelector((state: AppState) => state.computingStatus[ComputingType.PCC_MIN]);
+
+    const RESULTS_TAB_INDEX = 0;
+    const LOGS_TAB_INDEX = 1;
+
+    const { globalFilters, handleGlobalFilterChange } = useGlobalFilters();
+    const { countriesFilter, voltageLevelsFilter, propertiesFilter } = useGlobalFilterOptions();
+
+    const handleSubTabChange = useCallback(
+        (event: React.SyntheticEvent, newIndex: number) => {
+            setResultOrLogIndex(newIndex);
+        },
+        [setResultOrLogIndex]
+    );
+
+    const openLoader = useOpenLoaderShortWait({
+        isLoading: pccMinStatus === RunningStatus.RUNNING,
+        delay: RESULTS_LOADING_DELAY,
+    });
+
+    const filterableEquipmentTypes: EQUIPMENT_TYPES[] = useMemo(() => {
+        return [EQUIPMENT_TYPES.VOLTAGE_LEVEL];
+    }, []);
+
+    useEffect(() => {
+        // Clear the globalfilter when tab changes
+        handleGlobalFilterChange([]);
+    }, [handleGlobalFilterChange]);
+
+    const globalFilterOptions = useMemo(
+        () => [...voltageLevelsFilter, ...countriesFilter, ...propertiesFilter],
+        [voltageLevelsFilter, countriesFilter, propertiesFilter]
+    );
+
+    return (
+        <Box sx={{ display: 'flex', flexDirection: 'column', height: '100%' }}>
+            <Box sx={{ display: 'flex', alignItems: 'center', gap: 2, flexShrink: 0, mb: 1 }}>
+                <Tabs value={resultOrLogIndex} onChange={handleSubTabChange}>
+                    <Tab label={<FormattedMessage id="Results" />} />
+                    <Tab label={<FormattedMessage id="ComputationResultsLogs" />} />
+                </Tabs>
+                {resultOrLogIndex === RESULTS_TAB_INDEX && (
+                    <Box sx={{ flex: 1 }}>
+                        <GlobalFilterSelector
+                            onChange={handleGlobalFilterChange}
+                            filters={globalFilterOptions}
+                            filterableEquipmentTypes={filterableEquipmentTypes}
+                            genericFiltersStrictMode
+                        />
+                    </Box>
+                )}
+            </Box>
+
+            <Box sx={{ flex: 1, display: 'flex', flexDirection: 'column', minHeight: 0 }}>
+                {resultOrLogIndex === RESULTS_TAB_INDEX && (
+                    <Box sx={{ flex: 1, minHeight: 0 }}>
+                        <PccMinResult
+                            studyUuid={studyUuid}
+                            nodeUuid={nodeUuid}
+                            currentRootNetworkUuid={currentRootNetworkUuid}
+                            globalFilters={isGlobalFilterParameter(globalFilters) ? globalFilters : undefined}
+                            customTablePaginationProps={{
+                                labelRowsPerPageId: 'muiTablePaginationLabelRowsPerPage',
+                            }}
+                        />
+                    </Box>
+                )}
+
+                {resultOrLogIndex === LOGS_TAB_INDEX && (
+                    <>
+                        {openLoader && <LinearProgress sx={{ height: 4, flexShrink: 0 }} />}
+                        {(pccMinStatus === RunningStatus.SUCCEED || pccMinStatus === RunningStatus.FAILED) && (
+                            <Box sx={{ flex: 1, minHeight: 0 }}>
+                                <ComputationReportViewer reportType={ComputingType.PCC_MIN} />
+                            </Box>
+                        )}
+                    </>
+                )}
+            </Box>
+        </Box>
+    );
+};