How to use Tailwind Css grid generator

14.09.2024

Author:	ADMIN

Tailwind CSS là một framework CSS tiện dụng, giúp các lập trình viên xây dựng giao diện người dùng một cách nhanh chóng và dễ dàng nhờ việc sử dụng các lớp tiện ích (utility classes). Một trong những tính năng mạnh mẽ của Tailwind CSS là Grid Layout, cho phép tạo ra các bố cục phức tạp với sự linh hoạt cao.

Hôm nay, DevEliteBlog sẽ giới thiệu một công cụ hữu ích dành cho các lập trình viên muốn nhanh chóng tạo ra mã lưới (grid) bằng Tailwind CSS mà không cần phải nhớ toàn bộ cú pháp. Điều này giúp đơn giản hóa quá trình cấu hình bố cục grid, cho phép bạn trực quan hóa và tùy chỉnh các thông số cho grid trước khi xuất ra mã Tailwind CSS tương ứng.

Truy cập trang web: Vào trang tailwindgen.com.
Chọn cấu trúc grid: Bạn có thể chọn số cột (columns) mong muốn cho bố cục của mình. Tailwindgen cung cấp một giao diện đồ họa, nơi bạn có thể chọn số lượng cột và hàng trong grid của mình.
Tùy chỉnh khoảng cách (gap): Tailwindgen cung cấp các tùy chọn để điều chỉnh khoảng cách giữa các cột và hàng (grid-gap), một yếu tố quan trọng để tạo ra sự phân chia rõ ràng giữa các phần tử trong lưới.
Tùy chỉnh kích thước cột: Bạn có thể tùy chỉnh chiều rộng các cột bằng cách chọn các tùy chọn như col-span, cho phép cột chiếm nhiều hay ít không gian hơn so với các cột khác.
Xem trước và xuất mã: Sau khi đã tùy chỉnh cấu trúc grid theo ý muốn, bạn có thể xem trước kết quả ngay trên trang. Sau đó, chỉ cần sao chép mã Tailwind CSS được tạo ra từ công cụ và dán vào dự án của mình.

Với công cụ như Tailwindgen.com, bạn có thể tối ưu hóa quy trình làm việc khi sử dụng Tailwind CSS để xây dựng các bố cục lưới hiệu quả và đẹp mắt.

Chi tiết

How to use Laravel Reverb

07.09.2024

Author:	ADMIN

Laravel Reverb là một máy chủ WebSocket chính thức cho các ứng dụng Laravel, cung cấp khả năng giao tiếp theo thời gian thực giữa máy khách và máy chủ một cách liền mạch.

Laravel Reverb có nhiều tính năng hấp dẫn, bao gồm:

Tốc độ và khả năng mở rộng.
Hỗ trợ hàng nghìn kết nối đồng thời.
Tích hợp với các tính năng phát sóng hiện có của Laravel.
Tương thích với Laravel Echo.
Tích hợp và triển khai hàng đầu với Laravel Forge.

Trong hướng dẫn này, tôi sẽ hướng dẫn bạn cách sử dụng Laravel Reverb để phát triển một ứng dụng Laravel thời gian thực. Bạn sẽ học về các kênh, sự kiện, phát sóng, và cách sử dụng Laravel Reverb để tạo ra các ứng dụng nhanh chóng và thời gian thực trong Laravel.

Hơn nữa, bạn sẽ học cách thêm thông báo thời gian thực vào ứng dụng Laravel Reverb của mình!

Cài đặt một ứng dụng Laravel mới
```
composer create-project laravel/laravel laravel-reverb-chat
```
Chuyển đến thư mục dự án của bạn:
```
cd laravel-reverb-chat
```
Installing Laravel Reverb
Cài đặt Laravel Reverb bằng cách chạy câu lệnh sau:
```
php artisan install:broadcasting
npm install --save laravel-echo pusher-js
```
Chú ý: các lựa chọn default

Sau khi bạn đã cài đặt Reverb, bạn có thể chỉnh sửa cấu hình của nó từ tệp `config / reverb.php`. Để thiết lập kết nối đến Reverb, một bộ thông tin đăng nhập ứng dụng Reverb phải được trao đổi giữa máy khách và máy chủ. Những thông tin đăng nhập này được cấu hình trên máy chủ và được sử dụng để xác minh yêu cầu từ máy khách. Bạn có thể xác định những thông tin đăng nhập này bằng cách sử dụng các biến môi trường sau:
```
BROADCAST_DRIVER=reverb
REVERB_APP_ID=my-app-id
REVERB_APP_KEY=my-app-key
REVERB_APP_SECRET=my-app-secret
```
Running Server
Bạn có thể khởi chạy máy chủ Reverb bằng cách sử dụng command reverb:start:
```
php artisan reverb:start
```
Mặc định, máy chủ Reverb sẽ được khởi động tại 0.0.0.0:8080, điều này làm cho nó có thể truy cập từ tất cả các giao diện mạng. Nếu bạn muốn thiết lập một máy chủ hoặc cổng cụ thể, bạn có thể sử dụng các tùy chọn --host và --port khi khởi động máy chủ.
```
php artisan reverb:start --host=127.0.0.1 --port=9000
```
Bạn cũng có thể xác định các biến môi trường REVERB_SERVER_HOST và REVERB_SERVER_PORT trong tệp cấu hình .env của ứng dụng của bạn.

Setup Database
Mở tệp .env của bạn và điều chỉnh cài đặt để thiết lập cơ sở dữ liệu của bạn. Dưới đây là một ví dụ sử dụng MySQL để đơn giản hóa:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD=

Đối với bản demo này, chúng ta sẽ tạo năm phòng được xác định trước. Hãy bắt đầu bằng cách tạo một migration cho một bảng rooms.

php artisan make:model Room --migration

Để đơn giản hóa, chỉ cần tạo trường name cho model này và chạy migration.

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

php artisan migrate

Sau đó, seed dữ liệu cho database với 5 room. Tạo một seeder:

php artisan make:seeder RoomsTableSeeder

<?php

namespace Database\Seeders;

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

class RoomsTableSeeder extends Seeder
{
    /**
     * Run the database seeds.
     */
    public function run(): void
    {
        DB::table('rooms')->insert([
            ['name' => 'Room 1'],
            ['name' => 'Room 2'],
            ['name' => 'Room 3'],
            ['name' => 'Room 4'],
            ['name' => 'Room 5'],
        ]);
    }
}

Run seeder:

php artisan db:seed --class=RoomsTableSeeder

Tạo Event
Trong thư mục app/Events, tạo một file mới tên là MessageSent.php. File này chịu trách nhiệm phát sóng các tin nhắn mới tới các phòng chat cụ thể. Dưới đây là mẫu cơ bản:

php artisan make:event MessageSent

class MessageSent implements ShouldBroadcast
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public $userName;
    public $roomId;
    public $message;

    public function __construct($userName, $roomId, $message)
    {
        $this->userName = $userName;
        $this->roomId = $roomId;
        $this->message = $message;
    }

    public function broadcastOn() : Channel
    {

        return new Channel('chat.' . $this->roomId);
    }

    public function broadcastWith()
    {
        return [
            'userName' => $this->userName,
            'message' => $this->message,
        ];
    }
}

Tạo Pages
Trong dự án này, chúng ta sẽ có hai trang: một trang để hiển thị danh sách các phòng và một trang cho từng phòng chat riêng biệt. Chúng ta sẽ bắt đầu bằng cách tạo các template Blade để hiển thị các phòng. Đặt tên các view này là index.blade.php và chat.blade.php và lưu chúng trong thư mục rooms dưới resources/views. Tiếp theo, chúng ta sẽ tạo một controller và một route để điều hướng tới các trang này.

php artisan make:view rooms/index
php artisan make:view rooms/chat

index.blade.php

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>Chat Rooms</title>
</head>

<body>
    <div id="app">
        <h1>Chat Rooms</h1>
        <ul>
            @foreach ($rooms as $room)
                <li>
                    <a href="{{ route('rooms.show', $room->id) }}">Join {{ $room->name }}</a>
                </li>
            @endforeach
        </ul>
    </div>
</body>

</html>

chat.blade.php

Thiết lập một form cơ bản để hiển thị các tin nhắn và một trường nhập liệu đơn giản để gửi tin nhắn. Đảm bảo rằng bạn đã import Echo và Pusher vào file app.js.

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Chat Room: {{ $room->name }}</title>
    @vite(['resources/css/app.css'])
    @vite(['resources/js/app.js'])
</head>

<body>
    <div id="app">
        <h2>Chat Room: {{ $room->name }}</h2>
        <div id="messages"
            style="border: 1px solid #ccc; margin-bottom: 10px; padding: 10px; height: 300px; overflow-y: scroll;">
            <!-- Messages will be displayed here -->
        </div>
        <input type="text" id="messageInput" placeholder="Type your message here..." autofocus>
        <button onclick="sendMessage()">Send</button>
    </div>

    <script>
        document.addEventListener('DOMContentLoaded', function() {
            const roomId = "{{ $room->id }}";
            Echo.channel(`chat.${roomId}`)
                .listen('MessageSent', (e) => {
                    const messages = document.getElementById('messages');
                    const messageElement = document.createElement('div');
                    messageElement.innerHTML = `<strong>${e.userName}:</strong> ${e.message}`;
                    messages.appendChild(messageElement);
                    messages.scrollTop = messages.scrollHeight; // Scroll to the bottom
                });
        })

        function sendMessage() {
            const messageInput = document.getElementById('messageInput');
            const message = messageInput.value;
            messageInput.value = ''; // Clear input
            const roomId = "{{ $room->id }}"
            fetch(`/rooms/${roomId}/message`, {
                method: 'POST',
                headers: {
                    'X-CSRF-TOKEN': '{{ csrf_token() }}',
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    message: message
                })
            }).catch(error => console.error('Error:', error));
        }
    </script>
</body>

</html>

app.js

import Echo from 'laravel-echo';

import Pusher from 'pusher-js';
window.Pusher = Pusher;

window.Echo = new Echo({
    broadcaster: 'reverb',
    key: import.meta.env.VITE_REVERB_APP_KEY,
    wsHost: import.meta.env.VITE_REVERB_HOST,
    wsPort: import.meta.env.VITE_REVERB_PORT ?? 80,
    wssPort: import.meta.env.VITE_REVERB_PORT ?? 443,
    forceTLS: (import.meta.env.VITE_REVERB_SCHEME ?? 'https') === 'https',
    enabledTransports: ['ws', 'wss'],
});

Tiếp theo hãy tạo Controller

php artisan make:controller RoomsController

<?php

namespace App\Http\Controllers;

use App\Models\Room;

class RoomsController extends Controller
{
    public function index()
    {
        $rooms = Room::all();
        return view('rooms.index', [
            'rooms' => $rooms
        ]);
    }

    public function show(Room $room)
    {
        return view('rooms.chat', [
            'roomId' => $room->id,
            'room' => $room,
            'messages' => []
        ]);
    }
}

Để đơn giản, hãy tạo một endpoint postMessage và thêm nó vào web.php.

php artisan make:controller ChatController

<?php

namespace App\Http\Controllers;

use App\Events\MessageSent;
use Illuminate\Http\Request;
use Illuminate\Support\Str;

class ChatController extends Controller
{
    public function postMessage(Request $request, $roomId)
    {
        $userName = 'User_' . Str::random(4);
        $messageContent = $request->input('message');
        MessageSent::dispatch($userName, $roomId, $messageContent);
        return response()->json(['status' => 'Message sent successfully.']);
    }
}

routes/web.php

Route::get('/rooms', [RoomsController::class, 'index'])->name('rooms.index');
Route::get('/rooms/{room}', [RoomsController::class, 'show'])->name('rooms.show');
Route::post('/rooms/{roomId}/message', [ChatController::class, 'postMessage'])->name('api.rooms.message.post');

Run Project
Để chạy dự án Laravel, chúng ta cần thực thi các lệnh sau:
- Khởi động Laravel:
```
php artisan serve
```
- Khởi động frontend:
```
npm run dev
```
- Bắt đầu queue:
```
php artisan queue:listen
```
- Run Reverb:
```
php artisan reverb:start
```

Để biết thông tin chi tiết hơn, bạn có thể kiểm tra tài liệu hướng dẫn chính thức của Laravel Reverb. Chúc các bạn thành công

Chi tiết

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

Middleware

01.08.2024

Author:	ADMIN

Middleware cung cấp một cơ chế lọc các yêu cầu HTTP vào ứng dụng của bạn. Ví dụ, Laravel bao gồm một middleware kiểm tra người dùng của bạn có xác thực hay chưa. Nếu người dùng không xác thực, middleware sẽ chuyển hướng người dùng đến trang đăng nhập. Tuy nhiên, nếu người dùng đã xác thực, middleware sẽ cho phép yêu cầu tiếp tục vào ứng dụng.

Dưới đây là các bước để định nghĩa middleware trong Laravel:

1. Tạo Middleware

Để tạo middleware, bạn có thể sử dụng lệnh Artisan sau:

php artisan make:middleware CheckAge

Lệnh này sẽ tạo ra một lớp middleware mới tại app/Http/Middleware/CheckAge.php. Trong lớp middleware này, bạn chỉ cần định nghĩa phương thức handle.

2. Định nghĩa Middleware

Trong lớp middleware, bạn có thể viết logic để kiểm tra hoặc xử lý yêu cầu. Ví dụ, dưới đây là cách middleware kiểm tra độ tuổi của người dùng:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class CheckAge
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle(Request $request, Closure $next)
    {
        if ($request->age <= 200) {
            return redirect('home');
        }

        return $next($request);
    }
}

Trong ví dụ này, nếu độ tuổi của người dùng nhỏ hơn hoặc bằng 200, middleware sẽ chuyển hướng họ về trang chủ. Nếu không, yêu cầu sẽ tiếp tục được xử lý.

3. Đăng ký Middleware

Sau khi tạo middleware, bạn cần đăng ký nó trong ứng dụng. Có hai cách để đăng ký middleware: toàn cục và nhóm.

3.1. Middleware Global

Để đăng ký middleware toàn cục, bạn thêm nó vào thuộc tính $middleware trong app/Http/Kernel.php:

protected $middleware = [
    // Other middleware
    \App\Http\Middleware\CheckAge::class,
];

3.2. Middleware Groups

Để đăng ký middleware nhóm, bạn thêm nó vào thuộc tính $middlewareGroups trong app/Http/Kernel.php. Ví dụ, bạn có thể thêm middleware vào nhóm web:

protected $middlewareGroups = [
    'web' => [
        // Other middleware
        \App\Http\Middleware\CheckAge::class,
    ],

    'api' => [
        'throttle:api',
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],
];

3.3. Middleware Định Tuyến

Bạn có thể gán middleware cho các tuyến cụ thể bằng cách sử dụng phương thức middleware trong file routes/web.php hoặc routes/api.php:

Route::get('admin/profile', function () {
    // Only authenticated users may enter...
})->middleware('auth', 'check.age');

4. Middleware Tham Số

Middleware cũng có thể chấp nhận tham số. Ví dụ, bạn có thể tạo middleware để kiểm tra vai trò của người dùng:

public function handle($request, Closure $next, $role)
{
    if (! $request->user()->hasRole($role)) {
        // Redirect...
    }

    return $next($request);
}

Sau đó, bạn có thể gán middleware này cho một tuyến với tham số:

Route::put('post/{id}', function ($id) {
    // Update the post...
})->middleware('role:editor');

# Middleware and Responses

Middleware có thể thực hiện các tác vụ trước hoặc sau khi chuyển tiếp yêu cầu vào sâu hơn trong ứng dụng. Ví dụ, middleware sau đây sẽ thực hiện một số tác vụ trước khi yêu cầu được xử lý bởi ứng dụng:

Ví dụ Middleware

Dưới đây là một ví dụ về middleware thực hiện một số tác vụ trước khi xử lý yêu cầu:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class BeforeMiddleware
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle(Request $request, Closure $next)
    {
        // Thực hiện một số tác vụ trước khi yêu cầu được xử lý
        // Ví dụ: kiểm tra điều kiện hoặc ghi log
        if ($request->user() && $request->user()->isBlocked()) {
            return response('Your account is blocked.', 403);
        }

        // Chuyển tiếp yêu cầu vào sâu hơn trong ứng dụng
        return $next($request);
    }
}

Thực hiện tác vụ sau khi xử lý yêu cầu

Middleware cũng có thể thực hiện các tác vụ sau khi yêu cầu đã được xử lý. Để làm điều này, bạn chỉ cần thêm logic sau khi gọi hàm $next($request):

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class AfterMiddleware
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle(Request $request, Closure $next)
    {
        // Xử lý yêu cầu
        $response = $next($request);

        // Thực hiện một số tác vụ sau khi yêu cầu đã được xử lý
        // Ví dụ: thêm header vào phản hồi
        $response->header('X-Header-One', 'Header Value');

        return $response;
    }
}

Trong ví dụ trên, middleware sẽ thêm một header vào phản hồi sau khi yêu cầu đã được xử lý bởi ứng dụng.

# Sorting Middleware

Trong Laravel, bạn có thể chỉ định thứ tự thực hiện của các middleware. Việc sắp xếp này có thể hữu ích khi bạn cần một middleware phải được thực thi trước hoặc sau một middleware khác. Laravel cung cấp một cách dễ dàng để sắp xếp thứ tự của các middleware thông qua thuộc tính $middlewarePriority trong lớp App\Http\Kernel.

Định nghĩa Thứ Tự Middleware

Để sắp xếp thứ tự thực hiện của middleware, bạn chỉ cần thêm thuộc tính $middlewarePriority vào lớp App\Http\Kernel và liệt kê các middleware theo thứ tự bạn muốn chúng được thực thi:

<?php

namespace App\Http;

use Illuminate\Foundation\Http\Kernel as HttpKernel;

class Kernel extends HttpKernel
{
    /**
     * The application's global HTTP middleware stack.
     *
     * These middleware are run during every request to your application.
     *
     * @var array
     */
    protected $middleware = [
        // Danh sách các middleware toàn cục
    ];

    /**
     * The application's route middleware groups.
     *
     * @var array
     */
    protected $middlewareGroups = [
        'web' => [
            // Danh sách các middleware nhóm 'web'
        ],

        'api' => [
            // Danh sách các middleware nhóm 'api'
        ],
    ];

    /**
     * The application's route middleware.
     *
     * These middleware may be assigned to groups or used individually.
     *
     * @var array
     */
    protected $routeMiddleware = [
        // Danh sách các route middleware
    ];

    /**
     * The priority-sorted list of middleware.
     *
     * This forces non-global middleware to always be in the given order.
     *
     * @var array
     */
    protected $middlewarePriority = [
        \App\Http\Middleware\FirstMiddleware::class,
        \App\Http\Middleware\SecondMiddleware::class,
        \Illuminate\Session\Middleware\StartSession::class,
        \Illuminate\View\Middleware\ShareErrorsFromSession::class,
        \App\Http\Middleware\AnotherMiddleware::class,
        // Thêm các middleware khác theo thứ tự bạn muốn
    ];
}

Trong ví dụ trên, FirstMiddleware sẽ được thực thi trước SecondMiddleware, và AnotherMiddleware sẽ được thực thi sau StartSession và ShareErrorsFromSession.

Ví Dụ Về Middleware

Dưới đây là ví dụ về hai middleware mà bạn muốn sắp xếp thứ tự thực hiện:

FirstMiddleware:

<?php

namespace App\Http\Middleware;

use Closure;

class FirstMiddleware
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, Closure $next)
    {
        // Logic của FirstMiddleware
        return $next($request);
    }
}

SecondMiddleware:

<?php

namespace App\Http\Middleware;

use Closure;

class SecondMiddleware
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, Closure $next)
    {
        // Logic của SecondMiddleware
        return $next($request);
    }
}

Kết Hợp Với Route

Sau khi định nghĩa thứ tự của middleware, bạn có thể gán chúng cho các tuyến hoặc nhóm tuyến trong tệp routes/web.php hoặc routes/api.php:

// routes/web.php

Route::middleware(['first', 'second'])->group(function () {
    Route::get('/', 'HomeController@index');
});

// Hoặc sử dụng trực tiếp trong các tuyến:
Route::get('/example', 'ExampleController@index')->middleware('first', 'second');

# Terminable Middleware

Trong Laravel, middleware có thể được chia thành hai loại chính: middleware thực thi trong quá trình xử lý yêu cầu và middleware thực thi sau khi phản hồi đã được gửi đến client. Middleware thuộc loại thứ hai được gọi là "terminable middleware".

Terminable middleware cho phép bạn thực hiện các công việc sau khi phản hồi đã được gửi về phía client, chẳng hạn như ghi log hoặc thực hiện các tác vụ tốn thời gian mà bạn không muốn làm chậm thời gian phản hồi của ứng dụng.

Tạo Middleware Terminable

Để tạo một terminable middleware, bạn cần tạo một middleware như bình thường và thêm phương thức terminate vào lớp middleware đó. Phương thức terminate sẽ được tự động gọi sau khi phản hồi đã được gửi về phía client.

Tạo Middleware bằng Artisan:

php artisan make:middleware LogAfterRequest

Định nghĩa Middleware với phương thức terminate:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class LogAfterRequest
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle(Request $request, Closure $next)
    {
        // Thực hiện các công việc trước khi xử lý yêu cầu
        return $next($request);
    }

    /**
     * Handle tasks after the response has been sent to the client.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Symfony\Component\HttpFoundation\Response  $response
     * @return void
     */
    public function terminate(Request $request, Response $response)
    {
        // Thực hiện các công việc sau khi phản hồi đã được gửi đến client
        \Log::info('Request has been completed.');
    }
}

Đăng Ký Middleware

Bạn cần đăng ký middleware trong tệp app/Http/Kernel.php để Laravel có thể nhận diện và sử dụng middleware đó:

Thêm middleware vào thuộc tính $middleware hoặc $routeMiddleware của lớp Kernel:

// app/Http/Kernel.php

protected $middleware = [
    // Các middleware khác
    \App\Http\Middleware\LogAfterRequest::class,
];

Nếu bạn muốn middleware này chỉ áp dụng cho một số tuyến cụ thể, bạn có thể thêm vào thuộc tính $routeMiddleware:

// app/Http/Kernel.php

protected $routeMiddleware = [
    // Các route middleware khác
    'log.after' => \App\Http\Middleware\LogAfterRequest::class,
];

Sử dụng middleware trong tuyến của bạn:

// routes/web.php

Route::get('/example', 'ExampleController@index')->middleware('log.after');

Kết Hợp với Các Tác Vụ Sau Phản Hồi

Bạn có thể sử dụng terminable middleware để thực hiện các tác vụ sau khi phản hồi đã được gửi đến client, chẳng hạn như:

Ghi log các yêu cầu và phản hồi
Gửi email
Thực hiện các tác vụ bảo trì
Đặt lại các kết nối hoặc phiên làm việc

Ví dụ, bạn có thể sử dụng phương thức terminate để ghi lại log các thông tin về yêu cầu và phản hồi:

public function terminate(Request $request, Response $response)
{
    \Log::info('Request URL: ' . $request->fullUrl());
    \Log::info('Response Status: ' . $response->status());
}

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

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

Showing 13 to 24 of 44 results

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`