Laravel development: How to use Laravel Nova for CRUD operations?

Laravel is one of the most popular PHP frameworks today, providing rich functionality and a convenient development experience. Laravel Nova is an admin interface builder designed specifically for Laravel applications, helping you create and manage backend admin panels more easily. In this article, we will look at how to use Laravel Nova for CRUD operations.

What is CRUD operation?

CRUD is the abbreviation of "Create, Read, Update and Delete". These four operations are the basic functionality of any application. Through CRUD operations, you can implement basic operations such as adding, querying, updating, and deleting data in the database. In the Laravel framework, we can use Eloquent ORM to easily implement these operations. However, if you want a more user-friendly admin panel, Laravel Nova has a great solution for you.

Install Laravel Nova

Before using Laravel Nova, we need to install it first. Laravel Nova is a commercial product and officially provides a 30-day free trial period. If you want to try it out, you can go to https://nova.laravel.com/ to create an account and get a trial license.

After the installation is complete, we can add Nova to our Laravel application. You can use composer to complete this process, just go into your project folder in the console and run the following command:

composer require laravel/nova

Additionally, you will need to register the Nova service provider. In the config/app.php file, find the providers array and add the following code:

LaravelNovaNovaServiceProvider::class,

After running the above command, you need to run the following command:

php artisan nova:install

This command will be used for your app The program generates Nova configuration files and resource directories. You will also need to publish Nova's CSS and JavaScript files to the public/vendor/nova directory using the Nova publish command:

php artisan vendor:publish --tag=nova-assets

Next, you will also need to set up the driver in the auth.php file in the config folder session to allow Nova's authentication system to work properly:

'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
],

Finally, you need to run the following command to generate the authentication routes and tables for Nova:

php artisan nova:install

So far, we have completed Laravel Nova installation and configuration work.

Using Laravel Nova for CRUD operations

Next, we will take a look at how to use Laravel Nova for CRUD operations. We will start with a simple example, let us create a new blog application using Laravel Nova, in this application we will be able to create, view, update and delete blog posts.

1. Create model and database migration

First, we need to create a new model and database migration. We will use Laravel's Artisan command line tool to complete this process. In the console, switch to your project folder and type the following command:

php artisan make:model Blog -m

This command will create a new model named Blog and also generate a new database migration file named create_blogs_table.

Now, we need to define the schema of our "blogs" table in the database migration file. Find this file in the database/migrations directory and open it. You will see code like this:

public function up()
{
    Schema::create('blogs', function (Blueprint $table) {
        $table->id();
        $table->timestamps();
    });
}

public function down()
{
    Schema::dropIfExists('blogs');
}

In this example, we only defined an id and timestamps field. You can adjust and add other fields according to your needs. Run the database migration after completion:

php artisan migrate

2. Define the resource model

Next, we need to define a resource model. A resource model is the bridge between Laravel Nova and Eloquent models. We define the resource model to tell Laravel Nova which database table will be associated with it. To create a resource model, type the following command:

php artisan nova:resource Blog

This command will create a new file named Blog.php in the app/Nova directory. Once you open this file, you will see the following code:

<?php

namespace AppNova;

use IlluminateHttpRequest;
use LaravelNovaFieldsID;
use LaravelNovaFieldsText;
use LaravelNovaFieldsNumber;
use LaravelNovaHttpRequestsNovaRequest;

class Blog extends Resource
{
    /**
     * The model the resource corresponds to.
     *
     * @var string
     */
    public static $model = '';

    /**
     * The single value that should be used to represent the resource when being displayed.
     *
     * @var string
     */
    public static $title = 'id';

    /**
     * The columns that should be searched.
     *
     * @var array
     */
    public static $search = [];

    /**
     * Get the fields displayed by the resource.
     *
     * @param  IlluminateHttpRequest  $request
     * @return array
     */
    public function fields(Request $request)
    {
        return [
            ID::make()->sortable(),

            Text::make('Title')->sortable(),

            Number::make('Views')->sortable(),

            Text::make('Content')->hideFromIndex(),
        ];
    }

    /**
     * Get the cards available for the request.
     *
     * @param  IlluminateHttpRequest  $request
     * @return array
     */
    public function cards(Request $request)
    {
        return [];
    }

    /**
     * Get the filters available for the resource.
     *
     * @param  IlluminateHttpRequest  $request
     * @return array
     */
    public function filters(Request $request)
    {
        return [];
    }

    /**
     * Get the lenses available for the resource.
     *
     * @param  IlluminateHttpRequest  $request
     * @return array
     */
    public function lenses(Request $request)
    {
        return [];
    }

    /**
     * Get the actions available for the resource.
     *
     * @param  IlluminateHttpRequest  $request
     * @return array
     */
    public function actions(Request $request)
    {
        return [];
    }
}

In this file, we define a new resource model called Blog. Now we need to associate this model with the Laravel model. You just need to open the model file and add the following code to the top:

namespace App;

use IlluminateDatabaseEloquentModel;

class Blog extends Model
{
    //
}

3. Connect the resources to nova

Now, we need to connect the Blog resources to Laravel Nova. To do this, you can open the app/Nova/NovaServiceProvider.php file and add the following to its boot method:

use AppNovaBlog;

// ...

public function boot()
{
    // ...

    Nova::resources([
        Blog::class,
    ]);
}

Now that we have successfully configured Laravel Nova, we can enter the application and see what it's like.

4. Perform CRUD operations

Now, we have successfully set up Laravel Nova and connected our Blog resources to it. We can access the admin panel and start doing CRUD operations.

Run the following command in the console to start the local development server:

php artisan serve

Then, open the http://localhost:8000/nova URL and you will see a login page. Log in using an existing account in your Laravel application.

Now you can click on the "Resources" drop-down menu on the top menu and select Blog. Here you will see an empty blog list.

We can use Laravel Nova to create, read, update and delete blog posts. You can click the "New Blog" button in the upper right corner of the page and enter the data. Each time a new blog post is added, the list will automatically update to show the latest data.

You can enter view and edit modes by clicking on the name of a blog post to perform other operations, such as updating or deleting a blog post. Additionally, you can use the Filter feature to quickly find specific blog posts and the Search feature to search for keywords across all blog posts.

Summary

By using Laravel Nova, we can easily create and manage the backend admin panel of Laravel applications. In this tutorial, we learned how to build a simple CRUD application using Laravel Nova. You can use similar methods in actual projects and master more advanced features of Laravel Nova to implement more complex applications.

The above is the detailed content of Laravel development: How to use Laravel Nova for CRUD operations?. For more information, please follow other related articles on the PHP Chinese website!