Học Laravel – Bài 22: Validation

use App\Http\Controllers\PostController;
 
Route::get('/post/create', [PostController::class, 'create']);
Route::post('/post', [PostController::class, 'store']);

<?php
 
namespace App\Http\Controllers;
 
use App\Http\Controllers\Controller;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\View\View;
 
class PostController extends Controller
{
    /**
     * Show the form to create a new blog post.
     */
    public function create(): View
    {
        return view('post.create');
    }
 
    /**
     * Store a new blog post.
     */
    public function store(Request $request): RedirectResponse
    {
        $validated = $request->validate([
            'title' => 'required|unique:posts|max:255',
            'body' => 'required',
        ]);
 
        // The blog post is valid...
        // Save post
 
        return response()->noContent();
    }
}

$request->validate([
    'title' => 'bail|required|unique:posts|max:255',
    'body' => 'required',
]);

$request->validate([
    'title' => 'required|unique:posts|max:255',
    'author.name' => 'required',
    'author.description' => 'required',
]);

<!-- /resources/views/post/create.blade.php -->
 
<h1>Create Post</h1>
 
@if ($errors->any())
    <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    </div>
@endif
 
<!-- Create Post Form -->

<input id="title"
    type="text"
    name="title"
    class="@error('title') is-invalid @enderror">
 
@error('title')
    <div class="alert alert-danger">{{ $message }}</div>
@enderror

<input class="@error('title', 'post') is-invalid @enderror">

$title = $request->old('title');

<input type="text" name="title" value="{{ old('title') }}">

$request->validate([
    'title' => 'required|unique:posts|max:255',
    'body' => 'required',
    'publish_at' => 'nullable|date',
]);

{
    "message": "The team name must be a string. (and 4 more errors)",
    "errors": {
        "team_name": [
            "The team name must be a string.",
            "The team name must be at least 1 characters."
        ],
        "authorization.role": [
            "The selected authorization.role is invalid."
        ],
        "users.0.email": [
            "The users.0.email field is required."
        ],
        "users.2.email": [
            "The users.2.email must be a valid email address."
        ]
    }
}

php artisan make:request StorePostRequest

/**
 * Get the validation rules that apply to the request.
 *
 * @return array<string, \Illuminate\Contracts\Validation\Rule|array|string>
 */
public function rules(): array
{
    return [
        'title' => 'required|unique:posts|max:255',
        'body' => 'required',
    ];
}

/**
 * Store a new blog post.
 */
public function store(StorePostRequest $request): Response
{
    // The incoming request is valid...
 
    // Retrieve the validated input data...
    // Truy xuất toàn bộ dữ liệu đã được validate
    $validated = $request->validated();
 
    // Retrieve a portion of the validated input data...
    // Truy xuất 1 phần dữ liệu
    $validated = $request->safe()->only(['name', 'email']);
    $validated = $request->safe()->except(['name', 'email']);
 
    // Store the blog post...
 
    return response()->noContent();
}

use Illuminate\Validation\Validator;
 
/**
 * Configure the validator instance.
 */
public function withValidator(Validator $validator): void
{
    // Gọi sau khi validate
    $validator->after(function (Validator $validator) {
        // do it
    });
}

protected $stopOnFirstFailure = true;

protected $redirect = '/dashboard';

// hoặc dùng route:
protected $redirectRoute = 'dashboard';

public function authorize(): bool
{
    $comment = Comment::find($this->route('comment'));
 
    return $comment && $this->user()->can('update', $comment);
}

public function messages(): array
{
    return [
        'title.required' => 'A title is required',
        'body.required' => 'A message is required',
    ];
}

public function attributes(): array
{
    return [
        'email' => 'email address',
    ];
}

protected function prepareForValidation(): void
{
    $this->merge([
        'slug' => Str::slug($this->slug),
    ]);
}

protected function passedValidation(): void
{
    $this->replace(['name' => 'Taylor']);
}

namespace App\Http\Controllers;
 
use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Validator;
 
class PostController extends Controller
{
    /**
     * Store a new blog post.
     */
    public function store(Request $request): Response
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|unique:posts|max:255',
            'body' => 'required',
        ]);
 
        if ($validator->fails()) {
            return redirect('post/create')
                        ->withErrors($validator)
                        ->withInput();
        }
 
        // Retrieve the validated input...
        $validated = $validator->validated();
 
        // Retrieve a portion of the validated input...
        $validated = $validator->safe()->only(['name', 'email']);
        $validated = $validator->safe()->except(['name', 'email']);
 
        // Store the blog post...
 
        return response()->noContent();
    }
}

if ($validator->stopOnFirstFailure()->fails()) {
    // ...
}

Validator::make($request->all(), [
    'title' => 'required|unique:posts|max:255',
    'body' => 'required',
])->validate();

Validator::make($request->all(), [
    'title' => 'required|unique:posts|max:255',
    'body' => 'required',
])->validateWithBag('post');

return redirect('register')->withErrors($validator, 'login');

{{ $errors->login->first('email') }}

$validator = Validator::make($input, $rules, $messages = [
    'required' => 'The :attribute field is required.',
]);

$messages = [
    'same' => 'The :attribute and :other must match.',
    'size' => 'The :attribute must be exactly :size.',
    'between' => 'The :attribute value :input is not between :min - :max.',
    'in' => 'The :attribute must be one of the following types: :values',
];

$messages = [
    'email.required' => 'We need to know your email address!',
];

$validator = Validator::make($input, $rules, $messages, [
    'email' => 'email address',
]);

use Illuminate\Support\Facades;
use Illuminate\Validation\Validator;
 
$validator = Facades\Validator::make(/* ... */);
 
$validator->after(function (Validator $validator) {
    if ($this->somethingElseIsInvalid()) {
        $validator->errors()->add(
            'field', 'Something is wrong with this field!'
        );
    }
});
 
if ($validator->fails()) {
    // ...
}

// sử dụng request:
$validated = $request->validated();

// nếu sử dụng validator:
$validated = $validator->validated();

$validated = $request->safe()->only(['name', 'email']);
 
$validated = $request->safe()->except(['name', 'email']);
 
$validated = $request->safe()->all();

// Validated data may be iterated...
foreach ($request->safe() as $key => $value) {
    // ...
}
 
// Validated data may be accessed as an array...
$validated = $request->safe();
 
$email = $validated['email'];

$validated = $request->safe()->merge(['name' => 'Taylor Otwell']);

$collection = $request->safe()->collect();

$errors = $validator->errors();
 
echo $errors->first('email');

foreach ($errors->get('email') as $message) {
    // ...
}

foreach ($errors->get('attachments.*') as $message) {
    // ...
}

foreach ($errors->all() as $message) {
    // ...
}

if ($errors->has('email')) {
    // ...
}