Coding Wiki

Add this to the Role model

    public function users(){
        return $this->belongsToMany('App\Models\User');
    }

We are going to make roles for our users which will require a new model called Role with a migration

php artisan make:model Role -m

Next you need to make a table for both roles and users. In Laravel you need to use singular case and go in alphabetical order.

php artisan make:migration create_users_roles_table --create=role_user

In your roles migration add the new fields:

$table->string('name');

In your user role migration add these fields:

$table->integer('user_id');
$table->integer('role_id');

Now migrate this

php artisan migrate

Create two roles: administrator, subscriber. Create a second user if doesn’t exist. In role_user attach the user to role based on ID of each. You can do 1,1 and 2,2.

Now we need to define the relationship in the model. Open up User model and add:

    public function roles(){
        return $this->belongsToMany('App\Models\Role');
        //To customize tables name and columns follow the format below
        //(Table name, user foreign key name, role foreign key name)
        //return $this->belongsToMany('App\Models\Role', 'user_roles', 'user_id', 'role_id');
    }

Now let’s see roles in action. Add this to routes:

Route::get('/user/{id}/role', function($id){
    $user = User::find($id);
    foreach($user->roles as $role){
        echo $role->name.'<br>';
    }
});

Another way to find roles:

Route::get('/user/{id}/role', function($id){
    $user = User::find($id)->roles()->orderBy('id', 'desc')->get();
    return $user;
});

Update your Post model by adding this:

    public function posts(){
        return $this->hasMany('App\Models\Post');
    }

We can now display the user’s post titles in our routes:

use App\Models\User;

/*
|--------------------------------------------------------------------------
| ELOQUENT Relationships
|--------------------------------------------------------------------------
*/

Route::get('/posts', function(){
    $user = User::find(1);
    foreach($user->posts as $post){
        echo $post->title.'<br>';
    }
});

View in your browser.

Update your Post model by adding this:

    public function user(){
        return $this->belongsTo('App\Models\User');
    }

We can now display the post’s user in our routes:

use App\Models\User;

/*
|--------------------------------------------------------------------------
| ELOQUENT Relationships
|--------------------------------------------------------------------------
*/

Route::get('/post/{id}/user', function($id){
    return Post::find($id)->user->name;
});

View in your browser.

Update your post migration to have a user_id column

        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->integer('user_id')->unsigned();
            $table->string('title');
            $table->text('content');
            $table->timestamps();
        });

Update your migrations with

php artisan migrate:refresh

Add a user and a post in your database, where you add the user ID to the new post.

Then update your User model by adding this:

    public function post(){
        return $this->hasOne('App\Model\Post');
    }

The user_id is used as the default connection to Post model. Add a second parameter to use a different id name. Add a third parameter to change the post ID.

Now that we’ve added this relationship, we can display the user’s post in our routes:

use App\Models\User;

/*
|--------------------------------------------------------------------------
| ELOQUENT Relationships
|--------------------------------------------------------------------------
*/

Route::get('/user/{id}/post', function($id){
    return User::find($id)->post->title;
});

Add this to routes

Route::get('/forcedelete', function(){
    $post = Post::onlyTrashed()->forceDelete();
});

Add this to routes

Route::get('/restore', function(){
    $post = Post::withTrashed()->where('is_admin',0)->restore();
});

Use this statement in your routes to retrieve soft deletes

Route::get('/readsoftdelete', function(){
    Post::withTrashed()->where('id',11)->get();
});

Way of retrieving all soft deletes:

Route::get('/readsoftdelete2', function(){
    $post = Post::onlyTrashed()->get();
    return $post;
});

Update your model to include soft deletes like this:

use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    protected $dates = ['deleted_at'];

}

Now create a migration (name of file with flag for name of database table to add onto)

php artisan make:migration add_deleted_at_column_to_posts_tables --table=posts

Now add your new columns to this file in the up and down functions like so:

    public function up()
    {
        Schema::table('posts', function (Blueprint $table) {
            $table->softDeletes();
        });
    }


    public function down()
    {
        Schema::table('posts', function (Blueprint $table) {
            $table->dropColumn('deleted_at');
        });
    }

Get the new column to show up with:

php artisan migrate

To your routes file add this to soft delete an item in the database:

Route::get('/softdelete', function(){
    Post::find(11)->delete();
});

Now running queries like Post::all() won’t find the soft deleted items anymore so check the database directly.

Multiple ways of deleting:

use App\Models\Post;

/*
|--------------------------------------------------------------------------
| ELOQUENT ORM (Object Relational Model)
|--------------------------------------------------------------------------
*/

Route::get('/delete', function(){
    $post = Post::find(2);
    $post->delete();
});

Route::get('/delete2', function(){
    Post::destroy(3);
});

Route::get('/delete3', function(){
    Post::destroy([4,5]);
});

Route::get('/delete4', function(){
    Post::where('is_admin',0)->delete();
});