Forem: Samfield Hawb

The Wonders of Laravel Validation Rule Class

Samfield Hawb — Sat, 02 May 2020 17:46:32 +0000

Hello reader, I am here once again. I want to talk about form handling with laravel Rule class (Illuminate\Validation\Rule), When it comes to handling forms in our applications, validations of inputs from users becomes a paramount thing to ensure that users don't enter invalid data in our forms.

Laravel out of the box offers us classes and methods to enable us to validate these inputs without much stress and logical thinking. If you are reading this, you're likely a professional or beginner when it comes to using laravel framework and I wrote this article just for you.

I will not be going deep to review laravel validations in this article, for more understanding you can check on the laravel documentation on validation, but in this article, I will be taking you through on how to use the Rule class to enhance your validation logic.

Laravel validation Rule class offers developers the ability to perform complex validations on user input without having to worry about the complex implementations of the classes or methods or worry about implementing it themselves. When I explored this class, I was so amazed by all that can be achieved with it.

I will be working with two tables for illustration,users and posts tables, with the following few structures.
users

id	name	email	password
1	Samfield Hawb	samfield4sure@gmail.com	3hyev4yeuh22wyu4h2y3u3

posts

id	title	content	category	user_id
1	My Title	my content	news	1

Let's say it happens that we want to create a new post for a user, but we need all post titles to be unique. That means no user can use a title that already exists in the database, we can run a validation on the posts table to check if the entered title already exists, if it does we reject the title and show the necessary error to the user.

public function store(Request $request){
    $input = $request->all();

    $validator = Validator::make($input, [
                'title' => [
                    "required",
                    Rule::unique('posts');
                ]
            ]);
}

Here we are using the validator make method to validate our input data. the make() method accepts two parameters, the input we want to validate and the second parameter is our validation rules. taking a look at our validation rule, we are checking the title and ensuring that the user enters the title, looking at the title rule, I supplied an array of values ['required', Rule::unique('posts')]. When using the Rule class you will need to supply an array of rules if you are combining with regular string validation,(note I ignored a second parameter to our unique method because the title matches a column on the table if we had a different column name I will supply a second parameter to indicate the column we are validating on) but it looks unusual to what most of us know which is:

  'title' => 'required|unique:posts,title'

Many will say why don't I use this since its very simple than the above, yes you are very correct, but what if I want a situation where every user can create a post with any title provided that the user has not created a post on that title, that is, post titles are unique to a user.

use Illuminate\Validation\Rule;

public function store(Request $request){
    $input = $request->all();

    $validator = Validator::make($input, [
                'title' => [
                    "required",
                    Rule::unique('posts')->where('user_id', auth()->user()->id);
                ]
            ]);
}

As you can see, we added a where clause to our Rule query builder to check only for the logged-in user, this would have been a little difficult crafting that in the above method.
Let's say we want to now update this post, but it happens that the title does not change, we can do this:

use Illuminate\Validation\Rule;

public function update($id,Request $request){
    $input = $request->all();

    $validator = Validator::make($input, [
                'title' => [
                    "required",
                    Rule::unique('posts')->where('user_id', auth()->user()-id)->whereNot('id',$id);
                ]
            ]);
}

you can see the whereNot clause we applied here to ensure that the title, even if it's unique to the user, when updating the rule does not check the id we are updating. Whao, isn't it amazing?

Rule Methods

The Rule class offers the following static methods which can be chained to achieve the validation rule we can ever imagine

Unique

The unique method accepts two parameters, table_name as the first and table_column as a second optional parameter which can be gotten from the field if it matches the column on the database table.

Exists

The Exists method ensures that the field under validation must exist on a given database table. Like the unique method, it also accepts two parameters,table_name and table_column which is also optional, if not provided the field under validation is used.

use Illuminate\Validation\Rule;

Validator::make($data, [
    'email' => [
        'required',
        Rule::exists('staff')->where(function ($query) {
            $query->where('account_id', 1);
        }),
    ],
]);

Dimension

The dimension method is used with images to ensure that the uploaded image matches a particular rule

use Illuminate\Validation\Rule;

Validator::make($data, [
    'avatar' => [
        'required',
        Rule::dimensions()->maxWidth(1000)->maxHeight(500)->ratio(3 / 2),
    ],
]);

In

The In method validate the field across given list of values in an array, in example below, I am checking the category field in my form to ensure it matches this array of categories.

Validator::make($data, [
    'category' => [
        'required',
        Rule::in(['news', 'article']),
    ],
]);

NotIn

The NotIn method validate the field across given list of values an array,in example below, I am checking the category field in my form to ensure it is not in this array of categories.

Validator::make($data, [
    'category' => [
        'required',
        Rule::notIn(['news', 'article']),
    ],
]);

RequiredIf

This method accepts a boolean or a Closure. When passed a Closure, the Closure should return true or false to indicate if the field under validation is required:

Validator::make($request->all(), [
    'role_id' => Rule::requiredIf(function () use ($request) {
        return $request->user()->is_admin;
    }),
]);

Ignore

This method is used to force the validation rule to ignore a given idduring the validation. But a second parameter can be passed to this method if our table is using a different primary key name.


use Illuminate\Validation\Rule;

public function update($id,Request $request){
    $input = $request->all();

    $validator = Validator::make($input, [
                'title' => [
                    "required",
                    Rule::unique('posts')->where('user_id', auth()->user()-id)->ignore($id /*, custom_column_name as second parameter*/);
                ]
            ]);
}

Where

This method is an addition method that can be use to perform additional query constraint like

'email' => Rule::unique('users')->where(function ($query) {
    return $query->where('account_id', 1);
})

This method accepts two parameters or a closure.

'email' => Rule::unique('users')->where('role_id', 1)

One thing I will like you to note is that the Rule class static methods always return a reference to itself. That is why its possible to chain methods to arrive at a complex rule for your input validation, for example in the code below.

 $validator = Validator::make($input, [
                'title' => [
                    "required",
                    Rule::unique('posts')->where('user_id', auth()->user()->id)->ignore(1);
                ]
            ]);
}

Conclusion

We have so far since the Rule class and the methods it provides for us to use to perform complex validations in our application, I believe you learn a lot. Follow me to get updates on my articles on Laravel as you learn a lot laravel.

Mastering Laravel Eloquent ORM - The Eloquent Journey (PART 2)

Samfield Hawb — Sun, 26 Apr 2020 22:08:16 +0000

Understanding Eloquent Relationships

Welcome once again. In this post I will be diving into Laravel Eloquent Relationships, if you missed the previous article, the link can be found at the bottom of this post.

As we all know that databases tables are often related to one another, let take for instance in a blogging platform, the users' table will be related to the posts, comments and replies tables, the comments table will be rated to the posts table, replies related to the comments table. Eloquent comes packed with the underlying structure to enable us to manage the relations between our database tables, thereby making queries between our tables simple and flexible.

Eloquent supports many types of relationships, which includes:

One To One
One To Many
Many To Many
Has One Through
Has Many Through
One To One (Polymorphic)
One To Many (Polymorphic)
Many To Many (Polymorphic)

Eloquent relationships are defined as methods in our model classes. The method names are decided by you, but make sure to give a name that can explain your relationship.

One To One

The One to One relationship is a type of relationship whereby a model is related to another model by a single data. let's say we have Profile Model that will hold the profile information about a user in our database. We will expect our users to have only one profile and a profile should belong to a single user. This kind of relationship is a one to one relationship, and to achieve this relationship, we will expect our profiles table to have a connection to our users' table using the foreign key constraint by adding a column to create this connection.

Sample Profile table

id	user_id	address
1	1	20 Markson St.

  $table->unsignedInteger('user_id')

  $table->foriegnKey('user_id')->references('id')->on('users')->onDelete('cascade')

adding the above to our profile table migration, laravel now uses this to create our relationship between our models.

we can now define our relationship between our models. since the foreign key is on the Profile model, we can now use the eloquent hasOne() method to let eloquent bind our User model to the profile model that a user in our users' table has a profile by

  /**
  *Returns an Eloquent relationship
  **/
  public function profile()
  {
    return $this->hasOne(Profile::class);
  }

Here eloquent expect that we have a user_id column existing in the profile table, but in suituation you have a different column name for our foriegn key representing our users table,

id	`custom_user_id`	address
1	1	20 Markson St.

we can tell Eloquent by providing the second parameter to our hasOne() method

  return $this->hasOne(Profile::class, 'custom_user_id');

Eloquent also expect that on our user table the primary key is id, but in cases we have a different primary key other that id,

Sample User Table

`user_id`	name
1	Samfield Hawb

we can pass the third parameter

  return $this->hasOne(Profile::class, 'custom_user_id','user_id');

with this we have a relationship between the User model and Profile model. Now let create a reverse of the relationship using the Eloquent belongsTo() method. we will define the reverse now in our Profile Model class;

/**
*Returns an Eloquent Relationship
*/
public function user()
{
  return $this->belongsTo(User::class);
}

Also here eloquent will try to match user_id on the profiles table with an id on the users' table, and in situation you have a different column name for our foreign key on our profile table,

id	`custom_user_id`	address
1	1	20 Markson St.

we can tell Eloquent by providing the second parameter to our belongsTo() method

  return $this->belongsTo(User::class, 'custom_user_id');

Eloquent also expect that on our user table the primary key is id, but in cases we have a different primary key other than id,

`user_id`	name
1	Samfield Hawb

we can pass a third parameter

  return $this->belongsTo(User::class, 'custom_user_id','user_id');

With this set up, we can now use this relationship to perform a query between this two models

  $user = \App\User::find(1);
  $user->profile;//the profile can now be gotten by

  //likewise in the opposite direction
  $profile = \App\Profile::find(1);
  $profile->user; //gets the user that owns the profile
  $profile->user->name; //returns the name of the user

One To Many

This is a relationship whereby a model is related to another model by many records, for instance, A user in a blogging application can have many blog posts, comments, as well as replies, likewise a comment, post, or replies can belong to a user in the users' table. Eloquent provides us with hasMany() method to create this kind of relationship between our models. So let's define this kind of relationship between a User model and a Post Model, in a User model we add;

Sample Posts Table

id	title	content	`user_id`
1	Mastering laravel Eloquent ORM	content	1

public function posts()
{
  return $this->hasMany(Post::class);
}

here Eloquent expect a foriegn key column user_id in our posts table, but i situation we have a different name,

id	title	content	`custom_user_id`
1	Mastering laravel Eloquent ORM	content	1

a second parameter can be pass to the hasMany() method,

return $this->hasMany(Post::class,'custom_user_id');

likewise if we have a diffent primary key for the parent model User from the id column which Eloquent expect, we can also pass in a third parameter to the hasMany() method

return $this->hasMany(Post::class,'custom_user_id','user_id')

we have created a relationship for our User model to the Post model. Now let create the reverse of the relationship, Post model to the User model, this can be achieve also with the Eloquent belongsTo() method ;

public function user()
{
  return $this->belongsTo(User::class);
}

here eloquent will still try to match user_id on the posts table with an id on the users' table, in situation you have a different column name for our foreign key on our posts table, we can tell Eloquent by providing the second parameter to our belongsTo() method

  return $this->belongsTo(User::class, 'custom_user_id');

Eloquent still expect that on our user table the primary key is id, but in cases we had a define primary key name other that id, we can pass a third paramater to the belongsTo() method;

  return $this->belongsTo(User::class, 'custom_user_id','user_id');

with this set up now, we can now make use of eloquent to query data between the models. Lets get all the posts made by a user with id of 1 from the database;

  $user = \App\User::findOrFail(1); //we retrieve the user

  //lets print out the title for all the post made 
  foreach ($user->posts as $post)
  {
    echo $post->title;
  }

we have seen how easy eloquent has made retrieving the post here, with this relationship, we can create a post that binds to a particular user;

  $user = \App\User::find(1);
  $user->posts()->create([
    //we supply all keys representing the column name and the value in
    // 'key' => 'value'
  ]);

with the above code snippet, Eloquent automatically extracts the user_id from the $user object to create a blog post. likewise, using the createMany() method on the relationship can allow you to store many blog posts at a time to a user. We will come to this later.
Let's say we want to get the name of a user that owns a post, we can easily achieve this too from the relationship;

  $post = \App\Post::find(1);
  echo $post->user->name;

Many To Many

At times when building a web application, we want to related values in a table with other values in another, for instance, if we want to introduce a role system into our blog, a user can have multiple roles, also a role can belong to multiple users. Laravel Eloquent provides us with the many to many relationships, to achieve this, we will need to create another table using the laravel migration that will store up this relationship, create_role_user_table,

$ php artisan make:migration create_role_user_table --table=role_user

in the up method of our generated migration file, we can add

  $table->unsignedInteger('user_id');
  $table->unsignedInteger('role_id');
  //foriegn key
  $table->foriegnKey('user_id')->references('id')->on('users')->onDelete('cascade');
  $table->foriegnKey('role_id')->references('id')->on('roles')->onDelete('cascade')

here, eloquent uses these two columns to fetch our data when needed.

Sample role_user table with data

user_id	role_id
1	1
1	4
1	3
2	4

We can see how this user with id 1 has 3 roles with ids 1, 4, 3.
Now on our User model we can now define our relationship using the belongsToMany() method provided for use by Eloquent Model class

public function roles()
{
  return $this->belongsToMany(Role::class);
}

Eloquent seeing this relationship will try to determine the table for we created above by joining the two related models in alphabetical other separated by an underscore role_user. In situations we declared a name other than this, we can pass a second parameter to our belongsToMany method to tell Eloquent where to find the relationship.

   return $this->belongsToMany(Role::class,'custom_role_user');

Also, if we had custom keys for the table other than the expected value, we can pass the third parameter as a foreign key for the model we are defining the relationship and a fourth parameter for the foreign key to the relating model

    return $this->belongsToMany(Role::class,'custom_role_user','custom_user_id','custom_role_id');

we can then define the inverse of the relationship on our role model too, which will enable use query all users that is tied to a particular role.

public function users()
{
  return $this->belongsToMany(User::class);
}

With the relationships define, we can then fetch our data from the database using eloquent ORM;

$user = \App\User::find(1);
foreach ($user->roles as $role)
{
  echo $role->name
}

$role = \App\Role::find(1);
foreach($role->users as $user)
{
  echo $user->name;
}

we can assign a role to a user using the relationship and the attach() method from the Model class

$user = \App\User::find(1);
$user->roles()->attach(1); //assigned role with id 1 to the user

$user->roles()->attach([2,3,4]); //assigned roles with ids 2,3,4 to the user

also roles can be remove from users using the eloquent detach() method;

$user = \App\User::find(1);
$user->roles()->detach(1); //remove role with id 1 to the user

$user->roles()->detach([2,3,4]); //remove roles with ids 2,3,4 to the user

Conclusion

So far we have covered the One to One, One To Many, and Many To Many relationship types made available by eloquent, in the next article we will look into the remaining types. Thank you for following this far.

Links to Previous articles:

Mastering Laravel Eloquent ORM - The Eloquent Journey (PART 1)

Mastering Laravel Eloquent ORM - The Eloquent Journey (PART 1)

Samfield Hawb — Fri, 10 Jan 2020 12:28:46 +0000

Laravel is a web application framework with an expressive, elegant syntax, and also currently the most popular PHP framework ever existed.

Eloquent ORM is inclusion in Laravel which enables developers to interact with the database of their applications. I know many people may ask “why should I use ORM when I know my SQL QUERIES?”. I will say that it’s possible to know your SQL queries but I bet you that you may only be limited to one or two databases, but laravel eloquent has support for many underlying database types. You just need to write your eloquent command and allow laravel eloquent to initiate the queries.

Let me show you what I'm talking about, I'm assuming you have your laravel project set up already, with the correct database type in config/database.php of your project. Right out of the box, laravel is configured to use MySQL so we will stick to that for this post.

'default' => env('DB_CONNECTION', 'mysql')

and in your connection array

'mysql' => [
            'driver' => 'mysql',
            'url' => env('DATABASE_URL'),
            'host' => env('DB_HOST', '127.0.0.1'),
            'port' => env('DB_PORT', '3306'),
            'database' => env('DB_DATABASE', 'forge'),
            'username' => env('DB_USERNAME', 'forge'),
            'password' => env('DB_PASSWORD', ''),
            'unix_socket' => env('DB_SOCKET', ''),
            'charset' => 'utf8mb4',
            'collation' => 'utf8mb4_unicode_ci',
            'prefix' => '',
            'prefix_indexes' => true,
            'strict' => true,
            'engine' => null,
            'options' => extension_loaded('pdo_mysql') ? array_filter([
                PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
            ]) : [],
        ],

Let us say we want to create a blogging platform and we expect to have the following tables (entities) in our database:

Users
Posts
Comments
Replies

The Laravel framework out of the box provides us with the User Model and the create_users_table migration file which exist under the database/migrations folder of our project (migrations are the PHP files which laravel will use to create our database structure). The User Model here represents an entity in the users’ table of our project. Let’s have a look at what the User model which exist in the app/ folder looks like

//User.php


<?php

namespace App;

use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;

class User extends Authenticatable
{
    use Notifiable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name', 'email', 'password',
    ];

    /**
     * The attributes that should be hidden for arrays.
     *
     * @var array
     */
    protected $hidden = [
        'password', 'remember_token',
    ];

    /**
     * The attributes that should be cast to native types.
     *
     * @var array
     */
    protected $casts = [
        'email_verified_at' => 'datetime',
    ];
}

Looking at the User model we see that the User model extends the User class in Illuminate\Foundation\Auth\User imported as Authenticatable, this class behind the extends the Model class and implements lots of interfaces.

//Illuminate\Foundation\Auth\User.php

<?php

namespace Illuminate\Foundation\Auth;

use Illuminate\Auth\Authenticatable;
use Illuminate\Auth\MustVerifyEmail;
use Illuminate\Auth\Passwords\CanResetPassword;
use Illuminate\Contracts\Auth\Access\Authorizable as AuthorizableContract;
use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
use Illuminate\Contracts\Auth\CanResetPassword as CanResetPasswordContract;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Foundation\Auth\Access\Authorizable;

class User extends Model implements
    AuthenticatableContract,
    AuthorizableContract,
    CanResetPasswordContract
{
    use Authenticatable, Authorizable, CanResetPassword, MustVerifyEmail;
}

But our focus will be our Model class which is the brain of our Eloquent ORM.

All models representing our database entities must extend the Illuminate\Database\Eloquent\Model, which is used by eloquent to create communication between our application and the database. Let's run the following command to create a Post model and migration;

$ php artisan make:model Post -m
Model created successfully.
Created Migration: 2020_01_07_015353_create_posts_table

The -m directive here instruct laravel to create our migration file alongside creating for our Post model. Let’s take a look at our generated Post model existing in our App namespace.
//Post.php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    //
}

Notice that our Post model is extending the Illuminate\Database\Eloquent\Model class, which provide the Post model with the superpowers of Eloquent ORM

Protected $table

If your table name is different from what you have as your model name (let’s say you had an existing database with tables which you want to bind to your laravel project ), you can set up the $table property of the Model class specifying the table name;

protected $table = 'app_posts'; // replace users with your custom table name

one thing to note is that models are singular form for your plural table names, for example, User Model is applicable to users table.

Protected $primaryKey

Also eloquent takes your primary key to be id, but you can as well override this to a custom column name by setting the protected $primaryKey value to your primary key column name.

 protected $primaryKey = 'post_id'; // custom column to use as primary key

NOTE: We will discuss more on customizing of models in subsequent articles

Let’s run our migrations so that laravel will generate our tables for us with the following command

$ php artisan migrate

Let’s create a user for our database, take a look at the create_user_table provided for us in database/migrations, inside our up method of the CreateUserClass with extends the Illuminate\Database\Migrations\Migration class (we will discuss on this class), the columns created for our users’ table can be seen there. On the terminal of your project root, type the following

save() method

We are going to use the interactive shell provided for us by laravel framework,run the following command;

$ php artisan tinker

we are going to use this shell to create a new user,

>>> $user = new \App\User;
>>> $user->name = “Samfield Hawb”;
>>> $user->email = “samfield4sure@gmail.com”;
>>> $user->password = bcrypt(“secret”);
>>> $user->save(); //eloquent save() method
>>> exit
$ Exit:  Goodbye

Under the hood of the save() method, eloquent performs the SQL insert command for us, saving us the stress of thinking on how we can insert the values correctly.

create() method

The above code snippet can also be achieved with the static create() method of the model class, which accepts a keys/values pair array, with the keys representing the table column names.

$user = \App\User::create([
    'name' => 'Samfield Hawb',
    'email' => 'samfield4sure@gmail.com',
    'password' => bcrypt('secret')//create an encrypted password
]);

Once the create method is executed, our user gets created with the $user containing the created user and a generated id property.

Protected $fillable

The command creates a new user in the database too. In other for the create method to work for us, we will need to include the column fields here in our protected $fillable property of our model, we are doing this because Eloquent by default protects all it models against mass assignment vulnerability.
According to Laravel documentation,

A mass-assignment vulnerability occurs when a user passes an unexpected HTTP parameter through a request, and that parameter changes a column in your database you did not expect. For example, a malicious user might send an is_admin parameter through an HTTP request, which is then passed into your model's create method, allowing the user to escalate themselves to an administrator.

So adding the fields in our $fillable array, we instruct Eloquent to allow for the mass assignment of the fields.

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name', 'email', 'password',
    ];

Protected $guarded

The reverse for the fillable property is protected $gaurded, which can be used to specify the fields we cannot allow for mass assignment

    /**
     * The attributes that are not mass assignable.
     *
     * @var array
     */
    protected $gaurded = [
        'password',
    ];

all() method

With our user model now, let’s say we want to retrieve all our users from the database by

$users = App\User::all();

Calling the starting method all() which eloquent provides for us, return a collection of all the users in our database

Under the hood, laravel is executing the MySQL command (since we are using MySQL database)

SELECT * from users

With the collection return, we can easily perform actions with our data. Let print out the names of all the users returned (that will be only if you have data on the users’ table), Let print out the names of all the users from our database now.

foreach ($users as $user)
{
    echo $user->name;
}
//Samfield Hawb

find() method

Laravel Eloquent provides us with the find() method which can be used to get an instance of a model record or records. When the find method is passed in a primary key, it returns a single record matching the primary key, if no record its found, eloquent returns a null.

 $user = App\User::find(1);

Here we instruct Eloquent to retrieve the user with the primary key 1

SELECT * FROM users WHERE id=1

An array of primary keys can also be passed to the find() method of our model,

$users = App\User::find([1,2,3]);

When this is done the underlying Eloquent fetches and return a collection of records for the primary keys passed to it,

findOrFail() method

In most situations, we may want to throw an error when no model is found for a primary key. This can be achieved using the findOrFail() method on our model

 $user = App\User::findOrFail(1);

When a model is not found, an Illuminate\Database\Eloquent\ModelNotFoundException will be thrown. If the exception is not handled, a 404 HTTP response is automatically sent back to the user which is the Laravel way of handling the ModelNotFoundExeption error.

Conclusion

So far you have seen basically how eloquent is making queries simple. Watch out for my next article, as we continue our journey to see Eloquent ORM superpowers in action.