Teilweise Beherrschung von Laravel von den Grundlagen bis zur fortgeschrittenen Webentwicklung

Mastering Laravel : From Fundamentals to Advanced Web Development

Eloquent Relationship: One To One

Creating a one-to-one relationship between an author and a profile in 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.

authors migration may look something like this:

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

profiles migration should include a foreign key referencing the authors table:

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 the author_id column in the profiles table 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_id in the profiles table will correspond to the id in the authors table.
2. >references('id'): This specifies which column in the foreign table (authors) the author_id column is related to. Here, it's saying that author_id references the id column of the authors table. This creates a direct link between the two tables, where each author_id in the profiles table points to an id in the authors table.
3. >on('authors'): This part specifies the name of the foreign table that the foreign key relates to. In this case, it's the authors table.
4. >onDelete('cascade'): This is a referential action related to the foreign key. When a record in the parent table (authors) is deleted, the onDelete('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 the profiles table will also be automatically deleted, preventing orphaned records.

Define Eloquent Models

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

In the Author model:

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

In the Profil model:

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

Using the Relationship

With the relationships defined, you can now easily access the profile of an author and

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 an post and a comment in 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

The comments migration should include a foreign key referencing the posts table:

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 the Post model, define a relationship to access its comments:

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

Comment Model

In the Comment model, 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 involving posts, 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 for Tag with a migration, and also create a pivot table migration for the many-to-many relationship between posts and tags.

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 for tags to 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 table post_tag to 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 the Post model, define a relationship to access its tags.

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

Tag Model

In the Tag model, 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 between posts and tags, 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 a Comment model 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 the find method. This is an example of lazy loading, where the associated Post model is not loaded at the same time as the Comment. The Post data 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 the with('post') method to eagerly load the related Post model at the same time as the Comment. This means when the comment with ID 2 is fetched, the related Post is 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 command php artisan make:factory [FactoryName] --model=[ModelName] to create a new factory.
• Location: Factories are typically stored in the database/factories directory.
• 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 the state method 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

<?php

namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;

/**
 * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Post>
 */
class PostFactory extends Factory
{
    /**
     * Define the model's default state.
     *
     * @return array<string, mixed>
     */
    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 named user_id that is intended to store unsigned big integers (BigInteger equivalent). This is commonly used for foreign keys that reference an id field in another table. The foreignId method is a shorthand in Laravel for creating such an integer column specifically designed to link to the id of another table, assuming that id is an unsigned big integer.
• >constrained(): This method adds a foreign key constraint to the user_id column, linking it to the id column of another table. By default, without specifying a table name as a parameter to constrained(), Laravel assumes that the foreign key references the id column of a table whose name is the singular form of the column name before _id, following Laravel's naming conventions. In this case, user_id implies a reference to the id column of the users table.

This line effectively does two things:

1. Creates a user_id column meant to hold references to the id of the users table.
2. Establishes a foreign key constraint that enforces the integrity of this relationship, ensuring that each value in the user_id column corresponds to an existing id in the users table.

---

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, User and Post, 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 the User model, you would run:

php artisan make:seeder UsersTableSeeder

php artisan make:seeder PostsTableSeeder

User seeder

<?php

namespace Database\Seeders;

use Illuminate\Database\Console\Seeds\WithoutModelEvents;
use Illuminate\Database\Seeder;

class UsersTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     */
    public function run(): void
    {

         \App\Models\User::factory(10)->create();
    }
}

Post Seeder

<?php

namespace Database\Seeders;

use Illuminate\Database\Console\Seeds\WithoutModelEvents;
use Illuminate\Database\Seeder;

class PostsTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     */
    public function run(): void
    {
        //

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

        \App\Models\Post::factory(10)->make()->each(function ($post) use ($users) {
            $post->user_id = $users->random()->id;
            $post->save();
        });
    }
}

Linking Seeder Classes in DatabaseSeeder

The DatabaseSeeder class 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 the run method of the DatabaseSeeder class:

$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 the ask method available in the seeder class. This method is part of the Illuminate\Console\Command class, which seeders have access to via the command property.

Example: Interactive User Seeder

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

<?php

namespace Database\Seeders;

use Illuminate\Database\Console\Seeds\WithoutModelEvents;
use Illuminate\Database\Seeder;

class UsersTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     */
    public function run(): void
    {

        $count = $this->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

<?php

namespace Database\Seeders;

use Illuminate\Database\Console\Seeds\WithoutModelEvents;
use Illuminate\Database\Seeder;

class PostsTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     */
    public function run(): void
    {
        //

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

        if($users->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 the phpunit.xml file exists in your project root; this file configures your testing environment. You might want to configure your database for testing by setting the DB_CONNECTION environment variable in phpunit.xml to use a different database, like SQLite, for faster tests.

<!-- phpunit.xml -->
<env name="DB_CONNECTION" value="sqlite"/>
<env name="DB_DATABASE" value=":memory:"/>

php artisan test

php artisan make:test HomeTest

<?php

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithFaker;
use Tests\TestCase;

class HomeTest extends TestCase
{
    /**
     * A basic feature test example.
     */
    public function test_example(): void
    {
        $response = $this->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 in tests/Unit/UserTest.php to verify the User-Post relationship:

<?php

namespace Tests\Unit;

use App\Models\User;
use App\Models\Post;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class UserTest extends TestCase
{
    use RefreshDatabase;

  /**
     * A basic unit test example.
     */
    public function test_example(): void
    {
        $this->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, the assertDatabaseHas and assertDatabaseMissing methods 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

The assertDatabaseHas method 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 the posts table, you might use assertDatabaseHas like this:

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

assertDatabaseMissing

Conversely, the assertDatabaseMissing method 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 use assertDatabaseMissing to ensure that the post no longer exists in the posts table:

$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 in tests/Feature/PostTest.php to simulate creating and viewing posts:

<?php

namespace Tests\Feature;

use App\Models\User;
use App\Models\Post;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class PostTest extends TestCase
{
    use RefreshDatabase;

    /** @test */
    public function a_user_can_create_a_post()
    {
        $this->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 a dump watcher, which captures data dumped using the dump() 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 /telescope path 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 the ui vue --auth command, 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 its Auth facade 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();
   
   

   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();
   
   

   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;
   
   

   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();
   
   

   This method checks if the current visitor is authenticated. It returns true if the user is logged in and false otherwise. 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 the PostController class is using $this->middleware('auth')->only(['create', 'edit', 'update', 'destroy']); to specify that only authenticated users are allowed to access the create, edit, update, and destroy actions. Here's a breakdown of what this does:

• $this->middleware('auth'): This applies the auth middleware, 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 as index or show, 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 actions except for a selected few, you can use the except method instead of only. 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 use except:

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

---

Soft Deletes & Hard Deletes

To implement Soft Deletes and Hard Deletes in Laravel models like User and Post, 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, a deleted_at timestamp 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 like 2024_01_01_000000_add_soft_deletes_to_posts_table.php.

Modify the up method to add a deleted_at column 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 the posts table by adding the deleted_at column:

php artisan migrate

Update Your Model

To enable soft deletes in your Eloquent model, you must use the Illuminate\Database\Eloquent\SoftDeletes trait in the model that corresponds to the table you've just modified. Open or create the model file in app/Models/Post.php and update it as follows:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use HasFactory,SoftDeletes;

    protected $fillable = ['title', 'content', 'slug','user_id', 'active'];

    public function user()
    {
        return $this->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 the withTrashed() method on your model query:

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

This approach ensures that when a Post model is deleted, all of its associated Comment models 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 the delete method on a model instance without using the SoftDeletes trait.

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')
    <h1>list of Post</h1>
    <ul>

        @if(session()->has('status'))
        <p style="color: green">
            {{session()->get('status')}}
        </p>
        @endif

        @forelse($posts as $post)
        <li>
<h2><a href="{{route('posts.show',['post'=>$post->id])}}">{{$post->title}}</a></h2>
<b><a href="{{route('posts.edit',['post'=>$post->id])}}">Edit</a> </b>


   <!-- Soft Delete Form -->
   <form action="{{ route('posts.destroy', ['post' => $post->id]) }}" method="POST" style="display: inline;">
    @csrf
    @method('DELETE')
    <button type="submit">Delete Post</button>
</form>

<!-- Hard Delete Form -->
<form action="{{ route('posts.forceDestroy', ['id' => $post->id]) }}" method="POST" style="display: inline;">
    @csrf
    @method('DELETE')
    <button type="submit">Permanently Delete Post</button>
</form>
<p>{{$post->content}}</p>
<em>{{$post->created_at}}</em>
        </li>
        @empty
        <p>No blog post yet!</p>
        @endforelse

    </ul>
@endsection

ADD NEW ROUTE :

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

Das obige ist der detaillierte Inhalt vonTeilweise Beherrschung von Laravel von den Grundlagen bis zur fortgeschrittenen Webentwicklung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!