Soft Deletes

06.09.2024

Author:	ADMIN

Trong bài viết này, chúng ta sẽ tìm hiểu về một tính năng rất hữu ích trong Laravel - Soft Deletes

Trong Laravel, "Soft Deletes" là một tính năng giúp bạn có thể xóa bản ghi mà không thực sự xóa nó khỏi cơ sở dữ liệu. Thay vào đó, bản ghi sẽ được đánh dấu là đã bị xóa bằng cách thiết lập một trường deleted_at với thời gian xóa. Bản ghi vẫn tồn tại trong cơ sở dữ liệu nhưng sẽ không được hiển thị trong các truy vấn mặc định.

Cách sử dụng Soft Deletes trong Laravel

Thêm Soft Deletes vào Model: Đầu tiên, bạn cần thêm SoftDeletes trait vào model của mình.

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

class Post extends Model
{
    use SoftDeletes;

    // Các thuộc tính khác của model

    protected $dates = ['deleted_at'];
}

Thêm cột deleted_at vào bảng: Bạn cần phải thêm một cột deleted_at vào bảng tương ứng với model của bạn để lưu trữ thời gian xóa. Bạn có thể làm điều này bằng cách tạo một migration:
```
php artisan make:migration add_deleted_at_to_posts_table --table=posts
```
Trong file migration:
```
Schema::table('posts', function (Blueprint $table) {
    $table->softDeletes(); // Thêm cột deleted_at
});
```
Sau đó, chạy lệnh migrate:
```
php artisan migrate
```
Sử dụng Soft Deletes trong truy vấn:
- Để xóa mềm một bản ghi, sử dụng phương thức delete():
```
$post = Post::find(1);
$post->delete();
```
- Để khôi phục một bản ghi đã xóa mềm, sử dụng phương thức restore():
```
$post = Post::withTrashed()->find(1);
$post->restore();
```
- Để xóa cứng (xóa vĩnh viễn) một bản ghi đã xóa mềm, sử dụng phương thức forceDelete():
```
$post->forceDelete();
```
- Để lấy tất cả các bản ghi, bao gồm cả những bản ghi đã bị xóa mềm, sử dụng phương thức withTrashed():
```
$posts = Post::withTrashed()->get();
```
- Để chỉ lấy các bản ghi đã bị xóa mềm, sử dụng phương thức onlyTrashed():
```
$trashedPosts = Post::onlyTrashed()->get();
```

Lợi ích của Soft Deletes

Khôi phục dữ liệu: Cho phép bạn khôi phục lại các bản ghi đã bị xóa.
An toàn: Tránh xóa nhầm dữ liệu, đặc biệt là khi cần duyệt lại hoặc kiểm toán dữ liệu đã bị xóa.

Chi tiết

Eloquent Collections

04.09.2024

Author:	ADMIN

Eloquent Collections trong Laravel là một tính năng mạnh mẽ cho phép bạn làm việc với tập hợp các model được truy vấn từ cơ sở dữ liệu. Mỗi khi bạn thực hiện một truy vấn Eloquent, kết quả trả về thường là một đối tượng của Illuminate\Database\Eloquent\Collection. Các Eloquent Collection mở rộng từ Laravel Collection, cung cấp các phương thức hữu ích để thao tác và xử lý dữ liệu một cách dễ dàng.

1. Tổng quan về Eloquent Collections

Khi bạn truy xuất nhiều bản ghi từ cơ sở dữ liệu bằng Eloquent, Laravel sẽ trả về một Collection chứa các model. Ví dụ:

$users = User::all();

Biến $users ở đây sẽ là một instance của Illuminate\Database\Eloquent\Collection, chứa tất cả các đối tượng User trong cơ sở dữ liệu.

Eloquent Collections cung cấp các phương thức mạnh mẽ cho phép bạn duyệt qua, lọc, sắp xếp, và biến đổi các tập hợp model mà không cần phải viết mã phức tạp.

2. Phương thức phổ biến trong Eloquent Collections

append

Phương thức append cho phép bạn thêm các thuộc tính ảo vào một collection. Các thuộc tính này không có trong cơ sở dữ liệu nhưng được định nghĩa trong model thông qua Accessors.

Ví dụ:
```
$users = User::all()->append('full_name');
```
Ở đây, full_name là một accessor được định nghĩa trong model User. Thuộc tính này sẽ được thêm vào mỗi model trong collection.
contains

Phương thức contains kiểm tra xem collection có chứa một phần tử cụ thể không. Bạn có thể kiểm tra bằng cách so sánh giá trị thuộc tính hoặc kiểm tra đối tượng model.

Ví dụ:
```
$containsUser = $users->contains('id', 1);
$containsUser = $users->contains($someUser);
```
Phương thức này trả về true nếu collection chứa phần tử, ngược lại trả về false.
diff

Phương thức diff so sánh hai collection và trả về phần tử có trong collection hiện tại nhưng không có trong collection so sánh.

Ví dụ:
```
$users1 = User::where('status', 'active')->get();
$users2 = User::where('status', 'inactive')->get();
$diff = $users1->diff($users2);
```
Kết quả là các phần tử có trong $users1 nhưng không có trong $users2.
except

Phương thức except tạo một collection mới bằng cách loại bỏ các phần tử có khóa hoặc chỉ số cụ thể.

Ví dụ:
```
$users = User::all();
$usersExceptFirst = $users->except([0]);
```
Kết quả là một collection mới không chứa phần tử tại chỉ số 0.
find

Phương thức find tìm kiếm phần tử trong collection dựa trên giá trị của khóa chính.

Ví dụ:
```
$user = $users->find(1);
```
Phương thức này trả về model có ID là 1, hoặc null nếu không tìm thấy.
6. fresh

Phương thức fresh tải lại model từ cơ sở dữ liệu, cập nhật các thuộc tính của model với giá trị mới nhất.

Ví dụ:
```
$user = User::find(1);
$user->name = 'New Name';
$user->fresh();
```
Sau khi gọi fresh(), các thuộc tính của model sẽ được làm mới từ cơ sở dữ liệu.
intersect

Phương thức intersect trả về phần giao nhau của hai collection.

Ví dụ:
```
$users1 = User::where('status', 'active')->get();
$users2 = User::where('status', 'inactive')->get();
$intersect = $users1->intersect($users2);
```
Kết quả là các phần tử có trong cả $users1 và $users2.
load

Phương thức load eager load các quan hệ cho collection của các model.

Ví dụ:
```
$users = User::all()->load('posts');
```
Phương thức này sẽ tải trước quan hệ posts cho tất cả người dùng trong collection.
loadMissing

Phương thức loadMissing tương tự như load, nhưng chỉ tải các quan hệ còn thiếu, không tải lại các quan hệ đã được tải trước đó.

Ví dụ:
```
$users = User::with('posts')->get();
$users->loadMissing('comments');
```
comments chỉ được tải nếu chưa được tải từ trước đó.
modelKeys

Phương thức modelKeys trả về một collection chứa các khóa chính của các model trong collection.

Ví dụ:
```
$keys = $users->modelKeys();
```
Kết quả là một mảng các ID của các người dùng trong collection.
makeVisible

Phương thức makeVisible thêm các thuộc tính ẩn vào collection, làm cho chúng có thể truy cập được.

Ví dụ:
```
$users = User::all()->makeVisible(['secret_field']);
```
secret_field sẽ được thêm vào thuộc tính của model trong collection.
makeHidden

Phương thức makeHidden ẩn các thuộc tính khỏi collection.

Ví dụ:
```
$users = User::all()->makeHidden(['secret_field']);
```
secret_field sẽ bị ẩn và không còn có thể truy cập được.
only

Phương thức only tạo một collection mới chỉ với các phần tử có khóa cụ thể.

Ví dụ:
```
$users = User::all()->only(['id', 'name']);
```
Kết quả là một collection mới chỉ chứa các trường id và name.
setVisible

Phương thức setVisible thiết lập các thuộc tính của model mà bạn muốn hiển thị trong collection.

Ví dụ:
```
$users = User::all()->setVisible(['name', 'email']);
```
Chỉ các thuộc tính name và email sẽ được hiển thị trong collection.
setHidden

Phương thức setHidden thiết lập các thuộc tính của model mà bạn muốn ẩn trong collection.

Ví dụ:
```
$users = User::all()->setHidden(['password']);
```
Thuộc tính password sẽ bị ẩn và không được hiển thị.
toQuery

Phương thức toQuery trả về một query builder cho collection.

Ví dụ:
```
$query = User::all()->toQuery();
```
$query là một instance của Illuminate\Database\Eloquent\Builder và có thể tiếp tục được sử dụng để thực hiện các truy vấn.
unique

Phương thức unique loại bỏ các phần tử trùng lặp trong collection dựa trên một thuộc tính hoặc một hàm callback.

Ví dụ:
```
$uniqueUsers = $users->unique('email');
```
Kết quả là một collection mới chỉ chứa các người dùng có email duy nhất.

Ngoài ra, bạn có thể tham khảo thêm các method khác tại đây

Chi tiết

Eloquent Accessors and Mutators

30.08.2024

Author:	ADMIN

Eloquent Accessors và Mutators là các phương thức trong Eloquent của Laravel cho phép bạn điều chỉnh cách dữ liệu được lấy ra hoặc lưu vào cơ sở dữ liệu. Đây là một tính năng mạnh mẽ giúp bạn dễ dàng thao tác và định dạng dữ liệu mà không cần thay đổi logic truy vấn.

1. Accessors (Bộ lấy dữ liệu)

Accessors cho phép bạn thay đổi giá trị của một thuộc tính trước khi trả về nó cho ứng dụng. Điều này giúp bạn có thể định dạng dữ liệu theo cách mong muốn mỗi khi truy vấn model.

Cách sử dụng:

Bạn định nghĩa một accessor bằng cách tạo một phương thức trong model với tên theo cú pháp get{Attribute}Attribute, trong đó {Attribute} là tên của thuộc tính bạn muốn định dạng.

Ví dụ:

Giả sử bạn có một model User với thuộc tính first_name và last_name. Bạn muốn kết hợp chúng thành một thuộc tính full_name khi lấy dữ liệu từ model:

class User extends Model
{
    public function getFullNameAttribute()
    {
        return "{$this->first_name} {$this->last_name}";
    }
}

Bây giờ, bạn có thể truy cập thuộc tính full_name như thể nó là một cột trong bảng:

$user = User::find(1);
echo $user->full_name; // John Doe

Laravel sẽ tự động gọi phương thức getFullNameAttribute() mỗi khi bạn truy cập vào thuộc tính full_name.

2. Mutators (Bộ chỉnh sửa dữ liệu)

Mutators cho phép bạn thay đổi giá trị của một thuộc tính trước khi lưu nó vào cơ sở dữ liệu. Điều này rất hữu ích khi bạn muốn đảm bảo dữ liệu luôn được lưu theo định dạng nhất định.

Cách sử dụng:

Bạn định nghĩa một mutator bằng cách tạo một phương thức trong model với tên theo cú pháp set{Attribute}Attribute, trong đó {Attribute} là tên của thuộc tính bạn muốn thay đổi.

Ví dụ:

Giả sử bạn muốn đảm bảo rằng tất cả các tên người dùng (username) được lưu vào cơ sở dữ liệu đều ở dạng chữ thường:

class User extends Model
{
    public function setUsernameAttribute($value)
    {
        $this->attributes['username'] = strtolower($value);
    }
}

Khi bạn gán giá trị cho thuộc tính username, Laravel sẽ tự động gọi phương thức setUsernameAttribute():

$user = new User;
$user->username = 'JohnDoe';
$user->save();

// username được lưu dưới dạng 'johndoe'

3. Tùy chỉnh thuộc tính với Accessors và Mutators

Bạn có thể sử dụng cả Accessors và Mutators để tạo ra các thuộc tính tuỳ chỉnh không tồn tại trong cơ sở dữ liệu. Đây là cách bạn có thể thao tác với dữ liệu mà không ảnh hưởng đến các cột thực tế trong bảng.

Ví dụ:

Giả sử bạn có một cột birthdate lưu trữ ngày sinh của người dùng. Bạn muốn tạo một thuộc tính age để tính toán tuổi từ ngày sinh:

class User extends Model
{
    public function getAgeAttribute()
    {
        return \Carbon\Carbon::parse($this->birthdate)->age;
    }
}

Bây giờ, bạn có thể truy cập thuộc tính age một cách dễ dàng:

$user = User::find(1);
echo $user->age; // 30

4. Lợi ích của Accessors và Mutators

Tăng tính dễ đọc của mã nguồn: Accessors và Mutators giúp mã của bạn trở nên dễ đọc hơn bằng cách đóng gói logic xử lý dữ liệu vào trong model.
Đảm bảo tính nhất quán của dữ liệu: Bằng cách sử dụng Mutators, bạn có thể đảm bảo rằng dữ liệu luôn được lưu vào cơ sở dữ liệu theo một định dạng chuẩn xác.
Tính linh hoạt: Accessors cho phép bạn định dạng dữ liệu theo nhu cầu mà không cần phải thay đổi cấu trúc cơ sở dữ liệu.

5. Các trường hợp sử dụng phổ biến

Accessors thường được sử dụng để định dạng dữ liệu khi truy xuất, ví dụ như định dạng ngày tháng, kết hợp nhiều cột thành một, hoặc chuyển đổi mã sang định dạng hiển thị.
Mutators thường được sử dụng để xử lý dữ liệu trước khi lưu vào cơ sở dữ liệu, ví dụ như chuyển văn bản sang chữ thường, mã hóa mật khẩu, hoặc định dạng số điện thoại.

Kết luận

Eloquent Accessors và Mutators là công cụ mạnh mẽ trong Laravel giúp bạn quản lý và thao tác dữ liệu một cách dễ dàng và linh hoạt. Bằng cách sử dụng các phương thức này, bạn có thể đảm bảo rằng dữ liệu được định dạng và lưu trữ một cách nhất quán, đồng thời giữ cho mã nguồn của bạn trở nên dễ đọc và dễ bảo trì hơn.

Chi tiết

Polymorphic Relationships

30.08.2024

Author:	ADMIN

Polymorphic Relationships là một tính năng mạnh mẽ trong Eloquent của Laravel cho phép một model có thể liên kết với nhiều model khác nhau bằng cách sử dụng một bảng quan hệ duy nhất. Đây là mối quan hệ đặc biệt thường được sử dụng khi một thực thể có thể thuộc về nhiều loại thực thể khác nhau.

1. One-to-One Polymorphic Relationships

One-to-One Polymorphic Relationships cho phép một model có thể liên kết với một model khác trong mối quan hệ một-một, nhưng với khả năng liên kết với nhiều loại model khác nhau. Ví dụ, bạn có thể có một bảng image chứa các hình ảnh cho cả người dùng (users) và bài viết (posts). Một hình ảnh có thể thuộc về một bài viết hoặc một người dùng.

Ví dụ:

Cấu trúc cơ sở dữ liệu:

Đầu tiên, bạn cần tạo các bảng users, posts, và images. Bảng images sẽ chứa hai cột đặc biệt là imageable_id và imageable_type để xác định model mà hình ảnh thuộc về.

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

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

Schema::create('images', function (Blueprint $table) {
    $table->id();
    $table->string('url');
    $table->morphs('imageable');
    $table->timestamps();
});

Ở đây, morphs('imageable') sẽ tạo hai cột imageable_id và imageable_type.

Định nghĩa quan hệ trong model:

Trong model Image, bạn sẽ định nghĩa phương thức imageable để chỉ ra rằng hình ảnh này có thể thuộc về nhiều loại model khác nhau:
```
class Image extends Model
{
    public function imageable()
    {
        return $this->morphTo();
    }
}
```

Trong model User và Post, bạn sẽ định nghĩa một phương thức image để chỉ ra rằng người dùng và bài viết có thể có một hình ảnh:

class User extends Model
{
    public function image()
    {
        return $this->morphOne(Image::class, 'imageable');
    }
}

class Post extends Model
{
    public function image()
    {
        return $this->morphOne(Image::class, 'imageable');
    }
}

Sử dụng One-to-One Polymorphic Relationship:

Bạn có thể thêm và lấy hình ảnh cho người dùng và bài viết như sau:

$user = User::find(1);
$image = new Image(['url' => 'user_image.jpg']);
$user->image()->save($image);

$post = Post::find(1);
$image = new Image(['url' => 'post_image.jpg']);
$post->image()->save($image);

Để lấy hình ảnh của một người dùng hoặc bài viết:

$userImage = $user->image;
$postImage = $post->image;

2. One-to-Many Polymorphic Relationships

One-to-Many Polymorphic Relationships cho phép một model có thể liên kết với nhiều model khác nhau. Ví dụ điển hình là một bảng comments có thể chứa các bình luận cho cả bài viết (posts) và video (videos). Cả hai model Post và Video có thể chia sẻ cùng một bảng comments.

Ví dụ:

Cấu trúc cơ sở dữ liệu:

Bạn cần có các bảng posts, videos, và comments. Bảng comments sẽ chứa hai cột đặc biệt là commentable_id và commentable_type để theo dõi ID và loại model mà nó liên kết.

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

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

Schema::create('comments', function (Blueprint $table) {
    $table->id();
    $table->text('body');
    $table->morphs('commentable');
    $table->timestamps();
});

Ở đây, morphs('commentable') là một shortcut để tạo hai cột commentable_id và commentable_type.

Định nghĩa quan hệ trong model:

Trong model Comment, bạn sẽ định nghĩa một phương thức commentable để chỉ ra rằng comment này có thể thuộc về nhiều model khác nhau:
```
class Comment extends Model
{
    public function commentable()
    {
        return $this->morphTo();
    }
}
```

Trong model Post và Video, bạn sẽ định nghĩa một phương thức comments để chỉ ra rằng các bài viết và video có thể có nhiều comment:

class Post extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

class Video extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Sử dụng Polymorphic Relationship:

Bạn có thể thêm và lấy các bình luận cho các bài viết và video như sau:

$post = Post::find(1);
$comment = new Comment(['body' => 'Great post!']);
$post->comments()->save($comment);

$video = Video::find(1);
$comment = new Comment(['body' => 'Nice video!']);
$video->comments()->save($comment);

Để lấy tất cả các bình luận cho một bài viết hoặc video:

$postComments = $post->comments;
$videoComments = $video->comments;

3. Many-to-Many Polymorphic Relationships

Many-to-Many Polymorphic Relationships cho phép một model có thể có mối quan hệ nhiều-nhiều với nhiều model khác nhau. Ví dụ, một bảng tags có thể được liên kết với cả posts và videos.

Ví dụ:

Cấu trúc cơ sở dữ liệu:

Bạn cần có các bảng posts, videos, tags, và taggables. Bảng taggables sẽ chứa hai cột taggable_id và taggable_type để xác định loại thực thể mà nó liên kết (bài viết hoặc video).

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

Schema::create('taggables', function (Blueprint $table) {
    $table->morphs('taggable');
    $table->foreignId('tag_id')->constrained();
    $table->timestamps();
});

Định nghĩa quan hệ trong model:

Trong model Tag, bạn sẽ định nghĩa phương thức taggables để chỉ ra rằng tag này có thể thuộc về nhiều loại model khác nhau:
```
class Tag extends Model
{
    public function taggables()
    {
        return $this->morphedByMany(Post::class, 'taggable');
    }
}
```

Trong model Post và Video, bạn sẽ định nghĩa một phương thức tags để chỉ ra rằng bài viết và video có thể có nhiều tag:

class Post extends Model
{
    public function tags()
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}

class Video extends Model
{
    public function tags()
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}

Sử dụng Many-to-Many Polymorphic Relationship:

Bạn có thể thêm và lấy các tag cho bài viết và video như sau:
```
$post = Post::find(1);
$tag = Tag::find(1);
$post->tags()->attach($tag);

$video = Video::find(1);
$video->tags()->attach($tag);
```
Để lấy tất cả các tag cho một bài viết hoặc video:
```
$postTags = $post->tags;
$videoTags = $video->tags;
```

4. Lợi ích của Polymorphic Relationships

Tính linh hoạt: Bạn có thể thiết kế cơ sở dữ liệu linh hoạt hơn, cho phép các thực thể khác nhau có thể chia sẻ cùng một bảng quan hệ.
Tái sử dụng: Polymorphic Relationships giúp tránh lặp lại các bảng quan hệ không cần thiết, giảm phức tạp của cơ sở dữ liệu.
Tiết kiệm thời gian: Bạn có thể quản lý nhiều loại dữ liệu mà không cần phải tạo ra quá nhiều bảng phụ thuộc, giúp tiết kiệm thời gian trong quá trình phát triển và bảo trì.

Kết luận

Polymorphic Relationships trong Laravel là một công cụ cực kỳ mạnh mẽ và linh hoạt giúp bạn quản lý các mối quan hệ phức tạp trong cơ sở dữ liệu. Việc hiểu rõ và tận dụng tính năng này sẽ giúp bạn tối ưu hóa cấu trúc dữ liệu và mã nguồn của mình, đồng thời làm cho quá trình phát triển ứng dụng trở nên dễ dàng hơn.

Chi tiết

Eloquent Query Scopes

30.08.2024

Author:	ADMIN

Eloquent Query Scopes là một tính năng mạnh mẽ trong Laravel, giúp bạn tái sử dụng các đoạn mã truy vấn một cách dễ dàng. Bằng cách định nghĩa các scope, bạn có thể gom nhóm các truy vấn phức tạp thành các phương thức có thể tái sử dụng trên nhiều nơi trong ứng dụng.

Tổng quan

1. Local Scopes (Phạm vi cục bộ)

Local scopes cho phép bạn định nghĩa một truy vấn cụ thể ngay trong model và có thể được gọi trực tiếp từ các truy vấn Eloquent. Một scope cục bộ được định nghĩa bằng cách tạo một phương thức trong model và bắt đầu tên phương thức bằng từ khoá scope.

Ví dụ:

Giả sử bạn có một model User và bạn muốn tạo một scope để lấy tất cả các người dùng đã kích hoạt:

class User extends Model
{
    public function scopeActive($query)
    {
        return $query->where('active', 1);
    }
}

Bạn có thể sử dụng scope này trong các truy vấn của mình như sau:

$activeUsers = User::active()->get();

Phương thức scopeActive sẽ được gọi một cách tự động khi bạn sử dụng active() trong truy vấn. Scope này giúp mã trở nên ngắn gọn, dễ đọc và có thể tái sử dụng nhiều lần.

2. Dynamic Scopes (Phạm vi động)

Dynamic scopes cho phép bạn truyền tham số vào các phương thức scope để tuỳ chỉnh truy vấn dựa trên tham số đó.

Ví dụ:

Nếu bạn muốn tạo một scope để lấy người dùng dựa trên độ tuổi:

class User extends Model
{
    public function scopeOfAge($query, $age)
    {
        return $query->where('age', $age);
    }
}

Bạn có thể sử dụng scope này như sau:

$users = User::ofAge(25)->get();

Scope ofAge sẽ nhận một tham số $age và trả về danh sách người dùng có độ tuổi tương ứng.

3. Global Scopes (Phạm vi toàn cục)

Global scopes được áp dụng tự động trên mọi truy vấn của một model. Chúng thường được sử dụng khi bạn muốn áp dụng một điều kiện chung cho tất cả các truy vấn liên quan đến model đó. Để tạo một global scope, bạn cần định nghĩa một class riêng biệt và implement interface Scope.

Ví dụ:

Giả sử bạn muốn áp dụng một scope để chỉ lấy những người dùng đã kích hoạt trong tất cả các truy vấn liên quan đến model User:

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Scope;

class ActiveScope implements Scope
{
    public function apply(Builder $builder, Model $model)
    {
        return $builder->where('active', 1);
    }
}

Sau đó, bạn thêm scope này vào trong model User:

class User extends Model
{
    protected static function booted()
    {
        static::addGlobalScope(new ActiveScope);
    }
}

Bây giờ, mọi truy vấn liên quan đến model User sẽ tự động thêm điều kiện where('active', 1).

4. Xoá Global Scopes

Nếu bạn muốn loại bỏ một global scope khỏi một truy vấn cụ thể, bạn có thể sử dụng phương thức withoutGlobalScope.

Ví dụ:

$users = User::withoutGlobalScope(ActiveScope::class)->get();

Lệnh này sẽ loại bỏ scope ActiveScope và trả về tất cả người dùng, kể cả những người dùng chưa kích hoạt.

Lợi ích của Eloquent Query Scopes

Tái sử dụng: Các scope giúp bạn tránh lặp lại mã bằng cách gom nhóm các điều kiện truy vấn chung vào một nơi có thể tái sử dụng.
Tăng tính rõ ràng: Sử dụng scopes giúp mã nguồn dễ đọc hơn và rõ ràng hơn, đặc biệt là khi truy vấn phức tạp.
Dễ bảo trì: Khi cần thay đổi một điều kiện truy vấn, bạn chỉ cần thay đổi trong scope và tất cả các truy vấn khác sẽ tự động cập nhật theo.

Kết luận

Eloquent Query Scopes là một công cụ tuyệt vời giúp bạn tối ưu hoá và tổ chức mã nguồn của mình. Bằng cách sử dụng Local Scopes, Dynamic Scopes và Global Scopes, bạn có thể dễ dàng tái sử dụng các truy vấn phức tạp và giữ cho mã nguồn của mình ngắn gọn, dễ bảo trì.

Chi tiết

Eloquent: Factories (P2)

01.08.2024

Author:	ADMIN

Ở bài trước, chúng ta đã nắm sơ bộ về Eloquent Factories rồi, tiếp theo, chúng ta cùng tìm hiểu tiếp các Relationships trong Factories nhé.

# Many to Many Relationships

Laravel cung cấp nhiều cách để xây dựng và quản lý các mối quan hệ giữa các mô hình bằng cách sử dụng factories. Dưới đây là hướng dẫn chi tiết về các loại mối quan hệ khác nhau và cách sử dụng factories để tạo chúng.

1. Quan Hệ Many-to-Many

Khi hai mô hình có mối quan hệ nhiều-mối quan hệ, bạn có thể sử dụng phương thức hasAttached của factory để liên kết chúng qua bảng pivot.

Tạo Mô Hình Với Mối Quan Hệ Many-to-Many

Giả sử bạn có mô hình User và Role, và bạn muốn tạo một người dùng với ba vai trò:

use App\Models\Role;
use App\Models\User;
 
$user = User::factory()
            ->hasAttached(
                Role::factory()->count(3),
                ['active' => true]  // Thuộc tính trên bảng pivot
            )
            ->create();

Sử Dụng Closure Để Thay Đổi Trạng Thái

Nếu trạng thái cần truy cập mô hình liên quan, bạn có thể sử dụng closure:

$user = User::factory()
            ->hasAttached(
                Role::factory()
                    ->count(3)
                    ->state(function (array $attributes, User $user) {
                        return ['name' => $user->name.' Role'];
                    }),
                ['active' => true]
            )
            ->create();

Sử Dụng Các Mô Hình Hiện Có

Nếu bạn đã có các mô hình để liên kết, bạn có thể truyền chúng vào phương thức hasAttached:

$roles = Role::factory()->count(3)->create();
 
$user = User::factory()
            ->count(3)
            ->hasAttached($roles, ['active' => true])
            ->create();

Sử Dụng Các Phương Thức "Magic"

Để tiện lợi, bạn có thể sử dụng phương thức "ma thuật" để tạo quan hệ nhiều-mối quan hệ:

$user = User::factory()
            ->hasRoles(1, [
                'name' => 'Editor'
            ])
            ->create();

# Quan Hệ "Đa Hình" (Polymorphic Relationships)

Các quan hệ đa hình có thể được tạo bằng factories như các quan hệ bình thường.

Quan Hệ Morph Many

Nếu mô hình Post có mối quan hệ morphMany với mô hình Comment:

use App\Models\Post;
 
$post = Post::factory()->hasComments(3)->create();

Morph To Relationships

Để tạo các quan hệ morphTo, bạn không thể sử dụng các phương thức "ma thuật". Thay vào đó, bạn sử dụng phương thức for:

$comments = Comment::factory()->count(3)->for(
    Post::factory(), 'commentable'
)->create();

Quan Hệ "Many-to-Many" Đa Hình

Quan hệ nhiều-mối quan hệ đa hình có thể được tạo giống như các quan hệ nhiều-mối quan hệ không phải đa hình:

use App\Models\Tag;
use App\Models\Video;
 
$videos = Video::factory()
            ->hasAttached(
                Tag::factory()->count(3),
                ['public' => true]
            )
            ->create();

Bạn cũng có thể sử dụng phương thức "ma thuật":

$videos = Video::factory()
            ->hasTags(3, ['public' => true])
            ->create();

Định Nghĩa Quan Hệ Trong Factory

Để định nghĩa một mối quan hệ trong factory của mô hình, bạn thường gán một instance factory mới cho khóa ngoại của mối quan hệ.

Định Nghĩa Quan Hệ "Belongs To"

Ví dụ, nếu bạn muốn tạo một người dùng mới khi tạo một bài viết, bạn có thể làm như sau:

use App\Models\User;
 
/**
 * Định nghĩa trạng thái mặc định của mô hình.
 *
 * @return array<string, mixed>
 */
public function definition(): array
{
    return [
        'user_id' => User::factory(),
        'title' => fake()->title(),
        'content' => fake()->paragraph(),
    ];
}

Sử Dụng Closure Để Định Nghĩa Trạng Thái

Nếu các cột của mối quan hệ phụ thuộc vào factory định nghĩa nó, bạn có thể gán một closure cho thuộc tính:

public function definition(): array
{
    return [
        'user_id' => User::factory(),
        'user_type' => function (array $attributes) {
            return User::find($attributes['user_id'])->type;
        },
        'title' => fake()->title(),
        'content' => fake()->paragraph(),
    ];
}

Tái Sử Dụng Một Mô Hình Đã Tạo

Nếu bạn có các mô hình chia sẻ một mối quan hệ chung với một mô hình khác, bạn có thể sử dụng phương thức recycle để đảm bảo một instance của mô hình liên quan được tái sử dụng cho tất cả các mối quan hệ được tạo bởi factory.

Tái Sử Dụng Một Mô Hình Để Liên Kết

Ví dụ, nếu bạn có các mô hình Airline, Flight, và Ticket, và bạn muốn đảm bảo rằng cùng một hãng hàng không được sử dụng cho cả vé và chuyến bay, bạn có thể làm như sau:

Ticket::factory()
    ->recycle(Airline::factory()->create())
    ->create();

Tái Sử Dụng Một Bộ Sưu Tập Mô Hình

Bạn cũng có thể truyền một bộ sưu tập mô hình vào phương thức recycle. Khi có bộ sưu tập, một mô hình ngẫu nhiên từ bộ sưu tập sẽ được chọn khi factory cần một mô hình loại đó:

$airlines = Airline::factory()->count(3)->create();

Ticket::factory()
    ->recycle($airlines)
    ->create();

Tóm Tắt

Quan Hệ Nhiều-Mối Quan Hệ: Sử dụng hasAttached để liên kết các mô hình qua bảng pivot và phương thức "ma thuật" để đơn giản hóa việc định nghĩa mối quan hệ.
Quan Hệ Đa Hình: Tạo các quan hệ morphMany và morphTo như các quan hệ bình thường, và sử dụng phương thức for cho morphTo.
Định Nghĩa Quan Hệ Trong Factory: Gán một instance factory mới cho khóa ngoại và sử dụng closure nếu cần.
Tái Sử Dụng Một Mô Hình Đã Tạo: Sử dụng phương thức recycle để đảm bảo tái sử dụng một mô hình cho tất cả các mối quan hệ liên quan.

Những tính năng này giúp bạn dễ dàng tạo và quản lý dữ liệu mẫu cho các mối quan hệ phức tạp trong ứng dụng của bạn.

Chi tiết

Eloquent: Factories

01.08.2024

Author:	ADMIN

Ở phần trước các bạn đã được tiếp xúc cơ bản với Eloquent Model and MVC. Trong bài viết này, chúng ta cùng tìm hiểu thêm về Factories nhé!

Factories trong Laravel giúp tạo ra các mô hình (model) và các bản ghi trong cơ sở dữ liệu một cách dễ dàng và tự động, giúp việc kiểm thử và phát triển trở nên thuận tiện hơn.

Tạo Factory

Để tạo một factory, bạn có thể sử dụng lệnh artisan make:factory. Ví dụ, để tạo một factory cho mô hình User, bạn có thể chạy lệnh:

php artisan make:factory UserFactory

Lệnh này sẽ tạo một file factory trong thư mục database/factories.

Định Nghĩa Factory

Trong file factory mới tạo, bạn sẽ định nghĩa các giá trị mặc định cho các thuộc tính của mô hình. Ví dụ:

use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Str;

class UserFactory extends Factory
{
    protected $model = User::class;

    public function definition()
    {
        return [
            'name' => $this->faker->name,
            'email' => $this->faker->unique()->safeEmail,
            'email_verified_at' => now(),
            'password' => bcrypt('password'), // password mặc định
            'remember_token' => Str::random(10),
        ];
    }
}

Sử Dụng Factory

Sau khi đã định nghĩa xong factory, bạn có thể sử dụng nó để tạo ra các bản ghi trong cơ sở dữ liệu. Bạn có thể sử dụng phương thức create để lưu bản ghi vào cơ sở dữ liệu hoặc make để chỉ tạo ra đối tượng mà không lưu.

// Tạo một người dùng và lưu vào cơ sở dữ liệu
$user = User::factory()->create();

// Tạo một đối tượng người dùng nhưng không lưu vào cơ sở dữ liệu
$user = User::factory()->make();

Bạn cũng có thể tạo nhiều bản ghi cùng lúc bằng cách truyền vào số lượng cần tạo:

// Tạo 5 người dùng và lưu vào cơ sở dữ liệu
$users = User::factory()->count(5)->create();

Sử Dụng Factory Với Seeder

Factories rất hữu ích khi sử dụng kết hợp với seeders để tạo dữ liệu mẫu cho ứng dụng:

use Illuminate\Database\Seeder;
use App\Models\User;

class DatabaseSeeder extends Seeder
{
    public function run()
    {
        // Tạo 50 người dùng
        User::factory()->count(50)->create();
    }
}

Chạy lệnh seeder:

php artisan db:seed

# Model and Factory Discovery Conventions

Trong Laravel, các model và factory được kết nối với nhau qua các quy tắc phát hiện (discovery conventions). Khi bạn sử dụng trait Illuminate\Database\Eloquent\Factories\HasFactory trong mô hình của bạn, Laravel sẽ tự động tìm và sử dụng factory phù hợp theo các quy tắc sau:

Tự Động Phát Hiện Factory:
- Laravel sẽ tìm kiếm một factory trong namespace Database\Factories mà có tên lớp (class name) khớp với tên mô hình (model name) và kết thúc bằng Factory.
- Ví dụ, nếu bạn có mô hình Flight, Laravel sẽ tìm kiếm một factory có tên FlightFactory trong namespace Database\Factories.
Xác Định Factory Cụ Thể:
- Nếu bạn muốn xác định factory cho mô hình của bạn theo cách cụ thể hơn hoặc nếu tên và namespace của factory không tuân theo quy tắc tự động, bạn có thể ghi đè phương thức newFactory trên mô hình của mình để trả về instance của factory tương ứng.

Ví Dụ

Giả sử bạn có mô hình Flight và factory tương ứng FlightFactory:

Tạo Mô Hình và Factory:

Mô hình Flight:

namespace App\Models;

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

class Flight extends Model
{
    use HasFactory;

    // Bạn có thể tùy chỉnh phương thức newFactory nếu cần
    protected static function newFactory()
    {
        return \Database\Factories\FlightFactory::new();
    }
}

Factory FlightFactory:

namespace Database\Factories;

use App\Models\Flight;
use Illuminate\Database\Eloquent\Factories\Factory;

class FlightFactory extends Factory
{
    /**
     * Tên của mô hình mà factory tương ứng.
     *
     * @var class-string<\Illuminate\Database\Eloquent\Model>
     */
    protected $model = Flight::class;

    /**
     * Định nghĩa các thuộc tính mẫu cho mô hình.
     *
     * @return array
     */
    public function definition()
    {
        return [
            'flight_number' => $this->faker->unique()->word,
            'departure' => $this->faker->dateTime,
            'arrival' => $this->faker->dateTime,
        ];
    }
}

Sử Dụng Factory Trong Seeder:
Khi bạn sử dụng factory trong seeder, bạn có thể dễ dàng tạo dữ liệu mẫu:

use Illuminate\Database\Seeder;
use App\Models\Flight;

class DatabaseSeeder extends Seeder
{
    public function run()
    {
        // Tạo 10 bản ghi flight
        Flight::factory()->count(10)->create();
    }
}

Chạy Seeder:
```
php artisan db:seed
```

# Factory States

Factory states trong Laravel cho phép bạn định nghĩa các trạng thái (states) khác nhau để áp dụng các thay đổi cụ thể cho các mô hình khi tạo dữ liệu mẫu. Điều này rất hữu ích khi bạn muốn có các biến thể của mô hình với các thuộc tính khác nhau mà không cần phải viết nhiều factory khác nhau.

Cách Định Nghĩa và Sử Dụng Các Trạng Thái Trong Factory

Định Nghĩa Trạng Thái:

Bạn có thể định nghĩa trạng thái trong factory bằng cách sử dụng phương thức state. Phương thức này nhận một closure mà sẽ nhận các thuộc tính gốc của factory và trả về các thuộc tính đã được thay đổi.

Ví dụ:

Giả sử bạn có một factory cho mô hình User và bạn muốn định nghĩa một trạng thái suspended để thay đổi thuộc tính account_status thành suspended:

namespace Database\Factories;

use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Factory;

class UserFactory extends Factory
{
    /**
     * Tên của mô hình mà factory tương ứng.
     *
     * @var class-string<\Illuminate\Database\Eloquent\Model>
     */
    protected $model = User::class;

    /**
     * Định nghĩa các thuộc tính mẫu cho mô hình.
     *
     * @return array
     */
    public function definition()
    {
        return [
            'name' => $this->faker->name,
            'email' => $this->faker->unique()->safeEmail,
            'password' => bcrypt('password'),
            'account_status' => 'active',  // Giá trị mặc định
        ];
    }

    /**
     * Chỉ định rằng người dùng bị tạm ngưng.
     *
     * @return \Illuminate\Database\Eloquent\Factories\Factory
     */
    public function suspended(): Factory
    {
        return $this->state(function (array $attributes) {
            return [
                'account_status' => 'suspended',
            ];
        });
    }
}

Sử Dụng Các Trạng Thái:

Khi bạn muốn sử dụng một trạng thái cụ thể khi tạo dữ liệu mẫu, bạn có thể gọi phương thức trạng thái đó trước khi gọi create() hoặc make().

Ví dụ:

// Tạo một người dùng với trạng thái bị tạm ngưng
$suspendedUser = User::factory()->suspended()->create();

// Tạo một người dùng với trạng thái mặc định
$activeUser = User::factory()->create();

Trạng Thái "Trashed":

Nếu mô hình Eloquent của bạn hỗ trợ xóa mềm (soft deletes), bạn có thể sử dụng trạng thái trashed được tích hợp sẵn để chỉ định rằng mô hình đã bị "xóa mềm".

Ví dụ:
```
use App\Models\User;

// Tạo một người dùng đã bị xóa mềm
$trashedUser = User::factory()->trashed()->create();
```
Trạng thái trashed tự động có sẵn cho tất cả các factory mà mô hình hỗ trợ xóa mềm. Bạn không cần phải định nghĩa trạng thái này trong factory của mình.

# Tạo Mô Hình Sử Dụng Factory

Khi bạn đã định nghĩa các factory, bạn có thể sử dụng phương thức factory tĩnh được cung cấp bởi trait Illuminate\Database\Eloquent\Factories\HasFactory trong các mô hình của bạn để khởi tạo các phiên bản factory cho mô hình đó. Dưới đây là hướng dẫn chi tiết về cách tạo mô hình sử dụng factory.

Khởi Tạo Mô Hình

Tạo Mô Hình Mà Không Lưu Vào Cơ Sở Dữ Liệu:

Để tạo các mô hình mà không lưu vào cơ sở dữ liệu, bạn có thể sử dụng phương thức make:
```
use App\Models\User;

$user = User::factory()->make();
```
Phương thức này tạo ra một đối tượng User mới nhưng không lưu vào cơ sở dữ liệu.
Tạo Một Bộ Sưu Tập Các Mô Hình:

Bạn có thể tạo một số lượng mô hình nhất định bằng cách sử dụng phương thức count:
```
$users = User::factory()->count(3)->make();
```
Lệnh trên tạo ra ba đối tượng User mà không lưu chúng vào cơ sở dữ liệu.

Áp Dụng Trạng Thái

Bạn có thể áp dụng các trạng thái khác nhau cho các mô hình. Nếu bạn muốn áp dụng nhiều trạng thái cho các mô hình, bạn chỉ cần gọi các phương thức trạng thái trực tiếp:

$users = User::factory()->count(5)->suspended()->make();

Trong ví dụ này, năm đối tượng User được tạo ra với trạng thái bị tạm ngưng.

Ghi Đè Thuộc Tính

Nếu bạn muốn ghi đè một số giá trị mặc định của mô hình, bạn có thể truyền một mảng các giá trị vào phương thức make. Chỉ những thuộc tính được chỉ định mới bị thay đổi, trong khi các thuộc tính khác vẫn giữ giá trị mặc định:

$user = User::factory()->make([
    'name' => 'Abigail Otwell',
]);

Ngoài ra, bạn có thể sử dụng phương thức state để thực hiện việc ghi đè thuộc tính trực tiếp:

$user = User::factory()->state([
    'name' => 'Abigail Otwell',
])->make();

Lưu ý rằng việc tạo mô hình bằng factory tự động tắt bảo vệ gán hàng loạt (mass assignment).

Lưu Mô Hình Vào Cơ Sở Dữ Liệu

Phương thức create không chỉ khởi tạo mô hình mà còn lưu nó vào cơ sở dữ liệu:

use App\Models\User;

// Tạo một đối tượng User và lưu vào cơ sở dữ liệu...
$user = User::factory()->create();

// Tạo ba đối tượng User và lưu vào cơ sở dữ liệu...
$users = User::factory()->count(3)->create();

Bạn có thể ghi đè các thuộc tính mặc định của factory bằng cách truyền một mảng các thuộc tính vào phương thức create:

$user = User::factory()->create([
    'name' => 'Abigail',
]);

Sequences

Đôi khi bạn muốn luân phiên giá trị của một thuộc tính mô hình cho mỗi mô hình được tạo. Bạn có thể thực hiện điều này bằng cách định nghĩa một chuỗi (sequence) trong factory. Ví dụ, bạn có thể muốn luân phiên giá trị của thuộc tính admin giữa Y và N:

use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Sequence;

$users = User::factory()
                ->count(10)
                ->state(new Sequence(
                    ['admin' => 'Y'],
                    ['admin' => 'N'],
                ))
                ->create();

Trong ví dụ này, năm đối tượng User sẽ có giá trị admin là Y và năm đối tượng sẽ có giá trị là N.

Nếu cần, bạn có thể sử dụng một closure làm giá trị chuỗi. Closure sẽ được gọi mỗi khi chuỗi cần một giá trị mới:

use Illuminate\Database\Eloquent\Factories\Sequence;

$users = User::factory()
                ->count(10)
                ->state(new Sequence(
                    fn (Sequence $sequence) => ['role' => UserRoles::all()->random()],
                ))
                ->create();

Trong closure của chuỗi, bạn có thể truy cập các thuộc tính $index hoặc $count trên đối tượng chuỗi được chèn vào closure. Thuộc tính $index chứa số lần lặp qua chuỗi cho đến thời điểm đó, trong khi thuộc tính $count chứa tổng số lần chuỗi sẽ được gọi:

$users = User::factory()
                ->count(10)
                ->sequence(fn (Sequence $sequence) => ['name' => 'Name '.$sequence->index])
                ->create();

Để tiện lợi, bạn cũng có thể áp dụng chuỗi bằng phương thức sequence, phương thức này thực hiện gọi phương thức state nội bộ. Phương thức sequence chấp nhận một closure hoặc các mảng thuộc tính được chuỗi hóa:

$users = User::factory()
                ->count(2)
                ->sequence(
                    ['name' => 'First User'],
                    ['name' => 'Second User'],
                )
                ->create();

# Factory Relationships

Trong Laravel, bạn có thể xây dựng các mối quan hệ giữa các mô hình bằng cách sử dụng các phương thức factory. Dưới đây là cách bạn có thể sử dụng factories để tạo các mối quan hệ hasMany và belongsTo giữa các mô hình.

Quan Hệ "Has Many"

Khi một mô hình có nhiều mối quan hệ với một mô hình khác, ví dụ như một User có nhiều Post, bạn có thể sử dụng phương thức has của factory để tạo các mô hình liên quan.

Tạo Mô Hình Có Quan Hệ Has Many

Giả sử bạn có mô hình User và Post, và mô hình User định nghĩa một mối quan hệ hasMany với Post. Để tạo một người dùng với ba bài viết, bạn có thể sử dụng phương thức has như sau:
```
use App\Models\Post;
use App\Models\User;

$user = User::factory()
            ->has(Post::factory()->count(3))
            ->create();
```
Laravel sẽ tự động giả định rằng mô hình User có một phương thức posts để định nghĩa mối quan hệ hasMany. Nếu cần, bạn có thể chỉ định tên của mối quan hệ:
```
$user = User::factory()
            ->has(Post::factory()->count(3), 'posts')
            ->create();
```
Sử Dụng Các Phương Thức "Ma Thuật"

Để tiện lợi, bạn có thể sử dụng các phương thức mối quan hệ "ma thuật" của factory. Ví dụ, phương thức sau sẽ tự động xác định rằng các mô hình liên quan nên được tạo thông qua phương thức posts trên mô hình User:
```
$user = User::factory()
            ->hasPosts(3)
            ->create();
```
Bạn cũng có thể ghi đè thuộc tính cho các mô hình liên quan:
```
$user = User::factory()
            ->hasPosts(3, [
                'published' => false,
            ])
            ->create();
```
Và bạn có thể sử dụng closure nếu trạng thái cần truy cập vào mô hình cha:
```
$user = User::factory()
            ->hasPosts(3, function (array $attributes, User $user) {
                return ['user_type' => $user->type];
            })
            ->create();
```

Quan Hệ "Belongs To"

Bây giờ, hãy khám phá cách xây dựng các mối quan hệ ngược lại, tức là khi một mô hình thuộc về một mô hình khác. Bạn có thể sử dụng phương thức for để định nghĩa mô hình cha mà các mô hình do factory tạo ra thuộc về.

Tạo Các Mô Hình Thuộc Về Một Mô Hình Cha

Để tạo ba bài viết thuộc về một người dùng duy nhất, bạn có thể làm như sau:

use App\Models\Post;
use App\Models\User;

$posts = Post::factory()
            ->count(3)
            ->for(User::factory()->state([
                'name' => 'Jessica Archer',
            ]))
            ->create();

Nếu bạn đã có một đối tượng mô hình cha và muốn liên kết với các mô hình bạn đang tạo, bạn có thể truyền đối tượng mô hình vào phương thức for:

$user = User::factory()->create();

$posts = Post::factory()
            ->count(3)
            ->for($user)
            ->create();

Sử Dụng Các Phương Thức "Ma Thuật"

Để tiện lợi, bạn cũng có thể sử dụng các phương thức mối quan hệ "ma thuật" của factory để định nghĩa quan hệ belongsTo. Ví dụ, phương thức sau sẽ tự động xác định rằng các bài viết nên thuộc về mối quan hệ user trên mô hình Post:
```
$posts = Post::factory()
            ->count(3)
            ->forUser([
                'name' => 'Jessica Archer',
            ])
            ->create();
```

Tóm Tắt

Quan Hệ "Has Many": Sử dụng phương thức has để tạo các mô hình liên quan với mối quan hệ hasMany. Bạn có thể áp dụng trạng thái và sử dụng các phương thức "ma thuật" để dễ dàng định nghĩa mối quan hệ.

Quan Hệ "Belongs To": Sử dụng phương thức for để xác định mô hình cha mà các mô hình do factory tạo ra thuộc về. Bạn cũng có thể sử dụng các phương thức "ma thuật" để đơn giản hóa việc định nghĩa quan hệ.

Các tính năng này giúp bạn dễ dàng tạo dữ liệu mẫu cho việc kiểm thử và phát triển ứng dụng với các mối quan hệ giữa các mô hình.

Ở bài tiếp theo, chúng ta sẽ cùng khám phá các Relationships và các vấn đề liên quan đến Factories nhé

Chi tiết

Quản Lý Thời Gian Tự Động Trong Eloquent

01.08.2024

Author:	ADMIN

# Timestamps

Mặc định, Eloquent yêu cầu hai cột created_at và updated_at tồn tại trên bảng cơ sở dữ liệu tương ứng với mô hình của bạn. Eloquent sẽ tự động thiết lập giá trị cho các cột này khi mô hình được tạo mới hoặc cập nhật.

Tuy nhiên, nếu bạn không muốn Eloquent tự động quản lý các cột thời gian này, bạn có thể cấu hình mô hình của bạn để bỏ qua việc tự động cập nhật các cột created_at và updated_at. Để làm điều này, bạn cần định nghĩa thuộc tính $timestamps trên mô hình của bạn với giá trị false.

Ví Dụ Cụ Thể

Mô Hình Mặc Định Với Cột Thời Gian

Khi bạn tạo một mô hình Eloquent mà không cấu hình thuộc tính $timestamps, Eloquent sẽ tự động quản lý các cột thời gian:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    // Eloquent tự động quản lý created_at và updated_at
}

Bỏ Qua Quản Lý Thời Gian

Nếu bạn không muốn Eloquent tự động quản lý created_at và updated_at, bạn có thể cấu hình mô hình của bạn như sau:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    // Tắt quản lý created_at và updated_at
    public $timestamps = false;
}

# Tùy Chỉnh Định Dạng Thời Gian

Nếu bạn cần tùy chỉnh định dạng của các timestamp trên mô hình Eloquent của bạn, bạn có thể thiết lập thuộc tính $dateFormat trên mô hình. Thuộc tính này xác định cách các thuộc tính ngày tháng được lưu trữ trong cơ sở dữ liệu cũng như định dạng của chúng khi mô hình được chuyển đổi thành mảng hoặc JSON.

Ví Dụ Cụ Thể

Giả sử bạn muốn thay đổi định dạng ngày tháng từ mặc định (Y-m-d H:i:s) thành định dạng khác, chẳng hạn như d/m/Y H:i:s, bạn có thể thực hiện điều này bằng cách cấu hình thuộc tính $dateFormat trong mô hình của bạn.

Mô Hình Với Định Dạng Tùy Chỉnh

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    // Đặt định dạng ngày tháng tùy chỉnh
    protected $dateFormat = 'd/m/Y H:i:s';
}

Cách Hoạt Động

Lưu Trữ Trong Cơ Sở Dữ Liệu: Khi bạn lưu một mô hình vào cơ sở dữ liệu, Eloquent sẽ sử dụng định dạng d/m/Y H:i:s để lưu trữ giá trị thời gian vào các cột created_at và updated_at.
Chuyển Đổi Thành Mảng hoặc JSON: Khi bạn chuyển đổi mô hình thành mảng hoặc JSON, giá trị của các thuộc tính ngày tháng sẽ được định dạng theo cách bạn đã chỉ định trong thuộc tính $dateFormat.

# Tùy Chỉnh Tên Cột Thời Gian Trong Eloquent

Nếu bạn cần tùy chỉnh tên của các cột được sử dụng để lưu trữ timestamp (created_at và updated_at), bạn có thể định nghĩa các hằng số CREATED_AT và UPDATED_AT trên mô hình của bạn. Điều này cho phép bạn thay đổi tên các cột mặc định mà Eloquent sử dụng để lưu trữ thời gian tạo và cập nhật.

Ví Dụ Cụ Thể

Giả sử bạn có các cột trong bảng cơ sở dữ liệu với tên là created_on và updated_on thay vì created_at và updated_at. Bạn có thể cấu hình mô hình của bạn như sau:

Mô Hình Với Tên Cột Tùy Chỉnh

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    // Định nghĩa tên cột tùy chỉnh cho thời gian tạo và cập nhật
    const CREATED_AT = 'created_on';
    const UPDATED_AT = 'updated_on';
}

Cách Hoạt Động

Lưu Trữ Trong Cơ Sở Dữ Liệu: Eloquent sẽ sử dụng các tên cột tùy chỉnh (created_on và updated_on) thay vì các tên mặc định (created_at và updated_at) khi lưu trữ giá trị thời gian vào cơ sở dữ liệu.
Lấy Dữ Liệu: Khi bạn lấy dữ liệu từ cơ sở dữ liệu, Eloquent sẽ sử dụng các tên cột tùy chỉnh này để gán giá trị cho thuộc tính created_at và updated_at của mô hình.

# Không Cập Nhật updated_at

Nếu bạn muốn thực hiện các thao tác với mô hình mà không làm thay đổi giá trị của timestamp updated_at, bạn có thể sử dụng phương thức withoutTimestamps. Phương thức này cho phép bạn thực hiện các thao tác trên mô hình mà không ảnh hưởng đến giá trị của updated_at.

Ví Dụ Cụ Thể

Giả sử bạn có một mô hình Post và bạn muốn cập nhật một thuộc tính của mô hình mà không làm thay đổi timestamp updated_at, bạn có thể sử dụng withoutTimestamps để thực hiện điều này.

Cập Nhật Mô Hình Mà Không Cập Nhật updated_at

use App\Models\Post;

// Tìm mô hình cần cập nhật
$post = Post::find(1);

// Thực hiện cập nhật mà không làm thay đổi timestamp
$post->withoutTimestamps(function () use ($post) {
    // Cập nhật thuộc tính của mô hình
    $post->title = 'New Title';
    $post->save();
});

Chi tiết

Các Mối Quan Hệ Trong Eloquent

01.08.2024

Author:	ADMIN

# Các Mối Quan Hệ Trong Eloquent

Eloquent cung cấp một hệ thống mạnh mẽ để quản lý các mối quan hệ giữa các mô hình trong cơ sở dữ liệu. Các mối quan hệ giúp bạn dễ dàng lấy dữ liệu liên quan từ các bảng khác nhau. Dưới đây là các loại mối quan hệ phổ biến trong Eloquent và cách sử dụng chúng:

1. Mối Quan Hệ Một-Một (One-to-One)

Một mối quan hệ một-một liên kết hai mô hình với nhau, với mỗi bản ghi trong bảng đầu tiên liên kết với một bản ghi trong bảng thứ hai.

Ví Dụ:

// Mô hình User
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    public function profile()
    {
        return $this->hasOne(Profile::class);
    }
}

// Mô hình Profile
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

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

Cấu Trúc Bảng:

users table: id, name
profiles table: id, user_id, bio

2. Mối Quan Hệ Một-Nhiều (One-to-Many)

Một mối quan hệ một-nhiều cho phép một bản ghi trong bảng đầu tiên liên kết với nhiều bản ghi trong bảng thứ hai.

Ví Dụ:

// Mô hình Post
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

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

// Mô hình Comment
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

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

Cấu Trúc Bảng:

posts table: id, title
comments table: id, post_id, content

3. Mối Quan Hệ Nhiều-Nhiều (Many-to-Many)

Mối quan hệ nhiều-nhiều cho phép nhiều bản ghi trong bảng đầu tiên liên kết với nhiều bản ghi trong bảng thứ hai thông qua bảng trung gian.

Ví Dụ:

// Mô hình Student
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Student extends Model
{
    public function courses()
    {
        return $this->belongsToMany(Course::class);
    }
}

// Mô hình Course
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Course extends Model
{
    public function students()
    {
        return $this->belongsToMany(Student::class);
    }
}

Cấu Trúc Bảng:

students table: id, name
courses table: id, title
course_student table: student_id, course_id

4. Mối Quan Hệ Một-Một (Polymorphic)

Mối quan hệ polymorphic cho phép một mô hình liên kết với nhiều mô hình khác theo cách linh hoạt.

Ví Dụ:

// Mô hình Comment
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Comment extends Model
{
    public function commentable()
    {
        return $this->morphTo();
    }
}

// Mô hình Post
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

// Mô hình Video
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Video extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Cấu Trúc Bảng:

comments table: id, commentable_id, commentable_type, content
posts table: id, title
videos table: id, title

5. Mối Quan Hệ Một-Nhiều (Polymorphic)

Mối quan hệ một-nhiều polymorphic cho phép một mô hình liên kết với nhiều mô hình khác mà không cần phải tạo ra nhiều cột khóa ngoại. Điều này rất hữu ích khi bạn muốn một mô hình có thể liên kết với nhiều loại mô hình khác mà không cần tạo nhiều bảng trung gian.

Ví Dụ Cụ Thể

Giả sử bạn có một hệ thống mà người dùng có thể bình luận trên các bài viết (Post) và video (Video). Bạn có thể sử dụng mối quan hệ polymorphic để xử lý các bình luận mà không cần tạo bảng trung gian riêng cho mỗi loại mô hình.

Bước 1: Tạo Các Mô Hình và Cấu Trúc Bảng

Tạo Model Comment

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Comment extends Model
{
    /**
     * Thiết lập mối quan hệ polymorphic.
     */
    public function commentable()
    {
        return $this->morphTo();
    }
}

Tạo Model Post

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    /**
     * Thiết lập mối quan hệ một-nhiều polymorphic.
     */
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Tạo Model Video

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Video extends Model
{
    /**
     * Thiết lập mối quan hệ một-nhiều polymorphic.
     */
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Tạo Cấu Trúc Bảng

Bảng comments

Schema::create('comments', function (Blueprint $table) {
    $table->id();
    $table->text('content');
    $table->unsignedBigInteger('commentable_id');
    $table->string('commentable_type');
    $table->timestamps();
});

commentable_id: ID của mô hình mà bình luận thuộc về.
commentable_type: Loại mô hình mà bình luận thuộc về (ví dụ: Post hoặc Video).

Bảng posts

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

Bảng videos

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

Bước 2: Sử Dụng Mối Quan Hệ

1. Thêm Bình Luận

use App\Models\Post;
use App\Models\Video;
use App\Models\Comment;

// Thêm bình luận cho một bài viết
$post = Post::find(1);
$post->comments()->create([
    'content' => 'Great post!',
]);

// Thêm bình luận cho một video
$video = Video::find(1);
$video->comments()->create([
    'content' => 'Amazing video!',
]);

2. Truy Xuất Bình Luận

// Truy xuất bình luận của một bài viết
$post = Post::find(1);
foreach ($post->comments as $comment) {
    echo $comment->content;
}

// Truy xuất bình luận của một video
$video = Video::find(1);
foreach ($video->comments as $comment) {
    echo $comment->content;
}

3. Lấy Mô Hình Từ Bình Luận

// Lấy mô hình mà bình luận thuộc về
$comment = Comment::find(1);
echo $comment->commentable_type; // Ví dụ: App\Models\Post hoặc App\Models\Video

6.Mối Quan Hệ Nhiều-Nhiều (Polymorphic)

Mối quan hệ nhiều-nhiều polymorphic cho phép một mô hình liên kết với nhiều mô hình khác và ngược lại thông qua một bảng trung gian duy nhất. Điều này cho phép mô hình liên kết với nhiều mô hình khác mà không cần phải tạo nhiều bảng trung gian riêng biệt.

Ví Dụ: Tagging trên Bài Viết và Video

Cấu Trúc và Mô Hình

Tạo Mô Hình Tag

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Tag extends Model
{
    /**
     * Thiết lập mối quan hệ nhiều-nhiều polymorphic.
     */
    public function taggable()
    {
        return $this->morphTo();
    }
}

Tạo Mô Hình Post

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    /**
     * Thiết lập mối quan hệ nhiều-nhiều polymorphic.
     */
    public function tags()
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}

Tạo Mô Hình Video

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Video extends Model
{
    /**
     * Thiết lập mối quan hệ nhiều-nhiều polymorphic.
     */
    public function tags()
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}

Tạo Cấu Trúc Bảng

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

Schema::create('taggables', function (Blueprint $table) {
    $table->unsignedBigInteger('tag_id');
    $table->unsignedBigInteger('taggable_id');
    $table->string('taggable_type');
    $table->timestamps();
});

Sử dụng

// Thêm tag cho một bài viết
$post = Post::find(1);
$tag = Tag::find(1);
$post->tags()->attach($tag);

// Thêm tag cho một video
$video = Video::find(1);
$tag = Tag::find(2);
$video->tags()->attach($tag);

Kết Luận

Một-Một (One-to-One): Liên kết mỗi bản ghi trong bảng đầu tiên với một bản ghi trong bảng thứ hai.
Một-Nhiều (One-to-Many): Liên kết một bản ghi trong bảng đầu tiên với nhiều bản ghi trong bảng thứ hai.
Nhiều-Nhiều (Many-to-Many): Liên kết nhiều bản ghi trong bảng đầu tiên với nhiều bản ghi trong bảng thứ hai thông qua bảng trung gian.
Polymorphic: Cho phép liên kết linh hoạt với nhiều mô hình khác.

Các mối quan hệ trong Eloquent giúp bạn dễ dàng quản lý và truy xuất dữ liệu liên quan trong ứng dụng của bạn, làm cho việc tương tác với cơ sở dữ liệu trở nên dễ dàng và trực quan hơn.

Chi tiết

Basic Eloquent Model and MVC

01.08.2024

Author:	ADMIN

Trong Laravel, mô hình Eloquent cùng với kiến trúc MVC (Model-View-Controller) cung cấp một cách hiệu quả để xây dựng ứng dụng web. Dưới đây là cách hoạt động cơ bản của ba thành phần chính trong kiến trúc MVC:

1. Model (Mô Hình)

Model là thành phần đại diện cho dữ liệu của ứng dụng và thường tương tác với cơ sở dữ liệu. Trong Laravel, mô hình Eloquent được sử dụng để quản lý dữ liệu một cách dễ dàng và trực quan.

Tạo một Model:

Bạn có thể tạo một mô hình bằng cách sử dụng Artisan command:

php artisan make:model Post

Ngoài ra còn một số command tạo model khác, bạn có thể tham khảo bên dưới

# Tạo một model Flight cùng với một lớp factory. Lớp factory được sử dụng để tạo dữ liệu giả cho việc kiểm thử hoặc phát triển.
php artisan make:model Flight --factory
php artisan make:model Flight -f
 
# Tạo một model Flight cùng với một lớp seeder. Seeder được sử dụng để chèn dữ liệu mẫu vào cơ sở dữ liệu.
php artisan make:model Flight --seed
php artisan make:model Flight -s
 
# Tạo một model Flight cùng với một lớp controller. Controller được sử dụng để xử lý các yêu cầu HTTP và điều hướng đến các view hoặc thao tác với mô hình.
php artisan make:model Flight --controller
php artisan make:model Flight -c
 
# Tạo một model Flight, một lớp controller resource (controller với các phương thức chuẩn RESTful), và các lớp form request để xác thực dữ liệu đầu vào.
php artisan make:model Flight --controller --resource --requests
php artisan make:model Flight -crR
 
# Tạo một model Flight cùng với một lớp policy. Policy được sử dụng để xác định quyền truy cập cho các hành động trên mô hình.
php artisan make:model Flight --policy
 
# Tạo một model Flight, một migration (để tạo bảng trong cơ sở dữ liệu), một lớp factory, một lớp seeder, và một lớp controller. 
# Đây là cách nhanh chóng để tạo tất cả các thành phần cơ bản cho một mô hình.
php artisan make:model Flight -mfsc
 
# Tạo một model Flight cùng với tất cả các thành phần liên quan bao gồm migration, factory, seeder, policy, controller, và form request. 
# Đây là một cách tiện lợi để tạo tất cả các thành phần cơ bản và mở rộng cho một mô hình trong một lệnh duy nhất.
php artisan make:model Flight --all
 
# Tạo một model Member để sử dụng cho các bảng pivot trong các mối quan hệ nhiều-nhiều. 
# Pivot model là các mô hình đặc biệt dùng để lưu trữ các mối quan hệ giữa hai mô hình khác.
php artisan make:model Member --pivot
php artisan make:model Member -p

Định nghĩa Model:

Mô hình Post sẽ được lưu trữ trong thư mục app/Models. Ví dụ về một mô hình cơ bản:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    // Tên bảng (nếu không theo quy ước tên bảng số nhiều)
    protected $table = 'posts';

    // Các thuộc tính có thể được gán đại chúng
    protected $fillable = ['title', 'content'];

    // set primary key
    protected $primaryKey = 'flight_id';

    /**
     * Cho biết ID của model có tự động tăng hay không.
     */
    public $incrementing = false;
}

Mô hình này đại diện cho bảng posts trong cơ sở dữ liệu và có thể thực hiện các thao tác như truy vấn, thêm, sửa, xóa dữ liệu.

2. Controller (Bộ điều khiển)

Controller là thành phần xử lý logic ứng dụng và giao tiếp giữa mô hình và view. Nó nhận các yêu cầu từ người dùng, thao tác với mô hình và trả về dữ liệu cho view.

Tạo một Controller:

Sử dụng Artisan command để tạo một controller mới:

php artisan make:controller PostController

Định nghĩa Controller:

Bên trong controller, bạn có thể định nghĩa các phương thức để xử lý yêu cầu từ người dùng:

namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\Request;

class PostController extends Controller
{
    public function index()
    {
        // Lấy tất cả các bài viết từ cơ sở dữ liệu
        $posts = Post::all();
        // Trả về view với dữ liệu bài viết
        return view('posts.index', compact('posts'));
    }

    public function show($id)
    {
        // Tìm bài viết theo ID
        $post = Post::findOrFail($id);
        // Trả về view với dữ liệu bài viết
        return view('posts.show', compact('post'));
    }

    public function store(Request $request)
    {
        // Xác thực và tạo bài viết mới
        $request->validate([
            'title' => 'required',
            'content' => 'required',
        ]);

        Post::create($request->all());
        return redirect()->route('posts.index');
    }
}

3. View (Giao diện)

View là phần của ứng dụng chịu trách nhiệm hiển thị dữ liệu cho người dùng. Trong Laravel, các view thường được lưu trữ trong thư mục resources/views và được viết bằng Blade, một engine template của Laravel.

Tạo View:

Tạo các file Blade trong thư mục resources/views/posts để hiển thị dữ liệu:

index.blade.php: Hiển thị danh sách tất cả các bài viết

<!DOCTYPE html>
<html>
<head>
    <title>Danh sách bài viết</title>
</head>
<body>
    <h1>Danh sách bài viết</h1>
    <ul>
        @foreach($posts as $post)
            <li><a href="{{ route('posts.show', $post->id) }}">{{ $post->title }}</a></li>
        @endforeach
    </ul>
</body>
</html>

show.blade.php: Hiển thị chi tiết một bài viết

<!DOCTYPE html>
<html>
<head>
    <title>{{ $post->title }}</title>
</head>
<body>
    <h1>{{ $post->title }}</h1>
    <p>{{ $post->content }}</p>
    <a href="{{ route('posts.index') }}">Trở lại danh sách</a>
</body>
</html>

Tổng Quan

Model (Mô Hình) quản lý dữ liệu và tương tác với cơ sở dữ liệu.
Controller (Bộ điều khiển) xử lý logic và điều hướng giữa mô hình và giao diện.
View (Giao diện) hiển thị dữ liệu cho người dùng.

Sử dụng kiến trúc MVC trong Laravel giúp phân chia rõ ràng giữa các phần của ứng dụng, làm cho việc phát triển và bảo trì dễ dàng hơn.

Chi tiết

Eager Loading

01.08.2024

Author:	ADMIN

# Eager Loading

Eager loading là một kỹ thuật trong Eloquent ORM của Laravel để giảm số lượng truy vấn đến cơ sở dữ liệu bằng cách tải các quan hệ của model ngay lập tức khi bạn truy vấn model chính. Điều này giúp cải thiện hiệu suất ứng dụng bằng cách tránh vấn đề N+1 queries, nơi bạn thực hiện nhiều truy vấn không cần thiết khi tải các quan hệ.

Ví Dụ: Eager Loading với Mối Quan Hệ Một-Nhiều

Giả sử bạn có một model Post và mỗi bài viết có nhiều Comment. Khi bạn muốn lấy tất cả các bài viết cùng với các bình luận của chúng, bạn có thể sử dụng eager loading để giảm số lượng truy vấn SQL.

Model và Cấu Trúc Bảng

Model Post

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    /**
     * Thiết lập mối quan hệ một-nhiều với Comment.
     */
    public function comments()
    {
        return $this->hasMany(Comment::class);
    }
}

Model Comment

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Comment extends Model
{
    /**
     * Thiết lập mối quan hệ nhiều-một với Post.
     */
    public function post()
    {
        return $this->belongsTo(Post::class);
    }
}

Cấu Trúc Bảng

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

Schema::create('comments', function (Blueprint $table) {
    $table->id();
    $table->unsignedBigInteger('post_id');
    $table->text('content');
    $table->timestamps();

    $table->foreign('post_id')->references('id')->on('posts')->onDelete('cascade');
});

Sử Dụng Eager Loading
4.1 Truy Vấn Bình Thường (Lazy Loading)

// Lấy tất cả bài viết
$posts = Post::all();

// Truy xuất các bình luận của mỗi bài viết (N+1 queries)
foreach ($posts as $post) {
    foreach ($post->comments as $comment) {
        // Xử lý bình luận
    }
}

4.2 Sử Dụng Eager Loading

// Lấy tất cả bài viết cùng với các bình luận của chúng (1 query cho bài viết + 1 query cho bình luận)
$posts = Post::with('comments')->get();

// Truy xuất các bình luận của mỗi bài viết mà không thực hiện thêm truy vấn
foreach ($posts as $post) {
    foreach ($post->comments as $comment) {
        // Xử lý bình luận
    }
}

Các Tùy Chọn Eager Loading

5.1 Chỉ Định Các Quan Hệ Nâng Cao

Bạn có thể eager load nhiều quan hệ hoặc nested quan hệ (quan hệ trong quan hệ) bằng cách chỉ định chúng trong phương thức with.

// Eager load các quan hệ bình luận và user của mỗi bình luận
$posts = Post::with('comments.user')->get();

5.2 Sử Dụng withCount
Bạn có thể sử dụng withCount để lấy số lượng các quan hệ mà không cần phải lấy dữ liệu chi tiết của quan hệ.

// Lấy số lượng bình luận cho mỗi bài viết
$posts = Post::withCount('comments')->get();

foreach ($posts as $post) {
    echo $post->comments_count; // Số lượng bình luận
}

5.3 Eager Load Với Điều Kiện

// Eager load bình luận với điều kiện chỉ lấy những bình luận mới nhất
$posts = Post::with(['comments' => function ($query) {
    $query->where('created_at', '>', now()->subDays(7));
}])->get();

# Nested Eager Loading morphTo Relationships

Khi làm việc với các mối quan hệ polymorphic trong Eloquent, bạn có thể cần thực hiện eager loading không chỉ cho các mối quan hệ polymorphic mà còn cho các mối quan hệ liên quan đến các model mà chúng liên kết đến. Đây được gọi là nested eager loading.

Mối Quan Hệ Polymorphic (morphTo) cho phép một model liên kết với nhiều model khác và không cần phải tạo nhiều cột khóa ngoại. Khi sử dụng eager loading với các mối quan hệ polymorphic, bạn có thể tải tất cả các dữ liệu cần thiết trong một truy vấn hiệu quả.

Ví Dụ: Nested Eager Loading với Mối Quan Hệ Polymorphic

Giả sử bạn có một hệ thống bình luận mà mỗi bình luận có thể thuộc về nhiều loại model khác nhau (như Post hoặc Video). Đồng thời, mỗi bình luận có thể được gán cho một người dùng (user). Dưới đây là cách bạn có thể thiết lập và thực hiện nested eager loading cho các mối quan hệ này.

Cấu Trúc và Model

Model Comment

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Comment extends Model
{
    /**
     * Thiết lập mối quan hệ polymorphic.
     */
    public function commentable()
    {
        return $this->morphTo();
    }

    /**
     * Thiết lập mối quan hệ nhiều-một với User.
     */
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

Model Post

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    /**
     * Thiết lập mối quan hệ một-nhiều polymorphic với Comment.
     */
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Model Video

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Video extends Model
{
    /**
     * Thiết lập mối quan hệ một-nhiều polymorphic với Comment.
     */
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Model User

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    /**
     * Thiết lập mối quan hệ một-nhiều với Comment.
     */
    public function comments()
    {
        return $this->hasMany(Comment::class);
    }
}

Cấu Trúc Bảng

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

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

Schema::create('comments', function (Blueprint $table) {
    $table->id();
    $table->unsignedBigInteger('commentable_id');
    $table->string('commentable_type');
    $table->unsignedBigInteger('user_id');
    $table->text('content');
    $table->timestamps();

    $table->foreign('user_id')->references('id')->on('users')->onDelete('cascade');
});

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

Thực Hiện Nested Eager Loading
```
// Lấy tất cả các bài viết cùng với bình luận của chúng, bình luận có người dùng và video hoặc bài viết liên quan
$posts = Post::with(['comments.user', 'comments.commentable'])->get();

foreach ($posts as $post) {
    foreach ($post->comments as $comment) {
        echo $comment->content; // Nội dung bình luận
        echo $comment->user->name; // Tên người dùng bình luận
        echo $comment->commentable->title; // Tiêu đề của video hoặc bài viết liên quan
    }
}
```
Giải Thích:
- Post::with(['comments.user', 'comments.commentable'])->get();: Phương thức with được sử dụng để eager load các quan hệ comments và trong comments, eager load user (người dùng bình luận) và commentable (model mà bình luận thuộc về, có thể là Post hoặc Video).
- Trong ví dụ này, khi bạn truy xuất các bài viết và bình luận, tất cả các dữ liệu liên quan đến bình luận và người dùng bình luận, cùng với model liên quan của bình luận (có thể là bài viết hoặc video) sẽ được tải ngay lập tức, giúp giảm số lượng truy vấn đến cơ sở dữ liệu.

Chi tiết

Database: Seeding

01.08.2024

Author:	ADMIN

Seeding trong Laravel là một cách để tự động thêm dữ liệu mẫu vào cơ sở dữ liệu của bạn. Điều này hữu ích khi bạn cần tạo ra dữ liệu thử nghiệm hoặc khởi tạo dữ liệu mặc định cho ứng dụng.

Tạo Seeder

Bạn có thể tạo một seeder mới bằng cách sử dụng lệnh Artisan:

php artisan make:seeder UsersTableSeeder

Lệnh này sẽ tạo một file seeder mới trong thư mục database/seeders.

Định Nghĩa Seeder

Khi bạn mở file seeder, nó sẽ trông giống như sau:

<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;

class UsersTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        // Đoạn mã để chèn dữ liệu mẫu vào bảng users
    }
}

Bạn có thể sử dụng phương thức DB::table hoặc các phương thức của Eloquent để chèn dữ liệu vào bảng:

public function run()
{
    DB::table('users')->insert([
        'name' => Str::random(10),
        'email' => Str::random(10).'@gmail.com',
        'password' => bcrypt('password'),
    ]);
}

Hoặc sử dụng model Eloquent:

public function run()
{
    \App\Models\User::create([
        'name' => 'John Doe',
        'email' => 'johndoe@example.com',
        'password' => bcrypt('password'),
    ]);
}

Gọi Seeder

Sau khi định nghĩa seeder, bạn cần gọi nó trong lớp DatabaseSeeder để nó được chạy khi bạn chạy lệnh seed:

// database/seeders/DatabaseSeeder.php

public function run()
{
    $this->call(UsersTableSeeder::class);
}

Chạy Seeder

Bạn có thể chạy tất cả các seeder bằng lệnh Artisan:

php artisan db:seed

Hoặc chạy một seeder cụ thể:

php artisan db:seed --class=UsersTableSeeder

Tái Tạo Cơ Sở Dữ Liệu

Nếu bạn muốn làm mới cơ sở dữ liệu và chạy lại các seeder, bạn có thể sử dụng lệnh migrate:fresh:

php artisan migrate:fresh --seed

Lệnh này sẽ xóa tất cả các bảng trong cơ sở dữ liệu của bạn và chạy lại tất cả các migration và seeder.

Tùy chọn --seeder có thể được sử dụng để chỉ định một seeder cụ thể để chạy:

php artisan migrate:fresh --seed --seeder=UserSeeder

Sử Dụng Factory trong Seeder

Laravel có thể tích hợp factory với seeder để tạo ra dữ liệu mẫu phong phú hơn. Ví dụ, bạn có thể sử dụng factory để tạo nhiều người dùng một cách dễ dàng:

public function run()
{
    \App\Models\User::factory(10)->create();
}

Forcing Seeders to Run in Production

Khi làm việc với Laravel, bạn có thể muốn chạy seeder (tạo dữ liệu mẫu) ngay cả khi ứng dụng đang ở môi trường production. Điều này thường bị ngăn chặn để tránh nguy cơ làm hỏng dữ liệu thực tế. Tuy nhiên, đôi khi bạn vẫn cần phải chạy seeder trong môi trường production, và Laravel cung cấp cách để làm điều này một cách an toàn.

php artisan db:seed --force

Cờ --force sẽ bỏ qua cảnh báo và cho phép seeder chạy ngay cả khi ứng dụng đang ở môi trường production.

Ví dụ Thực Tế

Giả sử bạn có một seeder gọi là DatabaseSeeder và bạn muốn chạy nó trong môi trường production. Bạn chỉ cần chạy lệnh sau từ dòng lệnh:

php artisan db:seed --class=DatabaseSeeder --force

Lệnh trên sẽ thực hiện seeding dữ liệu từ DatabaseSeeder vào cơ sở dữ liệu hiện tại, ngay cả khi ứng dụng đang ở môi trường production.

Chạy Seeder Cụ Thể

Nếu bạn chỉ muốn chạy một seeder cụ thể trong môi trường production, bạn có thể chỉ định seeder đó với cờ --class cùng với --force. Ví dụ:

php artisan db:seed --class=UsersTableSeeder --force

Điều này sẽ chỉ chạy seeder UsersTableSeeder.

Sử Dụng Migrate với Seeder

Nếu bạn muốn chạy migration kèm theo seeder trong môi trường production, bạn có thể sử dụng lệnh migrate:fresh hoặc migrate cùng với cờ --seed và --force:

php artisan migrate:fresh --seed --force
// or 
php artisan migrate --seed --force

Cả hai lệnh trên sẽ chạy migration để tạo lại hoặc cập nhật các bảng trong cơ sở dữ liệu và sau đó chạy seeder.

Chi tiết

Cách sử dụng Soft Deletes trong Laravel

Lợi ích của Soft Deletes

1. Tổng quan về Eloquent Collections

2. Phương thức phổ biến trong Eloquent Collections

Ví dụ:

contains

Ví dụ:

diff

Ví dụ:

except

Ví dụ:

find

Ví dụ:

6. fresh

Ví dụ:

intersect

Ví dụ:

load

Ví dụ:

loadMissing

Ví dụ:

modelKeys

Ví dụ:

makeVisible

Ví dụ:

makeHidden

Ví dụ:

only

Ví dụ:

setVisible

Ví dụ:

setHidden

Ví dụ:

toQuery

Ví dụ:

unique

Ví dụ:

1. Accessors (Bộ lấy dữ liệu)

Cách sử dụng:

Ví dụ:

2. Mutators (Bộ chỉnh sửa dữ liệu)

Cách sử dụng:

Ví dụ:

3. Tùy chỉnh thuộc tính với Accessors và Mutators

Ví dụ:

4. Lợi ích của Accessors và Mutators

5. Các trường hợp sử dụng phổ biến

Kết luận

1. One-to-One Polymorphic Relationships

Ví dụ:

2. One-to-Many Polymorphic Relationships

Ví dụ:

3. Many-to-Many Polymorphic Relationships

Ví dụ:

4. Lợi ích của Polymorphic Relationships

Kết luận

Tổng quan

1. Local Scopes (Phạm vi cục bộ)

Ví dụ:

2. Dynamic Scopes (Phạm vi động)

Ví dụ:

3. Global Scopes (Phạm vi toàn cục)

Ví dụ:

4. Xoá Global Scopes

Ví dụ:

Lợi ích của Eloquent Query Scopes

Kết luận

1. Quan Hệ Many-to-Many

Định Nghĩa Quan Hệ Trong Factory

Tái Sử Dụng Một Mô Hình Đã Tạo

Tóm Tắt

Tạo Factory

Định Nghĩa Factory

Sử Dụng Factory

Sử Dụng Factory Với Seeder

Ví Dụ

Cách Định Nghĩa và Sử Dụng Các Trạng Thái Trong Factory

Khởi Tạo Mô Hình

Áp Dụng Trạng Thái

Ghi Đè Thuộc Tính

`contains`

`diff`

`except`

`find`

6. `fresh`

`intersect`

`load`

`loadMissing`

`modelKeys`

`makeVisible`

`makeHidden`

`only`

`setVisible`

`setHidden`

`toQuery`

`unique`