useImport

Here is a basic usage example of useImport hook:

import { useImport, ImportButton } from "@pankod/refine-antd";

export const PostList: React.FC = () => {
  const importProps = useImport();

  return <ImportButton {...importProps}>Import</ImportButton>;
};

Refer to the <ImportButton> interface for more information →

Also, you can use the inputProps and uploadProps properties without the <ImportButton> component for more customization:

import { useImport, Upload, Button } from "@pankod/refine-antd";

export const PostList: React.FC = () => {
  const { buttonProps, uploadProps } = useImport();

  return (
    <Upload {...uploadProps}>
      <Button {...buttonProps}>Import</Button>
    </Upload>
  );
};

Default: It reads the resource value from the current URL.

Determines which resource is passed to the create or createMany method of your data provider.

useImport({
  resourceName: "posts",
});

If you want to map the data before sending it to a data provider method, you can use the mapData property.

useImport({
  mapData: (data) => ({
    ...data,
    category: {
      id: data.categoryId,
    },
  }),
});

You can pass any Papa Parse options to the paparseOptions property.

useImport({
  paparseOptions: {
    header: true,
  },
});

Default: Number.MAX_SAFE_INTEGER

If you want to send the data in batches, you can use the batchSize property. When the batchSize is 1, it calls the create method of your data provider for each row in the file. When the batchSize is greater than 1, it calls the createMany method of your data provider for each batch.

useImport({
  batchSize: 1,
});

If you want to do something after the import is finished, you can use the onFinish property. It returns an object with two properties: succeeded and errored which contain the responses of the successful and failed requests.

useImport({
  onFinish: (result) => {
    // success requests response
    result.succeeded.forEach((item) => {
      console.log(item);
    });

    // failed requests response
    result.errored.forEach((item) => {
      console.log(item);
    });
  },
});

If you want to send additional data to the create or createMany method of your data provider, you can use the metaData property.

useImport({
  metaData: {
    foo: "bar",
  },
});

A callback function that is called when the import progress changes. It returns an object with two properties: totalAmount and processedAmount which contain the total amount of rows and the processed amount of rows.

useImport({
  onProgress: ({ totalAmount, processedAmount }) => {
    // progress percentage
    console.log((processedAmount / totalAmount) * 100);
  },
});

By default, it shows a notification with the progress percentage. You can override this behavior by passing a custom onProgress function.

If there is more than one dataProvider, you can specify which one to use by passing the dataProviderName prop. It is useful when you have a different data provider for different resources.

useImport({
  dataProviderName: "second-data-provider",
});

Button properties that are compatible with Ant Design <Button> component.

import { useImport, Button } from "@pankod/refine-antd";

export const PostList: React.FC = () => {
  const { buttonProps } = useImport();

  return <Button {...buttonProps}>Import</Button>;
};

It is set to default by default.

If the import is in progress, it sets the loading state of the button.

Upload properties that are compatible with Ant Design <Upload> component.

import { useImport, Upload } from "@pankod/refine-antd";

export const PostList: React.FC = () => {
  const { uploadProps } = useImport();

  return <Upload {...uploadProps}>Import</Upload>;
};

Handles the file upload.

By default, () => false is set to prevent the file from being uploaded automatically.

By default, false is set to hide the upload list.

By default, ".csv" is set to accept only CSV files.

It is a boolean value that indicates whether the import is in progress.

Result of the useCreate or useCreateMany method of your data provider.

Sometimes you need to process your parsed CSV data for certain cases, such as when your data includes relational data and references to other data, or when your backend API requires a specific data format. To handle this, you can use the mapData option in useImport to customize the process.

For example, the CSV file is as follows:

"title","content","status","categoryId","userId"
"dummy title 1","dummy content 1","rejected","3","8"
"dummy title 2","dummy content 2","draft","44","8"
"dummy title 3","cummy content 3","published","41","10"

Since the user and category are relational fields, we store only their id fields in the exported file as userId and categoryId respectively. To create resources from this file, we need to map the data back to the required format of the backend API. To do this, we use the mapData option in useImport. Here's an example:

When creating these resources back, we should map it back to our backend API's required format. mapData option allows us to do this. Here is an example:

useImport<IPostFile>({
  mapData: (item) => {
    return {
      title: item.title,
      content: item.content,
      status: item.status,
      category: {
        id: item.categoryId,
      },
      user: {
        id: item.userId,
      },
    };
  },
});

interface IPostFile {
  title: string;
  status: string;
  content: string;
  categoryId: string;
  userId: string;
}

With this code, the parsed data will be mapped to conform to the API requirements.