Mastering Laravel : From Fundamentals to Advanced Web Development

Eloquent Relationship: One To One

Creating a one-to-one relationship between anauthorand aprofilein Laravel using Eloquent involves several steps, including creating migrations, models, and defining the relationship.

Create Migrations and model

php artisan make:model Author --migration php artisan make:model Profil --migration

Define Migrations

Edit the migrations to define the structure of your tables.

authorsmigration may look something like this:

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

profilesmigration should include a foreign key referencing theauthorstable:

Schema::create('profiles', function (Blueprint $table) { $table->id(); $table->unsignedBigInteger('author_id'); $table->string('bio'); $table->timestamps(); $table->foreign('author_id')->references('id')->on('authors')->onDelete('cascade'); });

Let's break down what each part of this statement does:

1. $table->foreign('author_id'): This part of the statement is declaring that theauthor_idcolumn in theprofilestable is a foreign key. A foreign key is a field in one table, which is a primary key in another table. In this case,author_idin theprofilestable will correspond to theidin theauthorstable.
2. >references('id'): This specifies which column in the foreign table (authors) theauthor_idcolumn is related to. Here, it's saying thatauthor_idreferences theidcolumn of theauthorstable. This creates a direct link between the two tables, where eachauthor_idin theprofilestable points to anidin theauthorstable.
3. >on('authors'): This part specifies the name of the foreign table that the foreign key relates to. In this case, it's theauthorstable.
4. >onDelete('cascade'): This is a referential action related to the foreign key. When a record in the parent table (authors) is deleted, theonDelete('cascade')action specifies that all records in the current table (profiles) that reference the deleted record should also be deleted. This helps in maintaining the integrity of your data. For example, if an author is deleted, their associated profile in theprofilestable will also be automatically deleted, preventing orphaned records.

Define Eloquent Models

In your Eloquent models, define the one-to-one relationship.

In theAuthormodel:

public function profile() { return $this->hasOne(Profil::class); }

In theProfilmodel:

public function author() { return $this->belongsTo(Author::class); }

Using the Relationship

With the relationships defined, you can now easily access theprofileof anauthorand

do the opposite ;

To access the profile of an author:

$author = Author::find(1); $profile = $author->profile;

To access the author of a profile:

$profile = Profile::find(1); $author = $profile->author;

using tinker to associate an author with a profile

$author = new Author(); $author->save(); $profile = new Profile(); $author->profile()->save($profile); // $authors = Author::get(); // return list of authors with their profile $authors = Author::with('profile')->get(); // return only one author $author = Author::with('profile')->whereId(1)->first(); // list of profiles : $profiles = Profile::get(); // list of profiles with authors : $profiles = Profile::with('author')->get();

Eloquent Relationship: One To Many

Creating a one-to-Many relationship between anpostand acommentin Laravel using Eloquent involves several steps, including creating migrations, models, and defining the relationship.

Create Migrations and Models

php artisan make:model Comment --migration

Comments Migration

Thecommentsmigration should include a foreign key referencing thepoststable:

Schema::create('comments', function (Blueprint $table) { $table->id(); $table->unsignedBigInteger('post_id'); $table->text('comment'); $table->timestamps(); $table->foreign('post_id')->references('id')->on('posts')->onDelete('cascade'); });

Define Eloquent Models

Now, define the relationships in the Eloquent models.

Post Model

In thePostmodel, define a relationship to access its comments:

public function comments() { return $this->hasMany(Comment::class); }

Comment Model

In theCommentmodel, define a relationship to access its parent post:

public function post() { return $this->belongsTo(Post::class); }

Associating Comments with a Post

Using Tinker or in your application logic, you can associate a comment with a post as follows:

$comment = new Comment(); $comment->comment= "first comment"; $post = new Post(); $post->comments()->save($comment);

// method 1 $comment = new Comment(); $comment->comment= "first comment"; $comment->post_id = x ; $comment->save(); // method 2 : associate two comment to one post $comment = new Comment(); $comment->comment= "first comment"; $comment1 = new Comment(); $comment1->comment= "second comment "; $post = Post::find(3); $post->comments()->saveMany([$comment,$comment1]);

Eloquent Relationship: Many To Many

create a many-to-many relationship in Laravel, let's use an example involvingposts,comments, and introduce a new entity,tags, to demonstrate a many-to-many relationship, since a comment typically belongs to one post directly, making it a one-to-many relationship. Tags can be applied to posts and posts can have multiple tags, perfectly illustrating a many-to-many relationship.

Step 1: Create Migrations and Models for Tags

First, create a model forTagwith a migration, and also create a pivot table migration for the many-to-many relationship betweenpostsandtags.

bashCopy code php artisan make:model Tag --migration php artisan make:migration create_post_tag_table --create=post_tag

Step 2: Migration for Tags

Edit the migration fortagsto add the necessary fields.

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

Step 3: Migration for the Pivot Table

Define the pivot tablepost_tagto store the relationships between posts and tags.

phpCopy code Schema::create('post_tag', function (Blueprint $table) { $table->id(); $table->unsignedBigInteger('post_id'); $table->unsignedBigInteger('tag_id'); $table->timestamps(); $table->foreign('post_id')->references('id')->on('posts')->onDelete('cascade'); $table->foreign('tag_id')->references('id')->on('tags')->onDelete('cascade'); });

Step 4: Define Eloquent Models Relationships

Post Model

In thePostmodel, define a relationship to access its tags.

public function tags() { return $this->belongsToMany(Tag::class); }

Tag Model

In theTagmodel, define a relationship to access its posts.

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

Step 5: Associating Tags with Posts

You can associate tags with a post using Tinker or within your application logic. Here's an example of how to attach a tag to a post:

phpCopy code $post = Post::find(1); $tag = Tag::find(1); // Attach the tag to the post $post->tags()->attach($tag->id); // Alternatively, if you have multiple tags to attach at once $post->tags()->attach([$tagId1, $tagId2]);

To detach tags from a post:

// Detach a single tag from the post $post->tags()->detach($tagId); // Detach multiple tags from the post $post->tags()->detach([$tagId1, $tagId2]); // Detach all tags from the post $post->tags()->detach();

This setup allows you to have a many-to-many relationship betweenpostsandtags, where a post can have multiple tags and a tag can be associated with multiple posts.

lazy loading and Eager Loading

In the provided code snippets, we demonstrate two different approaches to retrieving aCommentmodel in Laravel, showcasing the difference between lazy and eager loading.

Lazy Loading Example:

$comment = comment::find(2);

In this line, we are retrieving the comment with ID 2 using thefindmethod. This is an example of lazy loading, where the associatedPostmodel is not loaded at the same time as theComment. ThePostdata will only be loaded when explicitly accessed, for example,$comment->post, which would trigger an additional query to the database at that point.

Eager Loading Example:

$comment = comment::with('post')->find(2);

Here, we use thewith('post')method to eagerly load the relatedPostmodel at the same time as theComment. This means when the comment with ID 2 is fetched, the relatedPostis also retrieved in the same query operation. Eager loading is beneficial for performance when you know you will need the related model immediately, as it reduces the total number of queries made to the database.

In summary, the choice between lazy and eager loading in Laravel depends on the specific requirements of your application and when you need access to related models. Eager loading is generally used to optimize performance by reducing the number of database queries.

Example with our Project :

// mode lazy public function index() { DB::connection()->enableQueryLog(); $posts = Post::all(); foreach ($posts as $post) { foreach ($post->comments as $comment) { dump($comment); } } return view('posts.index', [ 'posts' => $posts]); } // mode eager public function index() { DB::connection()->enableQueryLog(); $posts = Post::with('comments')->get(); foreach ($posts as $post) { foreach ($post->comments as $comment) { dump($comment); } } return view('posts.index', [ 'posts' => $posts]); }

Summary

• Response Time: Eager loading can improve response times by reducing the number of database queries, especially in data-intensive scenarios.
• Performance Optimization: Developers should choose between eager and lazy loading based on the specific use case, balancing the need for immediate data access against the potential cost of extra database queries.
• Best Practice: In Laravel, it's generally a good practice to use eager loading for data that will definitely be used, especially when dealing with 'hasMany' relationships or when iterating over collections that access related models.

Model Factories

Model Factories in Laravel are a powerful feature for testing and seeding your database with dummy data. They allow you to easily generate fake data for your Eloquent models, which is extremely useful for automated testing and during development when you need to work with sample data. Here's a detailed description suitable for a course module:

Introduction to Model Factories

• Purpose: Model Factories in Laravel are used to define a blueprint for how to generate fake data for a given model. This can be used to seed databases or for testing purposes.
• Benefits: They promote DRY (Don't Repeat Yourself) principles by centralizing the logic for creating models with test data, making tests and seeders cleaner and more maintainable.

Creating a Model Factory

• Command: Use the Artisan commandphp artisan make:factory [FactoryName] --model=[ModelName]to create a new factory.
• Location: Factories are typically stored in thedatabase/factoriesdirectory.
• Structure: A factory file contains a definition method that returns an array of attribute values for the associated model.

Defining Factory States

• Factories can have multiple "states", which are variations of the base factory. This is useful when you need different sets of data for the same model.
• States are defined using thestatemethod within the factory class.

Using Factories

• Seeding: Factories can be used in database seeders to populate tables with fake data for development or testing.
• Testing: In automated tests, factories can create models with predictable data, making it easier to test various scenarios.

Example

php artisan make:factory PostFactory

 */ class PostFactory extends Factory { /** * Define the model's default state. * * @return array */ public function definition(): array { $title = fake()->sentence(); return [ 'title' => fake()->sentence(), 'content' => fake()->text(2000), 'slug' => \Illuminate\Support\Str::slug($title), 'active' => fake()->boolean(), ]; } }

Execute factory in the Tinker :

php artisan tinker Post::factory()->create();

php artisan make:migration add_userid_to_posts_table

The$table->foreignId('user_id')->constrained();line in a Laravel migration represents the definition of a foreign key constraint within your database schema. Here's a breakdown of what each part means:

• $table->foreignId('user_id'): This part creates a new column on the table nameduser_idthat is intended to store unsigned big integers (BigInteger equivalent). This is commonly used for foreign keys that reference anidfield in another table. TheforeignIdmethod is a shorthand in Laravel for creating such an integer column specifically designed to link to theidof another table, assuming thatidis an unsigned big integer.
• >constrained(): This method adds a foreign key constraint to theuser_idcolumn, linking it to theidcolumn of another table. By default, without specifying a table name as a parameter toconstrained(), Laravel assumes that the foreign key references theidcolumn of a table whose name is the singular form of the column name before_id, following Laravel's naming conventions. In this case,user_idimplies a reference to theidcolumn of theuserstable.

This line effectively does two things:

1. Creates auser_idcolumn meant to hold references to theidof theuserstable.
2. Establishes a foreign key constraint that enforces the integrity of this relationship, ensuring that each value in theuser_idcolumn corresponds to an existingidin theuserstable.

Database Seeding

Definition:Database seeding is the method of automatically populating a database with data. This data can be static, meant for configuration or initial state setup, or dynamically generated to simulate a database filled with user-generated content. Seeding is especially useful for developers and testers by providing a quick way to insert test data into a database without manually entering it.

Purpose:

• To initialize a database with the data it needs to perform correctly upon startup.
• To assist in automated testing by providing a consistent data state.
• To aid in development by giving developers a set of data to work with.

How It Works:

1. Preparation: Define the data that needs to be inserted into the database. This can include users, posts, settings, or any other entities relevant to the application.
2. Implementation: Use the seeding capabilities provided by the development framework or database management tools. For example, Laravel provides a seeding system that allows the definition of seed classes, each responsible for seeding specific tables.
3. Execution: Run the seeding process through the framework's CLI or a custom script. This process executes the seed classes, inserting the predefined data into the database.

Best Practices:

• Idempotency: Make sure that running the seeding process multiple times does not create unwanted duplicates or errors. Achieve this by checking for existing data before seeding or by clearing relevant tables at the beginning of the seeding process.
• Use Realistic Data: Especially for development and testing, using data that mimics real user input can help uncover issues and better understand how the application behaves.
• Environment Awareness: Differentiate between the data needed for development, testing, and production. Sensitive data should not be used in development or testing databases.

\App\Models\User::factory(10)->create(); //\App\Models\User::factory()->create([ // 'name' => 'Test User', // 'email' => 'test@example.com', // ]); \App\Models\Post::factory(10)->create();

Model relations inside seeder

When working with database seeders in a Laravel application, it's often necessary to create not just standalone records, but also to establish relationships between them. This is crucial for reflecting the real-world connections between different entities in your application, such as users having posts, or orders being linked to customers. Here's how you can handle model relationships inside a database seeder in Laravel.

Creating Related Models

When seeding data, you typically start by creating instances of your root model. For related models, you can utilize Laravel's relationship methods to create and associate them seamlessly.

One-to-Many Relationship Example

Suppose you have two models,UserandPost, with a one-to-many relationship (a user can have many posts). Here's how you could seed this relationship:

//Model relations inside seeder $users = \App\Models\User::factory(10)->create(); \App\Models\Post::factory(10)->make()->each(function ($post) use ($users) { $post->user_id = $users->random()->id; $post->save(); });

Individual seeder classes

In Laravel, using individual seeder classes for each model can help organize your database seeds, making them more maintainable and readable, especially in larger applications. This approach allows you to separate the seeding logic for different parts of your application into distinct classes. Here's a guide on how to use individual seeder classes effectively.

Step 1: Creating Seeder Classes

To create a new seeder class, you can use the Artisan command provided by Laravel. For example, to create a seeder for theUsermodel, you would run:

php artisan make:seeder UsersTableSeeder php artisan make:seeder PostsTableSeeder

User seeder

create(); } }

Post Seeder

make()->each(function ($post) use ($users) { $post->user_id = $users->random()->id; $post->save(); }); } }

Linking Seeder Classes in DatabaseSeeder

TheDatabaseSeederclass is the root seeder class that's called when you run the database seed command. To use your individual seeder classes, you need to call them from therunmethod of theDatabaseSeederclass:

$this->call([ UsersTableSeeder::class, PostsTableSeeder::class, ]);

Making seeder interactive

Making a Laravel seeder interactive allows you to dynamically specify aspects of the seeding process at runtime, such as how many records to create. This approach can be particularly useful during development or when running seeders in different environments, providing flexibility without the need to modify the seeder code for each run. Here's how you can make a Laravel seeder interactive:

Step 1: Use the Command Line Interface (CLI)

Laravel seeders can interact with the user through the CLI by using theaskmethod available in the seeder class. This method is part of theIlluminate\Console\Commandclass, which seeders have access to via thecommandproperty.

Example: Interactive User Seeder

Let's create an interactive seeder that asks how many users to create.

command->ask('How many users do you want to create?', 10); // Create the specified number of users using the User factory \App\Models\User::factory((int)$count)->create(); $this->command->info("Successfully created {$count} users."); // \App\Models\User::factory(10)->create(); } }

refresh database before creating new seeders

if($this->command->confirm('Do you want to refresh the database?', true)) { $this->command->call('migrate:refresh'); $this->command->info('Database was refreshed.'); } $this->call([ UsersTableSeeder::class, PostsTableSeeder::class, ]);

check if users exist

count() == 0) { $this->command->info('Please create some users first.'); return; } \App\Models\Post::factory(10)->make()->each(function ($post) use ($users) { $post->user_id = $users->random()->id; $post->save(); }); } }

php artisan db:seed --class=PostsTableSeeder

Unit Testing

Creating a comprehensive tutorial on testing user and post functionality in a Laravel application involves several steps, including setting up the environment, writing tests for both models and their relationships, and ensuring that all functionalities work as expected. This tutorial will cover the basics of setting up Laravel for testing, creating unit tests for models, and feature tests for user interactions with posts.

Step 1: Setting Up the Testing Environment

First, ensure your Laravel application is set up for testing. Laravel uses PHPUnit for testing, configured out of the box. Check that thephpunit.xmlfile exists in your project root; this file configures your testing environment. You might want to configure your database for testing by setting theDB_CONNECTIONenvironment variable inphpunit.xmlto use a different database, like SQLite, for faster tests.

php artisan test

php artisan make:test HomeTest

get('/home'); $response->assertStatus(200); } public function test_home_page_contains_text(): void { $response = $this->get('/home'); $response->assertSeeText('Home pge'); } }

Step 2: Writing Unit Tests for Models

Before writing feature tests, it's a good practice to start with unit tests for your models to ensure your basic relationships and business logic are correct.

Testing User Model

Create a test file for the User model:

php artisan make:test UserTest --unit

Write tests intests/Unit/UserTest.phpto verify the User-Post relationship:

assertTrue(true); } /** @test */ public function user_can_have_posts() { $user = User::factory()->create(); $post = Post::factory()->create(['user_id' => $user->id]); // Use the load method to refresh the posts relationship $user->load('posts'); $this->assertTrue($user->posts->contains($post)); } }

This test checks that a user can have associated posts.

In the context of Laravel's testing utilities, theassertDatabaseHasandassertDatabaseMissingmethods are used to inspect the application's database and assert whether it contains or lacks certain data, respectively. These assertions are particularly useful for feature tests where you're testing the application's behavior as it interacts with the database. Here's a closer look at both methods:

assertDatabaseHas

TheassertDatabaseHasmethod asserts that data exists in the database. This method is helpful when you want to ensure that a database operation, such as creating or updating a record, was successful.

Example:

Suppose you have a test that creates a post. To verify that the post was successfully created and exists in thepoststable, you might useassertDatabaseHaslike this:

$this->assertDatabaseHas('posts', [ 'title' => 'Example Post Title', 'content' => 'The content of the example post.', ]);

assertDatabaseMissing

Conversely, theassertDatabaseMissingmethod asserts that specific data does not exist in the database. This method is useful for testing deletions or ensuring that a record was not created due to validation or authorization failures.

Example:

If you have a test that deletes a post, you can useassertDatabaseMissingto ensure that the post no longer exists in thepoststable:

$this->assertDatabaseMissing('posts', [ 'id' => $postId, ]);

Step 3: Writing Feature Tests for User Interactions with Posts

Feature tests simulate real user interactions with your application. Here, we'll write a test to ensure users can create and view posts.

Testing Post Creation and Viewing

Generate a test file for post interactions:

php artisan make:test PostTest

Write tests intests/Feature/PostTest.phpto simulate creating and viewing posts:

actingAs(User::factory()->create()); $postData = [ 'title' => 'Sample Post Title', 'content' => 'This is the content of the post.', ]; $this->post('/posts', $postData)->assertStatus(302); // Assuming redirection after creation $this->assertDatabaseHas('posts', $postData); } /** @test */ public function a_user_can_view_a_post() { $post = Post::factory()->create(); $this->get("/posts/{$post->id}") ->assertStatus(200) ->assertSee($post->title) ->assertSee($post->content); } }

// adjust our controller store post method : // method 1 $post = new Post(); $post->title = $request->input('title'); $post->content = $request->input('content'); $post->slug= Str::slug($post->title, '-'); $post->active = false; $post->user_id = auth()->id(); // or $request->user()->id; $post->save();

Running the Tests

To run your tests, use the PHPUnit command:

php artisan test

Testing update and Delete

public function a_user_can_update_a_post() { $user = User::factory()->create(); $this->actingAs($user); $post = Post::factory()->create(['user_id' => $user->id]); $updatedData = [ 'title' => 'Updated Post Title', 'content' => 'Updated content of the post.', ]; $response = $this->put("/posts/{$post->id}", $updatedData); $response->assertStatus(302); // Assuming a redirect occurs after update $this->assertDatabaseHas('posts', [ 'id' => $post->id, 'title' => 'Updated Post Title', 'content' => 'Updated content of the post.', ]); } // Delete public function a_user_can_view_a_post() { $user = User::factory()->create(); $this->actingAs($user); $post = Post::factory()->create(['user_id' => $user->id]); $response = $this->get("/posts/{$post->id}"); $response->assertStatus(200); $response->assertSee($post->title); $response->assertSee($post->content); }

Telescope

Laravel Telescope is an elegant debug assistant for Laravel applications. It provides insight into the requests coming into your application, exceptions, database queries, queued jobs, mail, notifications, cache operations, scheduled tasks, variable dumps, and more. Telescope is designed to make the development process easier by providing a convenient and powerful user interface to monitor your application's operations in real time.

Key Features of Laravel Telescope:

• Requests: Tracks incoming requests, including response times, payload, and status codes, helping you identify performance bottlenecks or problematic requests.
• Exceptions: Logs exceptions thrown within your application, providing stack traces and context to help with debugging.
• Database Queries: Shows all database queries executed during a request, including execution time and the ability to detect duplicate queries that could affect performance.
• Mail: Records all outgoing emails sent by the application, allowing you to inspect mail content, headers, and recipients.
• Notifications: Monitors notifications dispatched by your application, useful for debugging notification delivery issues.
• Jobs: Provides details on queued jobs, including their payload, status (pending, completed, failed), and execution time.
• Cache: Displays cache operations, making it easier to understand how your cache is being utilized and identify unnecessary cache hits or misses.
• Scheduled Tasks: Keeps track of scheduled tasks, showing when tasks are executed and how long they take, helping ensure your task scheduling is working as expected.
• Dumps: Telescope includes adumpwatcher, which captures data dumped using thedump()method, making it available in the Telescope interface instead of your application's output.
• Redis Commands: If your application uses Redis, Telescope can track Redis commands to give you insight into how Redis is being used.

Installation and Setup:

To install Telescope, you typically run the following Composer command in your Laravel project:

composer require laravel/telescope

After installation, publish its assets and run the migrations:

php artisan telescope:install php artisan migrate

Accessing Telescope:

Once installed, Telescope can be accessed via your web browser at the/telescopepath of your application (e.g.,http://127.0.0.1:8000/telescope). Access to Telescope can and should be restricted in production environments to prevent unauthorized access to sensitive application data.

Use Cases:

• Development: During development, Telescope can be used to debug and optimize your application by providing real-time insights into its operations.
• Staging: In a staging environment, Telescope helps in performing final checks before going live, ensuring that no unexpected issues or performance bottlenecks have been introduced.
• Production: While it's less common to have Telescope enabled in production due to performance considerations and the sensitivity of the data it exposes, it can be configured to only keep a limited set of data or to be accessible only by certain IP addresses or users.

Conclusion:

Laravel Telescope is an invaluable tool for Laravel developers, offering a rich set of features to improve application development, debugging, and performance optimization. Its user-friendly interface and comprehensive monitoring capabilities make it a must-have for serious Laravel projects.

Authentication

Step 1: Installing Laravel UI

First, you install the Laravel UI package using Composer:

composer require laravel/ui

This command adds the Laravel UI package to your project, allowing you to generate the basic scaffolding for authentication, as well as frontend presets for Vue.js, Bootstrap, or React.

Step 2: Generating the Auth Scaffolding

Once Laravel UI is installed, you can generate the authentication scaffolding. If you're interested in using Vue.js along with the authentication system, you can do so with the following command:

php artisan ui vue --auth

This command does two main things:

1. Vue.js Scaffolding: It sets up Vue.js in your Laravel application by generating example components and setting up webpack.mix.js for compiling your assets.
2. Authentication Scaffolding: It generates the necessary views, routes, and controllers for a basic authentication system. This includes login, registration, password reset, and email verification views, along with the routes and controllers needed to handle these functionalities.

Step 3: Compiling the Assets

After running theui vue --authcommand, you'll need to compile your assets (JavaScript and CSS) to reflect the changes in your application. You can do this with Laravel Mix by running:

npm install && npm run dev

php artisan migrate

now let adjust our redirect page after login and register in RouteServiceProvider :

public const HOME = '/home'; //to public const HOME = '/posts';

Retrieving the Currently Authenticated User

Laravel provides several methods through itsAuthfacade to access the currently authenticated user. Understanding these methods helps in managing user-specific data and enforcing access controls. Here are some examples:

1. Get the ID of the Authenticated User:
   

   $userId = Auth::id();

   Copy after login

   This method returns the identifier of the authenticated user without loading the user model. It's useful when you only need the user's ID for database queries or logging.

2. Retrieve the Authenticated User Instance:
   

   $user = Auth::user();

   Copy after login

   This method loads and returns the entire user model instance. It's helpful when you need more than just the user's ID, such as the user's name, email, or other attributes stored in the user table.

3. Accessing Specific Attributes of the Authenticated User:
   

   $userEmail = Auth::user()->email;

   Copy after login

   After retrieving the user model instance, you can access any of its attributes. This example demonstrates how to get the email of the authenticated user.

4. Check If a User is Authenticated:
   

   $isAuthenticated = Auth::check();

   Copy after login

   This method checks if the current visitor is authenticated. It returnstrueif the user is logged in andfalseotherwise. This is particularly useful for conditionally showing content or redirecting users.

Protecting Routes (Requiring Authentication)

Protecting routes is crucial to prevent unauthorized access to certain parts of your application. Laravel makes it straightforward to require authentication for specific routes using middleware.

Example of Protecting Routes:

use App\Http\Controllers\HomeController; use App\Http\Controllers\PostController; use Illuminate\Support\Facades\Route; use Illuminate\Support\Facades\Auth; // Public routes Route::get('/', function () { return view('welcome'); }); // Authentication Routes Auth::routes(); // Protected routes Route::middleware(['auth'])->group(function () { Route::get('/home', [HomeController::class, 'index'])->name('home'); Route::get('/about', [HomeController::class, 'about'])->name('about'); Route::resource('posts', PostController::class); });

Controller-based Middleware Protection:

use App\Http\Controllers\HomeController; use App\Http\Controllers\PostController; use Illuminate\Support\Facades\Route; use Illuminate\Support\Facades\Auth; // Public routes Route::get('/', function () { return view('welcome'); }); // Authentication Routes Auth::routes(); // Protected routes Route::middleware(['auth'])->group(function () { Route::get('/home', [HomeController::class, 'index'])->name('home'); Route::get('/about', [HomeController::class, 'about'])->name('about'); }); Route::resource('posts', PostController::class);

the constructor method of thePostControllerclass is using$this->middleware('auth')->only(['create', 'edit', 'update', 'destroy']);to specify that only authenticated users are allowed to access thecreate,edit,update, anddestroyactions. Here's a breakdown of what this does:

• $this->middleware('auth'): This applies theauthmiddleware, ensuring that only authenticated users can proceed.
• >only(['create', 'edit', 'update', 'destroy']): This limits the middleware application only to the specified methods. Other methods in this controller, such asindexorshow, would not require authentication, making them accessible to unauthenticated users.

public function __construct() { $this->middleware('auth')->only(['create', 'edit', 'update', 'destroy']); }

If you want to apply middleware to all controller actionsexceptfor a selected few, you can use theexceptmethod instead ofonly. This is useful when most of your controller's actions require middleware, but a few public actions should remain accessible without it.

Here's how you can modify your constructor to useexcept:

public function __construct() { $this->middleware('auth')->except(['index', 'show']); }

Soft Deletes & Hard Deletes

To implement Soft Deletes and Hard Deletes in Laravel models likeUserandPost, you first need to understand what each type of deletion entails and then see how to apply them to these models.

Soft Deletes

Soft deleting is a way to "delete" a model without actually removing it from the database. Instead, adeleted_attimestamp is set on the model. This approach lets you recover the "deleted" models later if needed.

How to Implement Soft Deletes:

Create a New Migration

First, you need to create a new migration file for the table you wish to add soft deletes to. If you're modifying an existing table, you'll still create a migration but structure it to alter the table rather than create a new one. Use the Artisan CLI to create this migration:

php artisan make:migration add_soft_deletes_to_posts_table --table=posts

Modify the Migration File

Open the newly created migration file in your editor. It will be named with a timestamp and the description you provided, something like2024_01_01_000000_add_soft_deletes_to_posts_table.php.

Modify theupmethod to add adeleted_atcolumn to the table. This column is used by Laravel to mark when a record was "deleted":

use Illuminate\Database\Migrations\Migration; use Illuminate\Database\Schema\Blueprint; use Illuminate\Support\Facades\Schema; class AddSoftDeletesToPostsTable extends Migration { public function up() { Schema::table('posts', function (Blueprint $table) { $table->softDeletes(); // Adds the deleted_at column }); } public function down() { Schema::table('posts', function (Blueprint $table) { $table->dropSoftDeletes(); // Removes the deleted_at column }); } }

Run the Migration

Apply the migration to your database to alter thepoststable by adding thedeleted_atcolumn:

php artisan migrate

Update Your Model

To enable soft deletes in your Eloquent model, you must use theIlluminate\Database\Eloquent\SoftDeletestrait in the model that corresponds to the table you've just modified. Open or create the model file inapp/Models/Post.phpand update it as follows:

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

$post = Post::find($postId); $post->delete();

To retrieve soft-deleted models, you can use thewithTrashed()method on your model query:

$posts = Post::withTrashed()->get();

This approach ensures that when aPostmodel is deleted, all of its associatedCommentmodels are also deleted, mimicking the behavior of a database-level ON DELETE CASCADE constraint.

// example without on cascade public static function boot(){ parent::boot(); static::deleting(function(Post $post){ $post->comments()->delete(); }); }

Hard Deletes

Hard deleting is the conventional way of deleting records from the database. Once a model is hard deleted, it's permanently removed from the database.

Implementing Hard Deletes:

Hard deletes don't require any special setup in Laravel; they are the default behavior when you call thedeletemethod on a model instance without using theSoftDeletestrait.

Example of Force Delete (Hard Delete):

$post = Post::withTrashed()->find($postId); $post->forceDelete();

implements new logic to our Posts Controller :

// Existing soft delete method public function destroy(Request $request, string $id) { $post = Post::findOrFail($id); $post->delete(); // Soft delete $request->session()->flash('status', 'Post was deleted!'); return redirect()->route('posts.index'); } // Add this method for hard (force) delete public function forceDestroy(Request $request, string $id) { $post = Post::withTrashed()->findOrFail($id); $post->forceDelete(); // Permanently deletes the post $request->session()->flash('status', 'Post was permanently deleted!'); return redirect()->route('posts.index'); }

index.blade.php

@extends('layouts.app') @section('content') 
list of Post
 
 @if(session()->has('status')) 
 {{session()->get('status')}} 
 @endif @forelse($posts as $post) 
 
{{$post->title}}
 Edit   
 @csrf @method('DELETE') Delete Post 
  
 @csrf @method('DELETE') Permanently Delete Post 
 
{{$post->content}}
 {{$post->created_at}} 
 @empty 
No blog post yet!
 @endforelse 
 @endsection

ADD NEW ROUTE :

Route::delete('/posts/{id}/force', [PostController::class, 'forceDestroy'])->name('posts.forceDestroy');

The above is the detailed content of Part Mastering Laravel From Fundamentals to Advanced Web Development. For more information, please follow other related articles on the PHP Chinese website!