@centreon/ui 24.4.60 → 24.4.62

package/src/Graph/LineChart/Legend/LegendHeader.tsx

@@ -0,0 +1,93 @@
+import { includes, isEmpty, split } from 'ramda';
+
+import { Typography } from '@mui/material';
+
+import { EllipsisTypography, formatMetricValue } from '../../..';
+import { Line } from '../../common/timeSeries/models';
+import { Tooltip } from '../../../components';
+
+import { useLegendHeaderStyles } from './Legend.styles';
+import { LegendDisplayMode } from './models';
+import LegendContent from './LegendContent';
+
+interface Props {
+  color: string;
+  disabled?: boolean;
+  line: Line;
+  minMaxAvg?;
+  value?: string | null;
+}
+
+const LegendHeader = ({
+  line,
+  color,
+  disabled,
+  value,
+  minMaxAvg
+}: Props): JSX.Element => {
+  const { classes, cx } = useLegendHeaderStyles({ color });
+
+  const { unit, name, legend } = line;
+
+  const legendName = legend || name;
+  const hasUnit = !isEmpty(unit);
+  const unitName = `(${unit})`;
+  const metricName = includes('#', legendName)
+    ? split('#')(legendName)[1]
+    : legendName;
+
+  const getEndText = (): string => {
+    if (value) {
+      return value;
+    }
+
+    return hasUnit ? ` ${unitName}` : '';
+  };
+
+  return (
+    <div className={classes.container}>
+      <Tooltip
+        followCursor={false}
+        label={
+          minMaxAvg ? (
+            <div>
+              <Typography>{`${legendName} ${unitName}`}</Typography>
+              <div className={classes.minMaxAvgContainer}>
+                {minMaxAvg.map(({ label, value: subValue }) => (
+                  <LegendContent
+                    data={formatMetricValue({
+                      unit: line.unit,
+                      value: subValue
+                    })}
+                    key={label}
+                    label={label}
+                  />
+                ))}
+              </div>
+            </div>
+          ) : (
+            `${legendName} ${unitName}`
+          )
+        }
+        placement="top"
+      >
+        <div className={classes.markerAndLegendName}>
+          <div className={cx(classes.icon, { [classes.disabled]: disabled })} />
+          <EllipsisTypography
+            className={cx(classes.text, classes.legendName)}
+            data-mode={
+              value ? LegendDisplayMode.Compact : LegendDisplayMode.Normal
+            }
+          >
+            {metricName}
+          </EllipsisTypography>
+        </div>
+      </Tooltip>
+      {hasUnit && (
+        <Typography className={classes.text}>{getEndText()}</Typography>
+      )}
+    </div>
+  );
+};
+
+export default LegendHeader;

package/src/Graph/LineChart/Legend/index.tsx

@@ -0,0 +1,200 @@
+import { Dispatch, ReactNode, SetStateAction } from 'react';
+
+import { prop, slice, sortBy } from 'ramda';
+import { useAtomValue } from 'jotai';
+
+import { Box, alpha, useTheme } from '@mui/material';
+
+import { useMemoComponent } from '@centreon/ui';
+
+import { formatMetricValue } from '../../common/timeSeries';
+import { Line, TimeValue } from '../../common/timeSeries/models';
+import { labelAvg, labelMax, labelMin } from '../translatedLabels';
+import { timeValueAtom } from '../InteractiveComponents/interactionWithGraphAtoms';
+
+import InteractiveValue from './InteractiveValue';
+import { useStyles } from './Legend.styles';
+import LegendHeader from './LegendHeader';
+import { GetMetricValueProps, LegendDisplayMode } from './models';
+import useInteractiveValues from './useInteractiveValues';
+import useLegend from './useLegend';
+import LegendContent from './LegendContent';
+
+interface Props {
+  base: number;
+  displayAnchor?: boolean;
+  limitLegend?: false | number;
+  lines: Array<Line>;
+  renderExtraComponent?: ReactNode;
+  setLinesGraph: Dispatch<SetStateAction<Array<Line> | null>>;
+  shouldDisplayLegendInCompactMode: boolean;
+  timeSeries: Array<TimeValue>;
+  toggable?: boolean;
+  xScale;
+}
+
+const MainLegend = ({
+  lines,
+  timeSeries,
+  base,
+  toggable = true,
+  limitLegend = false,
+  renderExtraComponent,
+  displayAnchor = true,
+  setLinesGraph,
+  xScale,
+  shouldDisplayLegendInCompactMode
+}: Props): JSX.Element => {
+  const { classes, cx } = useStyles({ limitLegendRows: Boolean(limitLegend) });
+  const theme = useTheme();
+
+  const { selectMetricLine, clearHighlight, highlightLine, toggleMetricLine } =
+    useLegend({ lines, setLinesGraph });
+
+  const { getFormattedValue } = useInteractiveValues({
+    base,
+    lines,
+    timeSeries,
+    xScale
+  });
+
+  const sortedData = sortBy(prop('metric_id'), lines);
+
+  const displayedLines = limitLegend
+    ? slice(0, limitLegend, sortedData)
+    : sortedData;
+
+  const getMetricValue = ({ value, unit }: GetMetricValueProps): string =>
+    formatMetricValue({
+      base,
+      unit,
+      value
+    }) || 'N/A';
+
+  const selectMetric = ({ event, metric_id }): void => {
+    if (!toggable) {
+      return;
+    }
+
+    if (event.ctrlKey || event.metaKey) {
+      toggleMetricLine(metric_id);
+
+      return;
+    }
+
+    selectMetricLine(metric_id);
+  };
+
+  const mode = shouldDisplayLegendInCompactMode
+    ? LegendDisplayMode.Compact
+    : LegendDisplayMode.Normal;
+
+  return (
+    <div className={classes.legend}>
+      <div className={classes.items} data-mode={mode}>
+        {displayedLines.map((line) => {
+          const { color, display, highlight, metric_id } = line;
+
+          const markerColor = display
+            ? color
+            : alpha(theme.palette.text.disabled, 0.2);
+
+          const interactiveValue = displayAnchor
+            ? getFormattedValue(line)
+            : null;
+
+          const minMaxAvg = [
+            {
+              label: labelMin,
+              value: line.minimum_value
+            },
+            {
+              label: labelMax,
+              value: line.maximum_value
+            },
+            {
+              label: labelAvg,
+              value: line.average_value
+            }
+          ];
+
+          return (
+            <Box
+              className={cx(
+                classes.item,
+                highlight ? classes.highlight : classes.normal,
+                toggable && classes.toggable
+              )}
+              key={metric_id}
+              onClick={(event): void => selectMetric({ event, metric_id })}
+              onMouseEnter={(): void => highlightLine(metric_id)}
+              onMouseLeave={(): void => clearHighlight()}
+            >
+              <LegendHeader
+                color={markerColor}
+                disabled={!display}
+                line={line}
+                minMaxAvg={
+                  shouldDisplayLegendInCompactMode ? minMaxAvg : undefined
+                }
+                value={
+                  shouldDisplayLegendInCompactMode
+                    ? interactiveValue
+                    : undefined
+                }
+              />
+              {!shouldDisplayLegendInCompactMode && (
+                <div>
+                  {displayAnchor && (
+                    <InteractiveValue value={interactiveValue} />
+                  )}
+                  {!interactiveValue && (
+                    <div className={classes.minMaxAvgContainer}>
+                      {minMaxAvg.map(({ label, value }) => (
+                        <LegendContent
+                          data={getMetricValue({ unit: line.unit, value })}
+                          key={label}
+                          label={label}
+                        />
+                      ))}
+                    </div>
+                  )}
+                </div>
+              )}
+            </Box>
+          );
+        })}
+      </div>
+      {renderExtraComponent}
+    </div>
+  );
+};
+
+const Legend = (props: Props): JSX.Element => {
+  const {
+    toggable,
+    limitLegend,
+    timeSeries,
+    lines,
+    base,
+    displayAnchor,
+    shouldDisplayLegendInCompactMode
+  } = props;
+  const timeValue = useAtomValue(timeValueAtom);
+
+  return useMemoComponent({
+    Component: <MainLegend {...props} />,
+    memoProps: [
+      timeValue,
+      timeSeries,
+      lines,
+      base,
+      toggable,
+      limitLegend,
+      displayAnchor,
+      shouldDisplayLegendInCompactMode
+    ]
+  });
+};
+
+export default Legend;

package/src/Graph/LineChart/Legend/models.ts

@@ -0,0 +1,16 @@
+export interface FormattedMetricData {
+  color: string;
+  formattedValue: string | null;
+  name: string;
+  unit: string;
+}
+
+export interface GetMetricValueProps {
+  unit: string;
+  value: number | null;
+}
+
+export enum LegendDisplayMode {
+  Compact = 'compact',
+  Normal = 'normal'
+}

package/src/Graph/LineChart/Legend/useInteractiveValues.ts

@@ -0,0 +1,99 @@
+import { useMemo } from 'react';
+
+import { useAtomValue } from 'jotai';
+import { equals, find, isNil } from 'ramda';
+
+import { mousePositionAtom } from '../InteractiveComponents/interactionWithGraphAtoms';
+import {
+  formatMetricValueWithUnit,
+  getLineForMetric,
+  getMetrics,
+  getTimeValue
+} from '../../common/timeSeries';
+import { Line, TimeValue } from '../../common/timeSeries/models';
+
+import { FormattedMetricData } from './models';
+
+interface InteractiveValues {
+  getFormattedValue: (line: Line) => string | null | undefined;
+}
+
+interface Props {
+  base: number;
+  lines: Array<Line>;
+  timeSeries: Array<TimeValue>;
+  xScale;
+}
+
+const useInteractiveValues = ({
+  timeSeries,
+  lines,
+  base,
+  xScale
+}: Props): InteractiveValues => {
+  const mousePosition = useAtomValue(mousePositionAtom);
+
+  const timeValue = getTimeValue({
+    timeSeries,
+    x: mousePosition?.[0],
+    xScale
+  });
+
+  const graphTimeValue = timeSeries?.find((item) =>
+    equals(item.timeTick, timeValue?.timeTick)
+  );
+
+  const getMetricsToDisplay = (): Array<number> => {
+    if (isNil(graphTimeValue)) {
+      return [];
+    }
+    const metricsData = getMetrics(graphTimeValue as TimeValue);
+
+    const metricsToDisplay = metricsData.filter((metric_id) => {
+      const line = getLineForMetric({ lines, metric_id: Number(metric_id) });
+
+      return !isNil(graphTimeValue[metric_id]) && !isNil(line);
+    });
+
+    return metricsToDisplay.map(Number);
+  };
+
+  const metrics = useMemo(() => getMetricsToDisplay(), [graphTimeValue]);
+
+  const getFormattedMetricData = (
+    metric_id: number
+  ): FormattedMetricData | null => {
+    if (isNil(graphTimeValue)) {
+      return null;
+    }
+    const value = graphTimeValue[metric_id] as number;
+
+    const { color, name, unit } = getLineForMetric({
+      lines,
+      metric_id
+    }) as Line;
+
+    const formattedValue = formatMetricValueWithUnit({
+      base,
+      unit,
+      value
+    });
+
+    return {
+      color,
+      formattedValue,
+      name,
+      unit
+    };
+  };
+
+  const getFormattedValue = (line: Line): string | undefined | null => {
+    const metric_id = find(equals(line.metric_id), metrics);
+
+    return metric_id ? getFormattedMetricData(metric_id)?.formattedValue : null;
+  };
+
+  return { getFormattedValue };
+};
+
+export default useInteractiveValues;

package/src/Graph/LineChart/Legend/useLegend.ts

@@ -0,0 +1,104 @@
+import { Dispatch, SetStateAction, useEffect } from 'react';
+
+import {
+  equals,
+  find,
+  head,
+  isEmpty,
+  isNil,
+  map,
+  pipe,
+  propEq,
+  reject
+} from 'ramda';
+
+import { Line } from '../../common/timeSeries/models';
+
+interface LegendActions {
+  clearHighlight: () => void;
+  highlightLine: (metric_id: number) => void;
+  selectMetricLine: (metric_id: number) => void;
+  toggleMetricLine: (metric_id: number) => void;
+}
+
+interface Props {
+  lines: Array<Line>;
+  setLinesGraph: Dispatch<SetStateAction<Array<Line> | null>>;
+}
+
+const useLegend = ({ lines, setLinesGraph }: Props): LegendActions => {
+  const displayedLines = reject(propEq(false, 'display'), lines);
+  const getLineByMetric = (metric_id: number): Line =>
+    find(propEq(metric_id, 'metric_id'), lines) as Line;
+
+  const toggleMetricLine = (metric_id): void => {
+    const data = lines.map((line) => ({
+      ...line,
+      display: equals(line.metric_id, metric_id) ? !line.display : line.display
+    }));
+
+    setLinesGraph(data);
+  };
+
+  const highlightLine = (metric_id): void => {
+    const data = lines.map((line) => ({
+      ...line,
+      highlight: equals(line.metric_id, metric_id)
+    }));
+
+    setLinesGraph(data);
+  };
+
+  const clearHighlight = (): void => {
+    setLinesGraph(map((line) => ({ ...line, highlight: undefined }), lines));
+  };
+
+  const selectMetricLine = (metric_id: number): void => {
+    const metricLine = getLineByMetric(metric_id);
+
+    const isLineDisplayed = pipe(head, equals(metricLine))(displayedLines);
+    const isOnlyLineDisplayed =
+      equals(displayedLines.length, 1) && isLineDisplayed;
+
+    if (isOnlyLineDisplayed || isEmpty(displayedLines)) {
+      setLinesGraph(
+        map(
+          (line) => ({
+            ...line,
+            display: true
+          }),
+          lines
+        )
+      );
+
+      return;
+    }
+
+    setLinesGraph(
+      map(
+        (line) => ({
+          ...line,
+          display: equals(line, metricLine)
+        }),
+        lines
+      )
+    );
+  };
+
+  useEffect(() => {
+    if (isNil(lines) || isEmpty(lines)) {
+      return;
+    }
+
+    const newLines = lines.map((line) => ({
+      ...line,
+      display: find(propEq(line.metric_id, 'metric_id'), lines)?.display ?? true
+    }));
+
+    setLinesGraph(newLines);
+  }, [lines]);
+
+  return { clearHighlight, highlightLine, selectMetricLine, toggleMetricLine };
+};
+
+export default useLegend;

package/src/Graph/LineChart/LineChart.styles.ts

@@ -0,0 +1,45 @@
+import { makeStyles } from 'tss-react/mui';
+
+const useStyles = makeStyles()((theme) => ({
+  container: {
+    '& .visx-axis-bottom': {
+      '& .visx-axis-tick': {
+        '& .visx-line': {
+          stroke: theme.palette.text.primary
+        },
+        text: {
+          fill: theme.palette.text.primary
+        }
+      }
+    },
+    '& .visx-axis-line': {
+      stroke: theme.palette.text.primary
+    },
+    '& .visx-axis-right': {
+      '& .visx-axis-tick': {
+        '& .visx-line': {
+          stroke: theme.palette.text.primary
+        }
+      }
+    },
+    '& .visx-columns': {
+      '& .visx-line': {
+        stroke: theme.palette.divider
+      }
+    },
+    '& .visx-rows': {
+      '& .visx-line': {
+        stroke: theme.palette.divider
+      }
+    },
+    fill: theme.palette.text.primary,
+    position: 'relative'
+  },
+  header: {
+    display: 'grid',
+    gridTemplateColumns: '0.4fr 1fr 0.4fr',
+    width: '100%'
+  }
+}));
+
+export { useStyles };