Custom User Email Verification / Activation Laravel

In this article, we will discuss how to make a Custom User Email Verification / Activation Laravel for the user and send an activation link to the user registered email address.

Before starting with the custom user email verification and activation. Please make sure, we need a basic Laravel setup with the Laravel default Authentication. If you are not familiar with this setup,  please follow the links.

Creating New Modal and Migration for VerifyUser

We need to create a new table in our database which is holding the verification code. This code is sent to the user email for account activation. Let go with the given Laravel Artisan command:

1. php artisan make:modal VerifyUser -m

You can run this command in command prompt, terminal, git bash or any of the IDE which provides the CLI interface. After running this command, generate a modal VerifyUser.php in the App folder. This command also create a migration file verify_user for VerifyUser.php modal under database/migration folder because we are using -m option.

Update the Migration file and Migrate Table

Now its time to update the migration file and migrate table. The migration file is available in database/migrationsfolder and file name you get in the console when you create the modal command. Let replace the default code with the given code.

1. <?php
3. use Illuminate\Support\Facades\Schema;
4. use Illuminate\Database\Schema\Blueprint;
5. use Illuminate\Database\Migrations\Migration;
7. class CreateVerifyUsersTable extends Migration
8. {
9. /**
10. * Run the migrations.
11. *
12. * @return void
13. */
14. public function up()
15. {
16. Schema::create('verify_users', function (Blueprint $table) {
17. $table->integer('user_id');
18. $table->string('token');
19. $table->timestamps();
20. });
21. }
23. /**
24. * Reverse the migrations.
25. *
26. * @return void
27. */
28. public function down()
29. {
30. Schema::dropIfExists('verify_users');
31. }
32. }

Nore user_idthat will be the foreign key of the primary key from the user’s table. Also, modify the migration file for the user’s table to include a new boolean field to maintain the status of account verification.

1. $table->boolean('verified')->default(false);

Now the time to refresh the DB using migrate:refresh command.

1. php artisan migrate:refresh
2. Rolling back: 2018_02_23_175157_create_verify_users_table
3. Rolled back: 2018_02_23_175157_create_verify_users_table
4. Rolling back: 2014_10_12_100000_create_password_resets_table
5. Rolled back: 2014_10_12_100000_create_password_resets_table
6. Rolling back: 2014_10_12_000000_create_users_table
7. Rolled back: 2014_10_12_000000_create_users_table
8. Migrating: 2014_10_12_000000_create_users_table
9. Migrated: 2014_10_12_000000_create_users_table
10. Migrating: 2014_10_12_100000_create_password_resets_table
11. Migrated: 2014_10_12_100000_create_password_resets_table
12. Migrating: 2018_02_23_175157_create_verify_users_table
13. Migrated: 2018_02_23_175157_create_verify_users_table

Use of the above command, All the present table’s rollbacked and recreated. Please note that use of this caused lost all the present data.

With this, verify_userstable created in your database with following structure.

and the users table is modified, and having verified field. Please check the given screenshot

Define Relations in Modal

Now, our tables are ready. Let’s now go ahead and specify the one-to-one relationship between Userand VerifyUserModel.

Add following method to the User.phpModel class. Because Laravel already provides the default User Modal.

1. public function verifyUser()
2. {
3. return $this->hasOne('App\VerifyUser');
4. }

Update following class to the VerifyUser.php Model class. Because we already create this modal when we create the migration.

1. class VerifyUser extends Model
2. {
3. protected $guarded = [];
5. public function user()
6. {
7. return $this->belongsTo('App\User', 'user_id');
8. }
9. }

Send Verification Email to Registered User Email

To send email’s make sure you have your mail properties set up in .env file of your project. Laravel provides the default configuration for Mailtrap SMTP. You need to add your Mailtrap API credentials in the .env file.

In Laravel, all the emails sent by the Mailable class. To generate one such class for our verify user’s email on registration. Let’s generate a class with artisan command. Run the given below command in your terminal.

1. php artisan make:mail VerifyMail

After above command is executed, A new Class named VerifyMail.phpwill be generated under App/Mail. This class will have a build method which defines which view file to send an email.

1. <?php
3. namespace App\Mail;
5. use Illuminate\Bus\Queueable;
6. use Illuminate\Mail\Mailable;
7. use Illuminate\Queue\SerializesModels;
8. use Illuminate\Contracts\Queue\ShouldQueue;
10. class VerifyMail extends Mailable
11. {
12. use Queueable, SerializesModels;
14. public $user;
16. /**
17. * Create a new message instance.
18. *
19. * @return void
20. */
21. public function __construct($user)
22. {
23. $this->user = $user;
24. }
26. /**
27. * Build the message.
28. *
29. * @return $this
30. */
31. public function build()
32. {
33. return $this->view('emails.verifyUser');
34. }
35. }

We will create a emails folder under resources/views in which we will keep our email views. Also as you can see we have declared the $user as public and we are setting the variable in the constructor. Variables are declared as a public is by default available in the view file. Thus you can directly refer to the variable to get the user-related data.

Let’s go ahead and create the view file to send an email. Create a new file verifyUser.blade.phpunder resources/views/emails and add following contents into it.

1. <!DOCTYPE html>
2. <html>
3. <head>
4. <title>Welcome Email</title>
5. </head>
6. <body>
7. <h2>Welcome to the site {{$user['name']}}</h2>
8. <br/>
9. Your registered email-id is {{$user['email']}} , Please click on the below link to verify your email account
10. <br/>
11. <a href="{{url('user/verify', $user->verifyUser->token)}}">Verify Email</a>
12. </body>
13. </html>

Now since we have the necessary code ready to send the verification email to the user. Let’s modify our RegistrationController class to send emails. This class located under App/Http/Controllers/Auth and modify the create method as given below:

1. protected function create(array $data)
2. {
3. $user = User::create([
4. 'name' => $data['name'],
5. 'email' => $data['email'],
6. 'password' => bcrypt($data['password']),
7. ]);
8. $verifyUser = VerifyUser::create([
9. 'user_id' => $user->id,
10. 'token' => sha1(time())
11. ]);
12. \Mail::to($user->email)->send(new VerifyMail($user));
14. return $user;
15. }

We are generating a new random token using sha1(time())and storing it in the verify_users table against the user_id, After that, we use the Mail facade to send VerifyMail to the users.

Setup Route and Controller for Verify User Functionality

Let’s now functionality of user verification that is the code that will be executed when the user clicks on the link sent to his email account.

Create a route for verify token, It will be better if you keep it together with your Authentication routes.

1. Route::get('/user/verify/{token}', 'Auth\RegisterController@verifyUser');

Since the functionality is related to User Registration we will create a new method verifyUser in RegisterController.php

1. public function verifyUser($token)
2. {
3. $verifyUser = VerifyUser::where('token', $token)->first();
4. if(isset($verifyUser) ){
5. $user = $verifyUser->user;
6. if(!$user->verified) {
7. $verifyUser->user->verified = 1;
8. $verifyUser->user->save();
9. $status = "Your e-mail is verified. You can now login.";
10. } else {
11. $status = "Your e-mail is already verified. You can now login.";
12. }
13. } else {
14. return redirect('/login')->with('warning', "Sorry your email cannot be identified.");
15. }
16. return redirect('/login')->with('status', $status);
17. }

The verifyuser method accepts a token from the URL and it goes ahead and finds the user that is associated with that token. It confirms that the user exists and is not verified yet and then goes ahead and changes the verification status in the database. Various status and warning messages are viewed when redirecting the user to display in the view file.

Restricting User Access for Un-Verified Users

Now, we have our email verification and user account activation process. And need one more important thing to be done before mark this complete. We should not be allowed the un-verified user’s to access the application pages until they are verified. Thus we need to apply checks at two places “after user Login” and “after new user Registration”.

1. public function authenticated(Request $request, $user)
2. {
3. if (!$user->verified) {
4. auth()->logout();
5. return back()->with('warning', 'You need to confirm your account. We have sent you an activation code, please check your email.');
6. }
7. return redirect()->intended($this->redirectPath());
8. }

The authenticated method is executed just after the user is authenticated. We will override this and will use this to check if the user is activated. If not we will log him out and send back to login page with the warning message.

Modify RegisterController.php and override the registered method from RegistersUsers

1. protected function registered(Request $request, $user)
2. {
3. $this->guard()->logout();
4. return redirect('/login')->with('status', 'We sent you an activation code. Check your email and click on the link to verify.');
5. }

The registered method is executed just after the user is registered into the application, we will override and modify this to log him out and send him back to login with the status message.

Last we need to modify our login.blade.php file which is located under resources/views/auth. Add the following code to display the appropriate status messages.

1. @if (session('status'))
2. <div class="alert alert-success">
3. {{ session('status') }}
4. </div>
5. @endif
6. @if (session('warning'))
7. <div class="alert alert-warning">
8. {{ session('warning') }}
9. </div>
10. @endif

Conclusion

In this article, we are discussing the custom email verification for users. This is not the only way to build this kind of email verification. Laravel provides the rich feature for development. So we can do more secure and flexible as per the needs. This is the basic solution for user email verification.

Please check back our other Laravel post. And feel free to comments for any query.