This is a Laravel Nova tool to that provides features to import and export CSV files.
When using Laravel Nova 4.x, use version ^2.0 of this package.
When using Laravel Nova 5.x, use version ^3.0 of this package.
Note to maintainers: We will be maintaining two branches for this package. The 2.x branch will be for Laravel Nova 4.x
support and the main branch will be for Laravel Nova 5.x support.
You can install the package in to a Laravel app that uses Nova via composer:
composer require coreproc/nova-data-syncPublish the package's config and migrations:
php artisan vendor:publish --provider="Coreproc\NovaDataSync\ToolServiceProvider"This package requires Laravel Horizon and comes with the package. If you have not gone through Horizon's install process yet, you can install it by running:
php artisan horizon:installMake sure to configure Horizon's environment processes in config/horizon.php.
You should also migrate the job batches table:
php artisan queue:batches-table
php artisan migrateThis package also requires spatie/laravel-media-library and comes with this package. If you have not gone through the installation process of Media Library, you should publish the migrations for it:
php artisan vendor:publish --provider="Spatie\MediaLibrary\MediaLibraryServiceProvider" --tag="medialibrary-migrations"
php artisan migratePublish Media Library's config file:
php artisan vendor:publish --provider="Spatie\MediaLibrary\MediaLibraryServiceProvider" --tag="medialibrary-config"Also run the following command to publish the config file for ebess/advanced-nova-media-library:
php artisan vendor:publish --tag=nova-media-libraryAdd the tool to your NovaServiceProvider.php:
publicfunctiontools()
{
return [
// ...new \Coreproc\NovaDataSync\NovaDataSync(),
];
}The Nova Data Sync tool should now appear in Nova's sidebar.
To start with creating an Import feature, you will need two create two classes that extend the following:
- an
ImportProcessclass that contains the validation rules and process logic for each row of an imported CSV file. - and an
ImportNovaActionclass that is essentially a Nova Action
Here is a sample ImportProcessor:
<?phpnamespaceApp\Nova\Imports\TestImport;
useCoreproc\NovaDataSync\Import\Jobs\ImportProcessor;useIlluminate\Support\Facades\Log;
class TestImportProcessor extends ImportProcessor
{
publicstaticfunctionexpectedHeaders(): array
{
return ['field1', 'field2'];
}
protectedfunctionrules(array$row, int$rowIndex): array
{
// Use Laravel validation rules to validate the values in each row.return [
'field1' => ['required'],
'field2' => ['required'],
];
}
protectedfunctionprocess(array$row, int$rowIndex): void
{
Log::info('processing row ' . $rowIndex);
// Put the logic to process each row in your imported CSV here
}
/** * Optional: The number of rows to process per chunk. If not defined, it will use the * default chunk size defined in the config file. */publicstaticfunctionchunkSize(): int
{
return100;
}
}The rules() method is where you can define the validation rules for each row of the CSV file. It will be passed the
$row and $rowIndex parameters. The $row parameter is an array of the CSV row's data. The $rowIndex parameter is
the index. Return an array of Laravel's validation rules.
The expected headers are defined in the expectedHeaders() method. This is used to validate the headers of the CSV.
The process() method is where you can define the logic for each row of the CSV file. It will be passed the $row and
$rowIndex parameters. The $row parameter is an array of the CSV row's data. The $rowIndex parameter is the index.
If you throw an Exception inside the process() method, the row will be marked as failed and the exception message
will be shown in the failed report for the Import.
Next, create an ImportNovaAction class and define the $processor class you just created.
<?phpnamespaceApp\Nova\Imports\TestImport;
useCoreproc\NovaDataSync\Import\Nova\Actions\ImportNovaAction;
class TestImportAction extends ImportNovaAction
{
// A sample processor will be shown belowpublicstring$processor = TestImportProcessor::class;
}Next, put your ImportNovaAction inside the actions() method of one of your Nova Resources:
publicfunctionactions(Request$request)
{
return [
newTestImportAction(),
];
}It should look something like this:
If you want to use the Import feature without the Nova Action, you can still use your ImportProcessor class. Here is an example of grabbing a file from S3 and importing it:
useCoreproc\NovaDataSync\Import\Actions\ImportAction;
// Get the file from s3$file = Storage::disk('s3')->get('file-for-import.csv');
// Put it in your local storage
Storage::disk('local')->put('file-for-import.csv', $file);
// Get the filepath of the file we just saved$filePath = Storage::disk('local')->path('file-for-import.csv');
try {
// Use ImportAction::make() to dispatch the jobs necessary to handle the import
ImportAction::make(TestImportProcessor::class, $filePath);
} catch (Exception$e) {
// Handle exception
\Log::error($e->getMessage());
}This will dispatch the jobs necessary to handle the import. You'll also be able to see the progress of the import in the Nova Data Sync tool.
You can find configuration options for the Import feature in config/nova-data-sync.php.
'imports' => [
'disk' => env('MEDIA_DISK', 'public'),
'chunk_size' => 1000,
'queue' => 'default',
],To start with creating an Export feature, you will need two create two classes that extend ExportProcessor and
ExportNovaAction.
Here is a sample ExportProcessor:
namespaceApp\Nova\Exports;
useApp\Models\Product;
useCoreproc\NovaDataSync\Export\Jobs\ExportProcessor;
useIlluminate\Contracts\Database\Query\Builder;
class UserExportProcessor extends ExportProcessor
{
publicfunctionquery(): Builder
{
return Product::query()->with('productCategory');
}
}You can also format the row data by defining the formatRow() method:
namespaceApp\Nova\Exports;
useApp\Models\Product;
useCoreproc\NovaDataSync\Export\Jobs\ExportProcessor;
useIlluminate\Contracts\Database\Query\Builder;
class UserExportProcessor extends ExportProcessor
{
publicfunctionquery(): Builder
{
return Product::query()->with('productCategory');
}
publicfunctionformatRow($row): array
{
return [
'name' => $row->name,
'product_category' => $row->productCategory->name ?? null,
'price' => $row->price,
];
}
}You can also define the query() method to return a query builder. This is useful if you want to export data from a
database table.
namespaceApp\Nova\Exports;
useCoreproc\NovaDataSync\Export\Jobs\ExportProcessor;
useDB;
useIlluminate\Contracts\Database\Query\Builder;
class UserExportProcessor extends ExportProcessor
{
publicfunctionquery(): Builder
{
return \DB::query()->from('users')
->select([
'id',
'email',
]);
}
}You can also override methods in the ExportProcessor class to customize the export process. The following methods can
be overridden:
<?phpnamespaceApp\Nova\Exports\Products;
useApp\Models\Product;
useCoreproc\NovaDataSync\Export\Jobs\ExportProcessor;
useIlluminate\Contracts\Database\Query\Builder;
class ProductExportProcessor extends ExportProcessor
{
publicfunction__construct(publicstring$startDate, publicstring$endDate)
{
// Always remember to call the parent constructor when overriding the constructorparent::__construct();
}
publicfunctionquery(): Builder
{
$startDate = Carbon::make($this->startDate)->startOfDay();
$endDate = Carbon::make($this->endDate)->endOfDay();
return Product::query()
->whereBetween('created_at', [$startDate, $endDate])
->with('productCategory');
}
publicfunctionformatRow($row): array
{
return [
'name' => $row->name,
'product cat' => $row->productCategory->name ?? null,
'price' => $row->price,
];
}
publicstaticfunctionqueueName(): string
{
return'custom-queue-name'; // Default is whatever is set in the config
}
publicfunctionallowFailures(): bool
{
returntrue; // Default is whatever is set in the config
}
publicfunctiondisk(): string
{
return'custom-disk-name'; // Default is whatever is set in the config
}
publicstaticfunctionchunkSize(): int
{
return100; // Default is whatever is set in the config
}
}Next, in order to use it as a Nova Action, create an ExportNovaAction class and create a processor() function that
returns the processor class you just created.
namespaceApp\Nova\Exports;
useCoreproc\NovaDataSync\Export\Nova\Action\ExportNovaAction;
class ProductExportAction extends ExportNovaAction
{
protectedfunctionprocessor(ActionFields$fields, Collection$models): ExportProcessor
{
returnnewProductExportProcessor();
}
}If you have additional fields that you want to add to the Export feature, you can define them in the fields() method
and access them through the $fields property.
namespaceApp\Nova\Exports;
useCoreproc\NovaDataSync\Export\Nova\Action\ExportNovaAction;
class ProductExportAction extends ExportNovaAction
{
protectedfunctionprocessor(ActionFields$fields, Collection$models): ExportProcessor
{
returnnewProductExportProcessor($fields->get('start_date'), $fields->get('end_date'));
}
publicfunctionfields(NovaRequest$request): array
{
return [
Date::make('Start Date')->required(),
Date::make('End Date')->required(),
];
}
}Now, you can add the ExportNovaAction to your Nova Resource:
publicfunctionactions(Request$request)
{
return [
newUserExportAction(),
];
}Each import and export have a morphable user() relationship. This is used to determine who imported or exported the
data. You will need to define Nova resource of each user type that you want to use for the import and export features.
This can be done in the config/nova-data-sync.php file.
'nova_resources' => [
/** * Since users are defined as morphable, we need to specify the Nova resource * associated with the users we want. */'users' => [
\App\Nova\User::class,
],
],By default, this already has the App\Nova\User::class resource. You can add more user resources like
App\Nova\BackendUser as needed.