@centreon/ui 24.4.21 → 24.4.23

package/src/Form/Inputs/Switch.tsx

@@ -6,7 +6,7 @@ import { useTranslation } from 'react-i18next';
 
 import { FormControlLabel, Switch as MUISwitch } from '@mui/material';
 
-import getNormalizedId from '../../utils/getNormalizedId';
+import { getNormalizedId } from '../../utils/getNormalizedId';
 import { useMemoComponent } from '../..';
 
 import { InputPropsWithoutGroup } from './models';

package/src/Form/Inputs/Text.tsx

@@ -12,6 +12,8 @@ import {
   type as variableType
 } from 'ramda';
 
+import { InputAdornment } from '@mui/material';
+
 import { TextField, useMemoComponent } from '../..';
 
 import PasswordEndAdornment from './PasswordEndAdornment';
@@ -64,16 +66,24 @@ const Text = ({
     ? path(fieldNamePath, errors)
     : undefined;
 
-  const passwordEndAdornment = useCallback(
-    (): JSX.Element | null =>
-      equals(type, InputType.Password) ? (
+  const EndAdornment = useCallback((): JSX.Element | null => {
+    if (equals(type, InputType.Password)) {
+      return (
         <PasswordEndAdornment
           changeVisibility={changeVisibility}
           isVisible={isVisible}
         />
-      ) : null,
-    [isVisible]
-  );
+      );
+    }
+
+    if (text?.endAdornment) {
+      return (
+        <InputAdornment position="end">{text?.endAdornment}</InputAdornment>
+      );
+    }
+
+    return null;
+  }, [isVisible]);
 
   const getInputType = (): string => {
     if (text?.type) {
@@ -97,13 +107,14 @@ const Text = ({
     Component: (
       <TextField
         fullWidth
-        EndAdornment={passwordEndAdornment}
+        EndAdornment={EndAdornment}
         ariaLabel={t(label) || ''}
         dataTestId={dataTestId || ''}
         disabled={disabled}
         error={error as string | undefined}
         label={t(label)}
         multiline={isMultiline}
+        placeholder={text?.placeholder}
         required={isRequired}
         rows={rows}
         type={getInputType()}

package/src/Form/Inputs/index.tsx

@@ -1,7 +1,6 @@
 import { Fragment, useMemo } from 'react';
 
 import * as R from 'ramda';
-import { useTranslation } from 'react-i18next';
 import { makeStyles } from 'tss-react/mui';
 import { FormikValues, useFormikContext } from 'formik';
 
@@ -18,6 +17,8 @@ import TextInput from './Text';
 import ConnectedAutocomplete from './ConnectedAutocomplete';
 import FieldsTable from './FieldsTable/FieldsTable';
 import Grid from './Grid';
+import CheckboxGroup from './CheckboxGroup';
+import Checkbox from './Checkbox';
 import Custom from './Custom';
 import LoadingSkeleton from './LoadingSkeleton';
 
@@ -33,7 +34,6 @@ export const getInput = R.cond<
     R.equals(InputType.Radio) as (b: InputType) => boolean,
     R.always(RadioInput)
   ],
-  [R.equals(InputType.Text) as (b: InputType) => boolean, R.always(TextInput)],
   [
     R.equals(InputType.SingleAutocomplete) as (b: InputType) => boolean,
     R.always(Autocomplete)
@@ -42,10 +42,6 @@ export const getInput = R.cond<
     R.equals(InputType.MultiAutocomplete) as (b: InputType) => boolean,
     R.always(Autocomplete)
   ],
-  [
-    R.equals(InputType.Password) as (b: InputType) => boolean,
-    R.always(TextInput)
-  ],
   [
     R.equals(InputType.MultiConnectedAutocomplete) as (b: InputType) => boolean,
     R.always(ConnectedAutocomplete)
@@ -61,7 +57,16 @@ export const getInput = R.cond<
     R.always(FieldsTable)
   ],
   [R.equals(InputType.Grid) as (b: InputType) => boolean, R.always(Grid)],
-  [R.equals(InputType.Custom) as (b: InputType) => boolean, R.always(Custom)]
+  [R.equals(InputType.Custom) as (b: InputType) => boolean, R.always(Custom)],
+  [
+    R.equals(InputType.Checkbox) as (b: InputType) => boolean,
+    R.always(Checkbox)
+  ],
+  [
+    R.equals(InputType.CheckboxGroup) as (b: InputType) => boolean,
+    R.always(CheckboxGroup)
+  ],
+  [R.T, R.always(TextInput)]
 ]);
 
 interface StylesProps {
@@ -89,7 +94,9 @@ const useStyles = makeStyles<StylesProps>()((theme, { groupDirection }) => ({
       ? 'row'
       : 'column'
   },
-  inputWrapper: { width: '100%' },
+  inputWrapper: {
+    width: '100%'
+  },
   inputs: {
     display: 'flex',
     flexDirection: 'column',
@@ -99,8 +106,10 @@ const useStyles = makeStyles<StylesProps>()((theme, { groupDirection }) => ({
 }));
 
 interface Props {
+  areGroupsOpen?: boolean;
   groupDirection?: GroupDirection;
   groups?: Array<Group>;
+  groupsClassName?: string;
   inputs: Array<InputProps>;
   isCollapsible: boolean;
   isLoading?: boolean;
@@ -111,10 +120,11 @@ const Inputs = ({
   groups = [],
   isLoading = false,
   isCollapsible,
-  groupDirection
+  groupDirection,
+  groupsClassName,
+  areGroupsOpen
 }: Props): JSX.Element => {
-  const { classes } = useStyles({ groupDirection });
-  const { t } = useTranslation();
+  const { classes, cx } = useStyles({ groupDirection });
   const formikContext = useFormikContext<FormikValues>();
 
   const groupsName = R.pluck('name', groups);
@@ -178,12 +188,13 @@ const Inputs = ({
           ? R.find(R.propEq('name', groupName), groups)
           : ({} as Group);
 
-        const isFirstElement = R.equals(index, 0);
+        const isFirstElement = areGroupsOpen || R.equals(index, 0);
 
         return (
           <Fragment key={groupName}>
             <div>
               <CollapsibleGroup
+                className={groupsClassName}
                 defaultIsOpen={isFirstElement}
                 group={groupProps}
                 hasGroupTitle={hasGroupTitle}
@@ -209,13 +220,18 @@ const Inputs = ({
                       >
                         {inputProps.additionalLabel && (
                           <Typography
-                            className={classes.additionalLabel}
+                            className={cx(
+                              classes.additionalLabel,
+                              inputProps?.additionalLabelClassName
+                            )}
                             variant="body1"
                           >
-                            {t(inputProps.additionalLabel)}
+                            {inputProps.additionalLabel}
                           </Typography>
                         )}
-                        <Input {...inputProps} />
+                        <div className={inputProps?.inputClassName || ''}>
+                          <Input {...inputProps} />
+                        </div>
                       </div>
                     );
                   })}

package/src/Form/Inputs/models.ts

@@ -1,6 +1,6 @@
 import { FormikValues } from 'formik';
 
-import { SvgIconProps } from '@mui/material';
+import { SvgIconProps, TypographyProps } from '@mui/material';
 
 import { SelectEntry } from '../../InputField/Select';
 import { ConditionsSearchParameter } from '../../api/buildListingEndpoint/models';
@@ -16,7 +16,9 @@ export enum InputType {
   MultiConnectedAutocomplete,
   FieldsTable,
   Grid,
-  Custom
+  Custom,
+  Checkbox,
+  CheckboxGroup
 }
 
 interface FieldsTableGetRequiredProps {
@@ -24,14 +26,22 @@ interface FieldsTableGetRequiredProps {
   values: FormikValues;
 }
 
+export type LabelPlacement = 'bottom' | 'top' | 'end' | 'start' | undefined;
+
 export interface InputProps {
-  additionalLabel?: string;
+  additionalLabel?: string | JSX.Element;
+  additionalLabelClassName?: string;
   additionalMemoProps?: Array<unknown>;
   autocomplete?: {
     creatable?: boolean;
     options: Array<SelectEntry>;
   };
   change?: ({ setFieldValue, value }) => void;
+  checkbox?: {
+    direction?: 'horizontal' | 'vertical';
+    labelPlacement?: LabelPlacement;
+    options?: Array<string>;
+  };
   connectedAutocomplete?: {
     additionalConditionParameters: Array<ConditionsSearchParameter>;
     endpoint?: string;
@@ -42,6 +52,7 @@ export interface InputProps {
     Component: React.ComponentType<InputPropsWithoutGroup>;
   };
   dataTestId?: string;
+  disableSortedOptions?: boolean;
   fieldName: string;
   fieldsTable?: {
     additionalFieldsToMemoize?: Array<string>;
@@ -57,15 +68,17 @@ export interface InputProps {
   getRequired?: (values: FormikValues) => boolean;
   grid?: {
     alignItems?: string;
+    className?: string;
     columns: Array<Omit<InputProps, 'group'>>;
     gridTemplateColumns?: string;
   };
   group: string;
   hideInput?: (values: FormikValues) => boolean;
+  inputClassName?: string;
   label: string;
   radio?: {
     options?: Array<{
-      label: string;
+      label: string | JSX.Element;
       value: boolean | string;
     }>;
     row?: boolean;
@@ -75,7 +88,9 @@ export interface InputProps {
     getChecked?: (value) => boolean;
   };
   text?: {
+    endAdornment?: JSX.Element;
     multilineRows?: number;
+    placeholder?: string;
     type?: string;
   };
   type: InputType;
@@ -90,4 +105,5 @@ export interface Group {
   TooltipContent?: () => JSX.Element;
   name: string;
   order: number;
+  titleAttributes?: TypographyProps;
 }

package/src/Form/index.ts

@@ -0,0 +1 @@
+export * from './Form';

package/src/Form/storiesData.tsx

@@ -4,6 +4,7 @@ import { equals, prop } from 'ramda';
 
 import { Typography } from '@mui/material';
 import HelpOutlineIcon from '@mui/icons-material/HelpOutline';
+import MailIcon from '@mui/icons-material/MailOutline';
 
 import { SelectEntry } from '../InputField/Select';
 import { Listing } from '../api/models';
@@ -81,9 +82,7 @@ export const basicFormValidationSchema = Yup.object().shape({
   scopes: Yup.array().of(
     Yup.string().min(3, '3 characters min').required('Required')
   ),
-  sports: Yup.array()
-    .of(selectEntryValidationSchema.required('Required'))
-    .min(2, 'Choose at least 2 sports')
+  sports: Yup.array().of(selectEntryValidationSchema.required('Required'))
 });
 
 const roleEntries: Array<SelectEntry> = [
@@ -115,6 +114,11 @@ export const basicFormInitialValues = {
   isForced: false,
   language: 'French',
   name: '',
+  notifications: {
+    channels: { Icon: MailIcon, checked: true, label: 'mail' },
+    hostevents: ['ok', 'warning'],
+    includeServices: { checked: true, label: 'Include services for this host' }
+  },
   password: '',
   roleMapping: [
     {
@@ -157,6 +161,10 @@ export const basicFormGroups: Array<Group> = [
     TooltipContent: (): JSX.Element => <Typography>Tooltip content</Typography>,
     name: 'Second group',
     order: 2
+  },
+  {
+    name: 'Third group',
+    order: 3
   }
 ];
 
@@ -171,6 +179,10 @@ export const basicFormInputs: Array<InputProps> = [
     fieldName: 'email',
     group: 'First group',
     label: 'Email',
+    text: {
+      endAdornment: <MailIcon />,
+      placeholder: 'Your email here'
+    },
     type: InputType.Text
   },
   {
@@ -205,6 +217,41 @@ export const basicFormInputs: Array<InputProps> = [
     },
     type: InputType.Radio
   },
+  {
+    additionalLabel: 'Notifications',
+    fieldName: '',
+    grid: {
+      alignItems: 'center',
+      columns: [
+        {
+          checkbox: {
+            direction: 'horizontal'
+          },
+          fieldName: 'notifications.channels',
+          label: 'channels',
+          type: InputType.Checkbox
+        },
+        {
+          fieldName: 'notifications.includeServices',
+          label: 'Iclude services',
+          type: InputType.Checkbox
+        },
+        {
+          checkbox: {
+            direction: 'horizontal',
+            labelPlacement: 'top',
+            options: ['ok', 'warning', 'critical', 'unknown']
+          },
+          fieldName: 'notifications.hostevents',
+          label: 'host events',
+          type: InputType.CheckboxGroup
+        }
+      ]
+    },
+    group: 'Third group',
+    label: 'Notifications',
+    type: InputType.Grid
+  },
   {
     fieldName: 'anotherText',
     group: 'First group',

package/src/Graph/Gauge/AnimatedPie.tsx

@@ -0,0 +1,102 @@
+import { PieArcDatum, ProvidedProps } from '@visx/shape/lib/shapes/Pie';
+import { useTransition, to, animated } from '@react-spring/web';
+import { equals, includes, isNil, pluck } from 'ramda';
+
+import { Typography } from '@mui/material';
+
+import { Thresholds } from '../common/models';
+
+type AnimatedStyles = { endAngle: number; opacity: number; startAngle: number };
+
+const fromLeaveTransition = ({ endAngle }): AnimatedStyles => ({
+  endAngle,
+  opacity: 0,
+  startAngle: -(Math.PI / 2)
+});
+const enterUpdateTransition = <T,>({
+  startAngle,
+  endAngle
+}: PieArcDatum<T>): AnimatedStyles => ({
+  endAngle,
+  opacity: 1,
+  startAngle
+});
+
+type AnimatedPieProps<Datum> = ProvidedProps<Datum> & {
+  animate?: boolean;
+  getColor: (d: PieArcDatum<Datum>) => string;
+  getKey: (d: PieArcDatum<Datum>) => string;
+  hideTooltip?: () => void;
+  showTooltip?: (args) => void;
+  thresholds: Thresholds;
+};
+
+const AnimatedPie = <Datum,>({
+  animate,
+  arcs,
+  path,
+  getKey,
+  getColor,
+  showTooltip,
+  hideTooltip,
+  thresholds
+}: AnimatedPieProps<Datum>): JSX.Element | null => {
+  const transitions = useTransition?.<PieArcDatum<Datum>, AnimatedStyles>(
+    arcs,
+    {
+      enter: enterUpdateTransition,
+      from: animate ? fromLeaveTransition : enterUpdateTransition,
+      keys: getKey,
+      leave: animate ? fromLeaveTransition : enterUpdateTransition,
+      update: enterUpdateTransition
+    }
+  );
+
+  if (isNil(useTransition)) {
+    return null;
+  }
+
+  return transitions((props, arc, { key }) => (
+    <g key={key}>
+      <animated.path
+        d={to([props.startAngle, props.endAngle], (startAngle, endAngle) =>
+          path({
+            ...arc,
+            endAngle,
+            startAngle
+          })
+        )}
+        data-testid={`${arc.data?.value || arc.data}-arc`}
+        display={
+          includes('transparent', arc.data?.name || '') ? 'none' : 'inline'
+        }
+        fill={getColor(arc)}
+        onMouseEnter={(event) => {
+          const thresholdType = arc.data?.name as string;
+
+          if (equals(thresholdType, 'success')) {
+            return;
+          }
+
+          showTooltip?.({
+            tooltipData: (
+              <div>
+                {pluck(
+                  'label',
+                  thresholds[thresholdType as 'warning' | 'critical']
+                ).map((label) => (
+                  <Typography key={label}>{label}</Typography>
+                ))}
+              </div>
+            ),
+            tooltipLeft: event.clientX,
+            tooltipTop: event.clientY
+          });
+        }}
+        onMouseLeave={() => hideTooltip?.()}
+      />
+    </g>
+  ));
+};
+
+export default AnimatedPie;

package/src/Graph/Gauge/Gauge.stories.tsx

@@ -0,0 +1,159 @@
+import { Meta, StoryObj } from '@storybook/react';
+
+import dataLastWeek from '../LineChart/mockedData/lastWeek.json';
+
+import { Gauge } from './Gauge';
+
+const meta: Meta<typeof Gauge> = {
+  component: Gauge
+};
+
+export default meta;
+type Story = StoryObj<typeof Gauge>;
+
+const Template = (props): JSX.Element => (
+  <div style={{ height: '500px', width: '500px' }}>
+    <Gauge {...props} />
+  </div>
+);
+
+export const success: Story = {
+  args: {
+    data: dataLastWeek,
+    thresholds: {
+      critical: [
+        {
+          label: 'Critical',
+          value: 0.6
+        }
+      ],
+      enabled: true,
+      warning: [
+        {
+          label: 'Warning',
+          value: 0.5
+        }
+      ]
+    }
+  },
+  render: Template
+};
+
+export const warning: Story = {
+  args: {
+    data: dataLastWeek,
+    thresholds: {
+      critical: [
+        {
+          label: 'Critical',
+          value: 0.6
+        }
+      ],
+      enabled: true,
+      warning: [
+        {
+          label: 'Warning',
+          value: 0.2
+        }
+      ]
+    }
+  },
+  render: Template
+};
+
+export const critical: Story = {
+  args: {
+    data: dataLastWeek,
+    thresholds: {
+      critical: [
+        {
+          label: 'Critical',
+          value: 0.35
+        }
+      ],
+      enabled: true,
+      warning: [
+        {
+          label: 'Warning',
+          value: 0.13
+        }
+      ]
+    }
+  },
+  render: Template
+};
+
+export const withCriticalLowerThanWarning: Story = {
+  args: {
+    data: dataLastWeek,
+    thresholds: {
+      critical: [
+        {
+          label: 'Critical',
+          value: 0.13
+        }
+      ],
+      enabled: true,
+      warning: [
+        {
+          label: 'Warning',
+          value: 0.5
+        }
+      ]
+    }
+  },
+  render: Template
+};
+
+export const withRangeThresholds: Story = {
+  args: {
+    data: dataLastWeek,
+    thresholds: {
+      critical: [
+        {
+          label: 'Critical',
+          value: 0.55
+        },
+        {
+          label: 'Critical',
+          value: 0.65
+        }
+      ],
+      enabled: true,
+      warning: [
+        {
+          label: 'Warning',
+          value: 0.13
+        },
+        {
+          label: 'Warning',
+          value: 0.5
+        }
+      ]
+    }
+  },
+  render: Template
+};
+
+export const RawValue: Story = {
+  args: {
+    data: dataLastWeek,
+    displayAsRaw: true,
+    thresholds: {
+      critical: [
+        {
+          label: 'Critical',
+          value: 0.6
+        }
+      ],
+      enabled: true,
+      warning: [
+        {
+          label: 'Warning',
+          value: 0.5
+        }
+      ]
+    }
+  },
+  render: Template
+};

package/src/Graph/Gauge/Gauge.tsx

@@ -0,0 +1,41 @@
+import { ParentSize } from '../..';
+import { LineChartData, Thresholds } from '../common/models';
+import { getMetricWithLatestData } from '../common/timeSeries';
+import { Metric } from '../common/timeSeries/models';
+
+import ResponsiveGauge from './ResponsiveGauge';
+
+interface Props {
+  baseColor?: string;
+  data?: LineChartData;
+  displayAsRaw?: boolean;
+  thresholds: Thresholds;
+}
+
+export const Gauge = ({
+  thresholds,
+  data,
+  displayAsRaw,
+  baseColor
+}: Props): JSX.Element | null => {
+  if (!data) {
+    return null;
+  }
+
+  const metric = getMetricWithLatestData(data) as Metric;
+
+  return (
+    <ParentSize>
+      {({ width, height }) => (
+        <ResponsiveGauge
+          baseColor={baseColor}
+          displayAsRaw={displayAsRaw}
+          height={height}
+          metric={metric}
+          thresholds={thresholds}
+          width={width}
+        />
+      )}
+    </ParentSize>
+  );
+};