Skip to content

The open alternative to Salesforce, designed for AI.

11.6 KB
Raw Blame
import { SpreadsheetImportStepBody } from '@/spreadsheet-import/components/SpreadsheetImportStepBody';
import { SpreadsheetImportTable } from '@/spreadsheet-import/components/SpreadsheetImportTable';
import { StepNavigationButton } from '@/spreadsheet-import/components/StepNavigationButton';
import { useHideStepBar } from '@/spreadsheet-import/hooks/useHideStepBar';
import { useSpreadsheetImportInternal } from '@/spreadsheet-import/hooks/useSpreadsheetImportInternal';
import { spreadsheetImportCreatedRecordsProgressState } from '@/spreadsheet-import/states/spreadsheetImportCreatedRecordsProgressState';
import { spreadsheetImportDialogState } from '@/spreadsheet-import/states/spreadsheetImportDialogState';
import { type SpreadsheetImportStep } from '@/spreadsheet-import/steps/types/SpreadsheetImportStep';
import { SpreadsheetImportStepType } from '@/spreadsheet-import/steps/types/SpreadsheetImportStepType';
import {
  type ImportedStructuredRow,
  type SpreadsheetImportImportValidationResult,
} from '@/spreadsheet-import/types';
import { type SpreadsheetColumns } from '@/spreadsheet-import/types/SpreadsheetColumns';
import { SpreadsheetColumnType } from '@/spreadsheet-import/types/SpreadsheetColumnType';
import { addErrorsAndRunHooks } from '@/spreadsheet-import/utils/dataMutations';
import { useDialogManager } from '@/ui/feedback/dialog-manager/hooks/useDialogManager';
import { styled } from '@linaria/react';
import { useStore } from 'jotai';
import { Trans, useLingui } from '@lingui/react/macro';
import {
  type Dispatch,
  type SetStateAction,
  useCallback,
  useMemo,
  useState,
} from 'react';
import { themeCssVariables } from 'twenty-ui/theme';
import { type RowsChangeData } from 'react-data-grid';
import { isDefined } from 'twenty-shared/utils';
import { IconTrash } from 'twenty-ui/icon';
import { Button, Switch } from 'twenty-ui/primitives/input';
import { generateColumns } from './components/columns';
import { type ImportedStructuredRowMetadata } from './types';

const StyledContentWrapper = styled.div`
  display: flex;
  flex: 1 1 0%;
  flex-direction: column;
  position: relative;
`;

const StyledToolbar = styled.div`
  align-items: center;
  background-color: ${themeCssVariables.background.secondary};
  border: 1px solid ${themeCssVariables.border.color.medium};
  border-radius: ${themeCssVariables.border.radius.md};
  bottom: ${themeCssVariables.spacing[3]};
  box-shadow: ${themeCssVariables.boxShadow.strong};
  display: flex;
  flex-direction: row;
  justify-content: space-between;
  left: 50%;
  padding: ${themeCssVariables.spacing[3]};
  position: absolute;
  transform: translateX(-50%);
  width: 400px;
  z-index: 1;
`;

const StyledErrorSwitch = styled.div`
  align-items: center;
  display: flex;
  flex-direction: row;
`;

const StyledErrorSwitchDescription = styled.span`
  color: ${themeCssVariables.font.color.secondary};
  font-size: ${themeCssVariables.font.size.md};
  font-weight: ${themeCssVariables.font.weight.regular};
  margin-left: ${themeCssVariables.spacing[2]};
`;

const StyledScrollContainer = styled.div`
  display: flex;
  flex-direction: column;
  flex-grow: 1;
  height: 0px;
  overflow: auto;
  width: 100%;
`;

const StyledNoRowsContainer = styled.div`
  display: flex;
  grid-column: 1/-1;
  justify-content: center;
  margin-top: ${themeCssVariables.spacing[8]};
`;

const StyledNoRowsWithErrorsContainer = styled.div`
  color: ${themeCssVariables.font.color.tertiary};
  display: flex;
  justify-content: center;
  margin: auto 0;
`;

type ValidationStepProps = {
  initialData: ImportedStructuredRow[];
  importedColumns: SpreadsheetColumns;
  file: File;
  onBack: () => void;
  setCurrentStepState: Dispatch<SetStateAction<SpreadsheetImportStep>>;
};

export const ValidationStep = ({
  initialData,
  importedColumns,
  file,
  setCurrentStepState,
  onBack,
}: ValidationStepProps) => {
  const store = useStore();
  const hideStepBar = useHideStepBar();
  const { enqueueDialog } = useDialogManager();
  const {
    spreadsheetImportFields: fields,
    onClose,
    onSubmit,
    rowHook,
    tableHook,
  } = useSpreadsheetImportInternal();

  const [data, setData] = useState<
    (ImportedStructuredRow & ImportedStructuredRowMetadata)[]
  >(
    useMemo(
      () => addErrorsAndRunHooks(initialData, fields, rowHook, tableHook),
      // oxlint-disable-next-line react-hooks/exhaustive-deps
      [],
    ),
  );
  const [selectedRows, setSelectedRows] = useState<
    ReadonlySet<number | string>
  >(new Set());
  const [filterByErrors, setFilterByErrors] = useState(false);

  const updateData = useCallback(
    (rows: typeof data) => {
      setData(addErrorsAndRunHooks(rows, fields, rowHook, tableHook));
    },
    [setData, rowHook, tableHook, fields],
  );

  const deleteSelectedRows = () => {
    if (selectedRows.size > 0) {
      const newData = data.filter((value) => !selectedRows.has(value.__index));
      updateData(newData);
      setSelectedRows(new Set());
    }
  };

  const { t } = useLingui();

  const updateRow = useCallback(
    (
      rows: typeof data,
      changedData?: RowsChangeData<(typeof data)[number]>,
    ) => {
      const changes = changedData?.indexes.reduce(
        // Todo: remove usage of react-data-grid
        (acc: any, index: any) => {
          // when data is filtered val !== actual index in data
          const realIndex = data.findIndex(
            (value) => value.__index === rows[index].__index,
          );
          acc[realIndex] = rows[index];
          return acc;
        },
        {} as Record<number, (typeof data)[number]>,
      );
      const newData = Object.assign([], data, changes);
      updateData(newData);
    },
    [data, updateData],
  );

  const columns = useMemo(
    () =>
      generateColumns(fields)
        .map((column) => {
          const hasBeenImported =
            importedColumns.filter(
              (importColumn) =>
                (importColumn.type === SpreadsheetColumnType.matched &&
                  importColumn.value === column.key) ||
                (importColumn.type === SpreadsheetColumnType.matchedSelect &&
                  importColumn.value === column.key) ||
                (importColumn.type ===
                  SpreadsheetColumnType.matchedSelectOptions &&
                  importColumn.value === column.key) ||
                (importColumn.type === SpreadsheetColumnType.matchedCheckbox &&
                  importColumn.value === column.key) ||
                column.key === 'select-row',
            ).length > 0;

          if (!hasBeenImported) return null;
          return column;
        })
        .filter(isDefined),
    [fields, importedColumns],
  );

  const tableData = useMemo(() => {
    if (filterByErrors) {
      return data.filter((value) => {
        if (isDefined(value?.__errors)) {
          return (
            (Object.values(value.__errors)?.filter(
              (err) => err.level === 'error',
            ).length ?? 0) > 0
          );
        }
        return false;
      });
    }
    return data;
  }, [data, filterByErrors]);

  const rowKeyGetter = useCallback(
    (row: ImportedStructuredRow & ImportedStructuredRowMetadata) => row.__index,
    [],
  );

  const submitData = async () => {
    const calculatedData = data.reduce(
      (acc, value) => {
        const { __index, __errors, ...values } = value;
        if (isDefined(__errors)) {
          for (const key in __errors) {
            if (__errors[key].level === 'error') {
              acc.invalidStructuredRows.push(
                values as unknown as ImportedStructuredRow,
              );
              return acc;
            }
          }
        }
        acc.validStructuredRows.push(
          values as unknown as ImportedStructuredRow,
        );
        return acc;
      },
      {
        validStructuredRows: [] as ImportedStructuredRow[],
        invalidStructuredRows: [] as ImportedStructuredRow[],
        allStructuredRows: data,
      } satisfies SpreadsheetImportImportValidationResult,
    );

    setCurrentStepState({
      type: SpreadsheetImportStepType.importData,
      recordsToImportCount: calculatedData.validStructuredRows.length,
    });
    hideStepBar();

    try {
      await onSubmit(calculatedData, file);
      onClose();
    } catch {
      const importedRecordsCount = store.get(
        spreadsheetImportCreatedRecordsProgressState.atom,
      );
      const importedRows = new Set(
        data
          .filter(
            (row) =>
              !Object.values(row.__errors ?? {}).some(
                (rowError) => rowError.level === 'error',
              ),
          )
          .slice(0, importedRecordsCount),
      );
      const remainingRows = data.filter((row) => !importedRows.has(row));

      updateData(remainingRows);
      setCurrentStepState({
        type: SpreadsheetImportStepType.validateData,
        data: remainingRows,
        importedColumns,
      });
      store.set(spreadsheetImportDialogState.atom, (state) => ({
        ...state,
        isStepBarVisible: true,
      }));
    }
  };
  const onContinue = () => {
    const invalidData = data.find((value) => {
      if (isDefined(value?.__errors)) {
        return !!Object.values(value.__errors)?.filter(
          (err) => err.level === 'error',
        ).length;
      }
      return false;
    });
    if (!invalidData) {
      submitData();
    } else {
      enqueueDialog({
        title: t`Finish flow with errors`,
        message: t`There are still some rows that contain errors. Rows with errors will be ignored when submitting.`,
        buttons: [
          { title: t`Cancel` },
          {
            title: t`Submit`,
            variant: 'outline',
            onClick: submitData,
            role: 'confirm',
          },
        ],
      });
    }
  };

  return (
    <>
      <SpreadsheetImportStepBody>
        <StyledContentWrapper>
          {filterByErrors && tableData.length === 0 ? (
            <StyledNoRowsWithErrorsContainer>
              <Trans>No rows with errors</Trans>
            </StyledNoRowsWithErrorsContainer>
          ) : (
            <StyledScrollContainer>
              <SpreadsheetImportTable
                headerRowHeight={32}
                rowKeyGetter={rowKeyGetter}
                rows={tableData}
                onRowsChange={updateRow}
                columns={columns}
                selectedRows={selectedRows}
                onSelectedRowsChange={setSelectedRows as any} // TODO: replace 'any'
                renderers={{
                  noRowsFallback: (
                    <StyledNoRowsContainer>
                      {filterByErrors
                        ? t`No data containing errors`
                        : t`No data found`}
                    </StyledNoRowsContainer>
                  ),
                }}
              />
            </StyledScrollContainer>
          )}
          <StyledToolbar>
            <StyledErrorSwitch>
              <Switch
                aria-label={t`Show only rows with errors`}
                checked={filterByErrors}
                onCheckedChange={() => setFilterByErrors(!filterByErrors)}
                size="sm"
              />
              <StyledErrorSwitchDescription>
                <Trans>Show only rows with errors</Trans>
              </StyledErrorSwitchDescription>
            </StyledErrorSwitch>
            <Button
              startIcon={<IconTrash />}
              size="sm"
              onClick={deleteSelectedRows}
              disabled={selectedRows.size === 0}
            >{t`Remove`}</Button>
          </StyledToolbar>
        </StyledContentWrapper>
      </SpreadsheetImportStepBody>
      <StepNavigationButton
        onContinue={onContinue}
        onBack={onBack}
        continueTitle={t`Confirm`}
      />
    </>
  );
};