@centreon/ui 24.4.1-sync-release-34022.1 → 24.4.1-test-code-coverage.0

package/src/Graph/LineChart/models.ts

@@ -88,7 +88,6 @@ export interface LineChartProps {
   displayAnchor?: DisplayAnchor;
   header?: LineChartHeader;
   height?: number | null;
-  loading: boolean;
   timeShiftZones?: InteractedZone;
   tooltip?: Tooltip;
   width: number;
@@ -144,3 +143,15 @@ export interface GetDate {
   timeSeries: Array<TimeValue>;
   xScale: ScaleLinear<number, number>;
 }
+
+export interface GraphTooltipData {
+  date: string;
+  highlightedMetricId: number | null;
+  metrics: Array<{
+    color: string;
+    id: number;
+    name: string;
+    unit: string;
+    value: number;
+  }>;
+}

package/src/Graph/PieChart/PieChart.cypress.spec.tsx

@@ -0,0 +1,154 @@
+import numeral from 'numeral';
+
+import PieChart from './PieChart';
+import { ArcType, PieProps } from './models';
+
+const defaultData = [
+  { color: '#88B922', label: 'Ok', value: 148 },
+  { color: '#999999', label: 'Unknown', value: 13 },
+  { color: '#F7931A', label: 'Warning', value: 16 },
+  { color: '#FF6666', label: 'Down', value: 62 }
+];
+
+const total = Math.floor(
+  defaultData.reduce((acc, { value }) => acc + value, 0)
+);
+
+const TooltipContent = ({ label, color, value }: ArcType): JSX.Element => {
+  return (
+    <div data-testid={`tooltip-${label}`} style={{ color }}>
+      {label} : {value}
+    </div>
+  );
+};
+
+const initialize = ({
+  width = '500px',
+  height = '500px',
+  data = defaultData,
+  ...args
+}: Omit<PieProps, 'data'> & {
+  data?;
+  height?: string;
+  width?: string;
+}): void => {
+  cy.mount({
+    Component: (
+      <div style={{ height, width }}>
+        <PieChart {...args} data={data} />
+      </div>
+    )
+  });
+};
+
+describe('Pie chart', () => {
+  it('renders pie chart correctly with provided data', () => {
+    initialize({});
+
+    defaultData.forEach(({ label }) => {
+      cy.findByTestId(label).should('be.visible');
+    });
+
+    cy.makeSnapshot();
+  });
+
+  it('adjusts size based on the provided width and height', () => {
+    initialize({ displayLegend: false, height: '300px', width: '300px' });
+
+    cy.findByTestId('pieChart')
+      .should('have.css', 'width', '300px')
+      .and('have.css', 'height', '300px');
+
+    cy.makeSnapshot();
+  });
+
+  it('renders as a donut when variant is set to "donut"', () => {
+    initialize({ variant: 'donut' });
+    cy.get('[data-variant="donut"]').should('exist');
+
+    cy.makeSnapshot();
+  });
+
+  it('renders as a pie when variant is set to "pie"', () => {
+    initialize({ variant: 'pie' });
+    cy.get('[data-variant="pie"]').should('exist');
+
+    cy.makeSnapshot();
+  });
+
+  it('displays tooltip with correct information on hover', () => {
+    initialize({ TooltipContent });
+
+    defaultData.forEach(({ label, value }) => {
+      cy.findByTestId(label).trigger('mouseover', { force: true });
+
+      cy.findByTestId(`tooltip-${label}`)
+        .should('contain', label)
+        .and('contain', numeral(value).format('0a').toUpperCase());
+    });
+
+    cy.makeSnapshot();
+  });
+  it('conditionally displays values on arcs based on displayValues prop', () => {
+    initialize({ displayValues: true });
+    defaultData.forEach(({ value }, index) => {
+      cy.findAllByTestId('value')
+        .eq(index)
+        .children()
+        .eq(0)
+        .should('have.text', value);
+    });
+
+    initialize({ displayValues: false });
+    cy.findAllByTestId('value').should('not.exist');
+
+    cy.makeSnapshot();
+  });
+
+  it('displays values on arcs in percentage unit when displayValues is set to true and unit to percentage', () => {
+    initialize({ displayValues: true, unit: 'percentage' });
+    defaultData.forEach(({ value }, index) => {
+      cy.findAllByTestId('value')
+        .eq(index)
+        .children()
+        .eq(0)
+        .should('have.text', `${((value * 100) / total).toFixed(1)}%`);
+    });
+
+    cy.makeSnapshot();
+  });
+
+  it('displays Legend component based on displayLegend prop', () => {
+    initialize({ displayLegend: true });
+    cy.findByTestId('Legend').should('be.visible');
+
+    initialize({ displayLegend: false });
+    cy.findByTestId('Legend').should('not.exist');
+
+    cy.makeSnapshot();
+  });
+
+  it('displays the title when the title is giving', () => {
+    initialize({ title: 'host' });
+    cy.findByTestId('Title').should('be.visible');
+
+    initialize({});
+    cy.findByTestId('Title').should('not.exist');
+
+    cy.makeSnapshot();
+  });
+
+  it('adjusts outer radius when chart dimensions are too small', () => {
+    initialize({
+      displayLegend: false,
+      height: '120px',
+      title: 'hosts',
+      variant: 'donut',
+      width: '120px'
+    });
+
+    cy.get('[data-variant="donut"]').should('have.css', 'width', '100px');
+
+    cy.makeSnapshot();
+  });
+});

package/src/Graph/PieChart/PieChart.stories.tsx

@@ -0,0 +1,194 @@
+import { Meta, StoryObj } from '@storybook/react';
+
+import { ArcType } from './models';
+
+import { PieChart } from '.';
+
+const data = [
+  { color: '#88B922', label: 'Ok', value: 148 },
+  { color: '#999999', label: 'Unknown', value: 13 },
+  { color: '#F7931A', label: 'Warning', value: 16 },
+  { color: '#FF6666', label: 'Down', value: 62 }
+];
+
+const dataWithBigNumbers = [
+  { color: '#88B922', label: 'Ok', value: 260000 },
+  { color: '#999999', label: 'Unknown', value: 1010900 },
+  { color: '#F7931A', label: 'Warning', value: 63114 },
+  { color: '#FF6666', label: 'Down', value: 122222 }
+];
+
+const meta: Meta<typeof PieChart> = {
+  component: PieChart
+};
+
+export default meta;
+type Story = StoryObj<typeof PieChart>;
+
+const Template = (args): JSX.Element => {
+  return (
+    <div style={{ height: '350px', width: '350px' }}>
+      <PieChart {...args} />
+    </div>
+  );
+};
+
+export const Pie: Story = {
+  args: {
+    data,
+    title: 'hosts'
+  },
+  render: Template
+};
+
+export const Donut: Story = {
+  args: {
+    data,
+    title: 'hosts',
+    variant: 'donut'
+  },
+  render: Template
+};
+
+export const WithPencentage: Story = {
+  args: {
+    data,
+    title: 'hosts',
+    unit: 'percentage',
+    variant: 'donut'
+  },
+  render: Template
+};
+
+export const WithBigNumbers: Story = {
+  args: {
+    data: dataWithBigNumbers,
+    title: 'hosts',
+    unit: 'number',
+    variant: 'donut'
+  },
+  render: Template
+};
+
+export const WithoutLegend: Story = {
+  args: {
+    data,
+    displayLegend: false,
+    title: 'hosts',
+    variant: 'donut'
+  },
+  render: Template
+};
+
+export const DonutWithoutTitle: Story = {
+  args: {
+    data,
+    variant: 'donut'
+  },
+  render: Template
+};
+
+export const PieWithoutTitle: Story = {
+  args: {
+    data
+  },
+  render: Template
+};
+
+export const DonutWithDisplayedValues: Story = {
+  args: {
+    data,
+    displayValues: true,
+    variant: 'donut'
+  },
+  render: Template
+};
+
+export const PieWithDisplayedValues: Story = {
+  args: {
+    data,
+    displayValues: true
+  },
+  render: Template
+};
+
+const TooltipContent = ({ label, color, value }: ArcType): JSX.Element => {
+  return (
+    <div style={{ color }}>
+      {label} : {value}
+    </div>
+  );
+};
+
+export const PieWithTooltip: Story = {
+  args: {
+    TooltipContent,
+    data,
+    displayValues: true,
+    unit: 'percentage'
+  },
+  render: Template
+};
+
+export const DonutWithTooltip: Story = {
+  args: {
+    TooltipContent,
+    data,
+    displayValues: true,
+    variant: 'donut'
+  },
+  render: Template
+};
+
+const TemplateForSmallDimensions = (args): JSX.Element => {
+  return (
+    <div style={{ height: '130px', width: '130px' }}>
+      <PieChart {...args} />
+    </div>
+  );
+};
+
+export const PieWithSmallDimensions: Story = {
+  args: {
+    data,
+    displayLegend: false
+  },
+  render: TemplateForSmallDimensions
+};
+
+export const DonutWithSmallDimensions: Story = {
+  args: {
+    data,
+    displayLegend: false,
+    title: 'hosts',
+    variant: 'donut'
+  },
+  render: TemplateForSmallDimensions
+};
+
+const dataWidthOneNoZeroValue = [
+  { color: '#88B922', label: 'Ok', value: 13 },
+  { color: '#999999', label: 'Unknown', value: 0 },
+  { color: '#F7931A', label: 'Warning', value: 0 },
+  { color: '#FF6666', label: 'Down', value: 0 }
+];
+
+export const PieWithOneNoZeroValue: Story = {
+  args: {
+    data: dataWidthOneNoZeroValue,
+    displayLegend: false,
+    title: 'hosts',
+    variant: 'pie'
+  },
+  render: Template
+};
+
+export const donutWithOneNoZeroValue: Story = {
+  args: {
+    data: dataWidthOneNoZeroValue,
+    displayLegend: false,
+    title: 'hosts',
+    variant: 'donut'
+  },
+  render: Template
+};

package/src/Graph/PieChart/PieChart.styles.ts

@@ -0,0 +1,39 @@
+import { lt } from 'ramda';
+import { makeStyles } from 'tss-react/mui';
+
+export const usePieStyles = makeStyles<{ svgSize: number }>()(
+  (theme, { svgSize }) => ({
+    container: {
+      alignItems: 'center',
+      display: 'flex',
+      gap: theme.spacing(2),
+      justifyContent: 'center'
+    },
+    pieChartTooltip: {
+      backgroundColor: theme.palette.background.paper,
+      color: theme.palette.text.primary,
+      padding: 0,
+      position: 'relative'
+    },
+    svgContainer: {
+      alignItems: 'center',
+      backgroundColor: theme.palette.background.panelGroups,
+      borderRadius: '100%',
+      display: 'flex',
+      justifyContent: 'center'
+    },
+    svgWrapper: {
+      alignItems: 'center',
+      display: 'flex',
+      flexDirection: 'column',
+      gap: theme.spacing(1),
+      justifyContent: 'center'
+    },
+    title: {
+      fontSize: lt(svgSize, 150)
+        ? theme.typography.body1.fontSize
+        : theme.typography.h6.fontSize,
+      fontWeight: theme.typography.fontWeightMedium
+    }
+  })
+);

package/src/Graph/PieChart/PieChart.tsx

@@ -0,0 +1,14 @@
+import { ParentSize } from '../..';
+
+import ResponsivePie from './ResponsivePie';
+import { PieProps } from './models';
+
+const PieChart = (props: PieProps): JSX.Element => (
+  <ParentSize>
+    {({ width, height }) => (
+      <ResponsivePie {...props} height={height} width={width} />
+    )}
+  </ParentSize>
+);
+
+export default PieChart;

package/src/Graph/PieChart/ResponsivePie.tsx

@@ -0,0 +1,243 @@
+import { useRef } from 'react';
+
+import { Pie } from '@visx/shape';
+import { Group } from '@visx/group';
+import { Text } from '@visx/text';
+import numeral from 'numeral';
+import { always, equals, gt, ifElse, lt } from 'ramda';
+import { useTranslation } from 'react-i18next';
+
+import { useTheme } from '@mui/material';
+
+import { Tooltip } from '../../components';
+import { Legend as LegendComponent } from '../Legend';
+import { LegendProps } from '../Legend/models';
+import { getValueByUnit } from '../common/utils';
+
+import { PieProps } from './models';
+import { usePieStyles } from './PieChart.styles';
+import { useResponsivePie } from './useResponsivePie';
+
+const DefaultLengd = ({ scale, direction }: LegendProps): JSX.Element => (
+  <LegendComponent direction={direction} scale={scale} />
+);
+
+type Placement = 'left' | 'right' | 'top' | 'bottom';
+
+const getTooltipPlacement = ({ radianX, radianY }): Placement => {
+  if (gt(Math.abs(radianX), Math.abs(radianY))) {
+    return ifElse<[b: number], Placement, Placement>(
+      lt(0),
+      always<Placement>('right'),
+      always<Placement>('left')
+    )(radianX);
+  }
+
+  return ifElse<[b: number], Placement, Placement>(
+    lt(0),
+    always<Placement>('bottom'),
+    always<Placement>('top')
+  )(radianY);
+};
+
+const ResponsivePie = ({
+  title,
+  variant = 'pie',
+  width,
+  height,
+  data,
+  unit = 'number',
+  Legend = DefaultLengd,
+  displayLegend = true,
+  innerRadius: defaultInnerRadius = 40,
+  onArcClick,
+  displayValues,
+  TooltipContent,
+  legendDirection = 'column'
+}: PieProps & { height: number; width: number }): JSX.Element => {
+  const { t } = useTranslation();
+  const theme = useTheme();
+
+  const legendRef = useRef(null);
+  const titleRef = useRef(null);
+
+  const {
+    half,
+    legendScale,
+    svgContainerSize,
+    svgSize,
+    svgWrapperWidth,
+    total,
+    innerRadius,
+    isContainsExactlyOneNonZeroValue
+  } = useResponsivePie({
+    data,
+    defaultInnerRadius,
+    height,
+    legendRef,
+    titleRef,
+    unit,
+    width
+  });
+
+  const { classes } = usePieStyles({ svgSize });
+
+  return (
+    <div
+      className={classes.container}
+      style={{
+        height,
+        width
+      }}
+    >
+      <div
+        className={classes.svgWrapper}
+        style={{
+          height,
+          width: svgWrapperWidth
+        }}
+      >
+        {equals(variant, 'pie') && title && (
+          <div className={classes.title} data-testid="Title" ref={titleRef}>
+            {`${numeral(total).format('0a').toUpperCase()} `} {t(title)}
+          </div>
+        )}
+        <div
+          className={classes.svgContainer}
+          data-testid="pieChart"
+          style={{
+            height: svgContainerSize,
+            width: svgContainerSize
+          }}
+        >
+          <svg data-variant={variant} height={svgSize} width={svgSize}>
+            <Group left={half} top={half}>
+              <Pie
+                cornerRadius={4}
+                data={data}
+                innerRadius={() => {
+                  return equals(variant, 'pie') ? 0 : half - innerRadius;
+                }}
+                outerRadius={half}
+                pieValue={(items) => items.value}
+              >
+                {(pie) => {
+                  return pie.arcs.map((arc) => {
+                    const [centroidX, centroidY] = pie.path.centroid(arc);
+                    const midAngle = Math.atan2(centroidY, centroidX);
+
+                    const labelRadius = half * 0.8;
+
+                    const labelX = Math.cos(midAngle) * labelRadius;
+                    const labelY = Math.sin(midAngle) * labelRadius;
+
+                    const angle = arc.endAngle - arc.startAngle;
+                    const minAngle = 0.2;
+
+                    const x = equals(variant, 'donut') ? centroidX : labelX;
+                    const y = equals(variant, 'donut') ? centroidY : labelY;
+
+                    const onClick = (): void => {
+                      onArcClick?.(arc.data);
+                    };
+
+                    return (
+                      <Tooltip
+                        hasCaret
+                        classes={{
+                          tooltip: classes.pieChartTooltip
+                        }}
+                        followCursor={false}
+                        key={arc.data.label}
+                        label={
+                          TooltipContent && (
+                            <TooltipContent
+                              color={arc.data.color}
+                              label={arc.data.label}
+                              title={title}
+                              total={total}
+                              value={arc.data.value}
+                            />
+                          )
+                        }
+                        leaveDelay={200}
+                        placement={getTooltipPlacement({
+                          radianX: Math.cos(midAngle),
+                          radianY: Math.sin(midAngle)
+                        })}
+                      >
+                        <g data-testid={arc.data.label} onClick={onClick}>
+                          <path
+                            cursor="pointer"
+                            d={pie.path(arc) as string}
+                            fill={arc.data.color}
+                          />
+                          {displayValues &&
+                            !isContainsExactlyOneNonZeroValue &&
+                            angle > minAngle && (
+                              <Text
+                                data-testid="value"
+                                dy=".33em"
+                                fill="#000"
+                                fontSize={12}
+                                fontWeight={600}
+                                pointerEvents="none"
+                                textAnchor="middle"
+                                x={x}
+                                y={y}
+                              >
+                                {getValueByUnit({
+                                  total,
+                                  unit,
+                                  value: arc.data.value
+                                })}
+                              </Text>
+                            )}
+                        </g>
+                      </Tooltip>
+                    );
+                  });
+                }}
+              </Pie>
+              {equals(variant, 'donut') && title && (
+                <>
+                  <Text
+                    className={classes.title}
+                    dy={lt(svgSize, 150) ? -10 : -15}
+                    fill={theme.palette.text.primary}
+                    textAnchor="middle"
+                  >
+                    {numeral(total).format('0a').toUpperCase()}
+                  </Text>
+                  <Text
+                    className={classes.title}
+                    data-testid="Title"
+                    dy={lt(svgSize, 150) ? 10 : 15}
+                    fill={theme.palette.text.primary}
+                    textAnchor="middle"
+                  >
+                    {t(title)}
+                  </Text>
+                </>
+              )}
+            </Group>
+          </svg>
+        </div>
+      </div>
+      {displayLegend && (
+        <div data-testid="Legend" ref={legendRef}>
+          <Legend
+            data={data}
+            direction={legendDirection}
+            scale={legendScale}
+            title={title}
+            total={total}
+            unit={unit}
+          />
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default ResponsivePie;

package/src/Graph/PieChart/index.ts

@@ -0,0 +1 @@
+export { default as PieChart } from './PieChart';

package/src/Graph/PieChart/models.ts

@@ -0,0 +1,19 @@
+export interface ArcType {
+  color: string;
+  label: string;
+  value: number;
+}
+
+export interface PieProps {
+  Legend?: ({ scale, direction, data, title, total, unit }) => JSX.Element;
+  TooltipContent?: (arcData) => JSX.Element | boolean | null;
+  data: Array<ArcType>;
+  displayLegend?: boolean;
+  displayValues?: boolean;
+  innerRadius?: number;
+  legendDirection?: 'row' | 'column';
+  onArcClick?: (ardata) => void;
+  title?: string;
+  unit?: 'percentage' | 'number';
+  variant?: 'pie' | 'donut';
+}