The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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`}
/>
</>
);
};