• To start it as we all know we have to create a project (xampp/htdocs directory) in our terminal by running the command given below:

composer create-project --prefer-dist laravel/laravel multi-auth "5.8.*"

cd multi-auth

• Once we have created the project we will run the make:auth command to create the default login authentication system of laravel.

php artisan make:auth

• Now we need to customize the users_table under migration as per our requirement.

• Now we have to create model and migration for role table where we can see the different roles who can login like ‘admin’, ‘user’ etc.

php artisan make:model Role -m

• In the roles table we will customize the Schemas as per the requirement.

• So now we have two model naming Users and Roles and both are dependent on each other hence we need to make a relationship between them.
• To create a relationship we will create functions in both the model for the other one by giving the command given below.

• In the next step we need to create seeders for each of the model (User , Role). To create the UsersTableseeder and

RolesTableSeeder we will run the command given below.

php artisan make:seed UsersTableSeeder
php artisan make:seed RolesTableSeeder

• After the following step we need to add insert function in the UsersTableseeder and RolesTableSeeder and also declare the use Illuminate\Support\Facades\DB; in both the seeders in the beginning since we will be using DB class in the seeders.

• Once we are done with the steps given above we will create a database and link it with the project in the .env file. In this project I have named the database as corona (since it is in trend ) and added that in my .env file as shown below, with that we will keep the username as root and leave the password blank.

• Once done with the database creation we will migrate our tables into the database with the command given below.

php artisan migrate

• In the next step we need to define two created seeders files (UsersTableSeeder and RolesTableSeeder) into the DatabaseSeeder.php as shown below:

• Now we need to import our data stored in the Seeder files into the database which we created using the command:

php artisan db:seed

• Until here we have set up the database for storing the details which will be provided by the user and now we need to create the controllers and the middleware to authenticate and redirect the users to there respective pages.
• First of all we need to create controller for User and the Admin.
• To create the controller we need to the follow the command given below:

php artisan make:controller Admin/AdminController
php artisan make:controller User/UserController

• Now we will be creating middleware for the authentication of the Admin and the User.

php artisan make:middleware AdminMiddleware
php artisan make:middleware UserMiddleware

• Now we will add Auth trait in the AdminMiddleware and UserMiddleware for authentication of the User and the Admin by writing use Auth;
• In the next step we will add handle() function in the AdminMiddleware and UserMiddleware.

• We will also implement Condition for Admin and User Login in RedirectIfAuthenticated which is in app/Http/Middleware/RedirectIfAuthenticated.php.

• Now we will be implementing condition in the login controller before that we will remove ‘/home’ from protected $redirectTo = ‘/home’; since we don’t want to redirect the page to Home after logging in.

• Likewise we will implement condition in the ResetPasswordController and remove ‘/home’ from protected $redirectTo = ‘/home’;

• Once we are done with the above steps we will use AdminMiddleware and UserMiddleware in Kernal.php which is in app/Http/Kernel.php.

use App\Http\Middleware\AdminMiddleware;
use App\Http\Middleware\UserMiddleware;

• After that we need to define and for defining we will add the command given below in routeMiddleware.

'admin' => AdminMiddleware::class,
'user' => UserMiddleware::class,

• Now we are almost done with it and need to write the routes for the Admin and the User.

• Almost done but we need to make the views as well where we can redirect the admin or user once they login.

-Create a blade file for Admin dashboard under resource/views/admin/dashboard.blade.php.

-Create a blade file for User dashboard under resource/views/user/dashboard.blade.php.

• Under the dashboard blades of User and Admin we can write the basic HTML to check whether it is showing it when redirected.

It’s good to go now. You can leave a comment if getting any error while following the steps.

The post How to Create Multiple Role Based Authentication in Laravel 5.8 appeared first on scmGalaxy.

https://www.scmgalaxy.com/tutorials/explanation-of-database-migrations-in-laravel-5-8/

Once we are done with creating a migration file, to create a new database
table we have to use the create method on the Schema facade. The create method accepts two arguments:-

The first is the name of the table, while the second is a closure which receives a Blueprint object that may be used to define the new table:

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email');
    $table->timestamps();
});

In the table we can add number of $table as per our requirement. There are several data type which we can use while creating the $table. Few of them are given below:

bigIncrements()

The bigIncrements method creates an auto-incrementing UNSIGNED BIGINT (primary key) equivalent column:

$table->bigIncrements('id');

bigInteger()

The bigInteger method creates a BIGINT equivalent column:

$table->bigInteger('votes');

id()

The id method is an alias of the bigIncrements method. By default, the method will create an id column; however, you may pass a column name if you would like to assign a different name to the column:

$table->id();

rememberToken()

The rememberToken method creates a nullable, VARCHAR(100) equivalent column that is intended to store the current “remember me” authentication token:

$table->rememberToken();

string()

The string method creates a VARCHAR equivalent column of the given length:

$table->string('name', 100);

text()

The text method creates a TEXT equivalent column:

$table->text('description');

To know more about creating tables and adding columns, you can refer the video given below:

The post Creating tables in Migration appeared first on scmGalaxy.

After the create operation we need to store the data in the database for this we used <form action=”{{route(‘store’)}}” method=”POST”> which will call store function. The store function be like

The in store function we create object $var of Task class make variables as $var->task which is assigned $request->task; (gets value from 1^st field) & $var->detail which is assigned $request->detail; (gets value from 2^nd field) and $var->save(); function will save it to the database.

The post How Control flow in Laravel appeared first on scmGalaxy.

We need to have the composer installed in our system. Then we need to download the Laravel installer, the command for installation is
composer global require “laravel/installer=~1.1”
if this does not works then we could just write
composer global require “laravel/installer”
and it would install the file.
Then we need to create a project and for this, we need to type
composer create-project –prefer-dist laravel/laravel blog “5.8”
if this does not works then we could just write
composer create-project –prefer-dist laravel/laravel blog
it would create a Laravel project named blog.

Soon after the project is created we now have to

Understanding the Folder structure

The most important thing in the Laravel project is understanding the structure of files and folders. Understanding the files and folder structure’s main purpose is to understand where we need to write codes for Html, Model, Controller, Routing, Filestore, Config, and Database.
The time after the Laravel project is created we see different folders and files. All the files and folder build while building the project have their use and gives it easy access while writing codes.
The main folder in the project consists of

Let’s take a brief look at the different folders created and the files in them.

The first one App mainly includes codes for HTML, Model, and Controller which are in folders shown below.

In the console directory, there is a kernel.php file that has codes for the custom command.
Exception folders have handler.php that includes all the codes for different exceptions.
The HTTP folder has 2 sub-folders namely controllers and middleware.

Controllers and Middleware mainly include files acting as a bridge between database and webpage. These include files for authentication login validation, registering ids, resetting the password, etc.

Cookies that are used to store some data of the user are also managed here. Controllers act as an interface between database and web-page and Middleware filters out the request.

The Model directory contains all of your model classes. It provides a beautiful, simple ActiveRecord implementation for working with your database. Each database table has a corresponding “Model” which is used to interact with that table. Models allow you to query for data in your tables, as well as insert new records into the table.

Then we have a Provider directory.

where we write different kinds of services like authentication services, routing services, and more.

Then we have Bootstrap directory that has an app.php file that helps in bootstrapping the application i.e loading the application on the browser.

Then we have a config directory that contains all the configuration files like database configurations, email configurations, session configurations, login configurations, catch configurations, and many more.

The database directory mainly includes three folders i.e factories, migrations, and seed.

Factories provide a convenient way to generate new model instances for  testing/seeding the application’s database. In Migrations, one database is shared with another database and also between developers. Seeding simply means putting the fake/dummy data in the database.

The public directory

has CSS, js, and more files that have predefined JavaScript and CSS of the project and most importantly index.php file. This is the first file that is loaded in the browser when our server (local server) is hosted.

The resource directory

is the important part where all the public files of HTML, CSS, js files are coded and sometimes local files. This directory most importantly includes views where we write the complete HTML. All the HTML pages that we want to display shall be placed here. These files can be placed directly or can placed inside the folder in views.

The route directory’s main purpose is placing the codes for URLs for the web as well as API.

The storage directory contains the app, framework, and log directory. The storage directory is used to store framework-generated files and caches. They also contain compiled Blade templates, file-based sessions, file caches, and other files generated by the framework and the log directory contains your application’s log files.

The test directory contains automated tests. We may run tests using the phpunit or php vendor/bin/phpunit commands.

Vendor directory stores all the package files which are installed by the composers.

In simple terms, the vendor directory acts as a store-keeper for all the package files for the project in laravel.

We have few more files that are necessary like environment file (env.php), composer file (composer.json), package file (package.json).

We use webpack.mix.js for integration of CSS and js files from different developers for effective use. It also serves as a better security for CSS and js files in the project so that it cannot be publicly accessed.

The post Setup a Laravel Project and Understand the Folder Structure appeared first on scmGalaxy.