Laravel
bevestiging

parameters

Basis voorbeeld

U kunt aanvraaggegevens valideren met behulp van de validate (beschikbaar in de basiscontroller, verstrekt door de eigenschap ValidatesRequests ).

Als de regels passeren, blijft uw code normaal worden uitgevoerd; Als de validatie echter mislukt, wordt er automatisch een foutreactie met de validatiefouten teruggestuurd:

• voor typische HTML-formulierverzoeken wordt de gebruiker omgeleid naar de vorige pagina, waarbij het formulier de ingediende waarden behoudt
• voor verzoeken die een JSON-antwoord verwachten, wordt een HTTP-antwoord met code 422 gegenereerd

In uw UserController kunt u bijvoorbeeld een nieuwe gebruiker store in de store , die moet worden gevalideerd voordat u opslaat.

/**
 * @param  Request  $request
 * @return Response
 */
public function store(Request $request) {
    $this->validate($request, [
        'name' => 'required',
        'email' => 'email|unique:users|max:255'
    ],
    // second array of validation messages can be passed here
    [
        'name.required' => 'Please provide a valid name!',
        'email.required' => 'Please provide a valid email!',
    ]);

    // The validation passed
}

In het bovenstaande voorbeeld, bevestigen we dat de name veld bestaat met niet-lege waarde. Ten tweede controleren we of het email mailveld een geldig e-mailformaat heeft, uniek is in de databasetabel "gebruikers" en maximaal 255 tekens lang is.

De | (pijp) karakter combineert verschillende validatieregels voor één veld.

Soms wilt u misschien stoppen met het uitvoeren van validatieregels voor een kenmerk na de eerste validatiefout. Wijs hiertoe de bail toe aan het kenmerk:

$this->validate($request, [
    'name' => 'bail|required',
    'email' => 'email|unique:users|max:255'
]);

De volledige lijst met beschikbare validatieregels is te vinden in de onderstaande parameterparameters .

Array validatie

Het valideren van matrixinvoervelden is heel eenvoudig.

Stel dat u elke naam, e-mail en vadernaam in een bepaalde array moet valideren. Je zou het volgende kunnen doen:

$validator = \Validator::make($request->all(), [
    'name.*'       => 'required', 
    'email.*'      => 'email|unique:users',
    'fatherName.*' => 'required'
]);

if ($validator->fails()) {
    return back()->withInput()->withErrors($validator->errors());
}

Laravel geeft standaardberichten voor validatie weer. Als u echter aangepaste berichten voor op array gebaseerde velden wilt, kunt u de volgende code toevoegen:

[
    'name.*' => [
        'required' => 'Name field is required',
    ],
    'email.*' => [
        'unique'   => 'Unique Email is required',
    ],
    'fatherName.*' => [
        'required' => 'Father Name required',
    ]
]

Uw uiteindelijke code ziet er als volgt uit:

$validator = \Validator::make($request->all(), [
    'name.*'       => 'required', 
    'email.*'      => 'email|unique:users',
    'fatherName.*' => 'required',
], [
    'name.*'       => 'Name Required',
    'email.*'      => 'Unique Email is required',
    'fatherName.*' => 'Father Name required',
]);

if ($validator->fails()) {
    return back()->withInput()->withErrors($validator->errors());
}

Andere validatiebenaderingen

1) Validatie van formulieraanvraag

U kunt een "formulieraanvraag" maken die de autorisatielogica, validatieregels en foutmeldingen voor een bepaald verzoek in uw toepassing kan bevatten.

De opdracht make:request Artisan CLI genereert de klasse en plaatst deze in de map app/Http/Requests :

php artisan make:request StoreBlogPostRequest

De authorize kan worden overschreven door de autorisatielogica voor dit verzoek:

public function authorize()
{        
    return $this->user()->can('post');
}

De rules methode kan worden overschreven met de specifieke regels voor deze aanvraag:

public function rules()
{
    return [
        'title' => 'required|unique:posts|max:255',
        'body' => 'required',
    ];
}

De messages kan worden opgeheven met de specifieke berichten voor dit verzoek:

public function messages()
{
    return [
        'title.required' => 'A title is required',
        'title.unique' => 'There is another post with the same title',
        'title.max' => 'The title may not exceed :max characters',
        'body.required' => 'A message is required',
    ];
}

Om het verzoek te valideren, typt u gewoon de specifieke verzoekklasse op de overeenkomstige controllermethode. Als de validatie mislukt, wordt een foutreactie teruggestuurd.

public function store(StoreBlogPostRequest $request)
{
    // validation passed
}

2) Handmatig Validators aanmaken

Voor meer flexibiliteit wilt u misschien handmatig een Validator maken en de mislukte validatie direct afhandelen:

<?php    
namespace App\Http\Controllers;

use Validator;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class PostController extends Controller
{
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|unique:posts|max:255',
            'body' => 'required',
        ]);

        if ($validator->fails()) {
            return redirect('post/create')
                    ->withErrors($validator)
                    ->withInput();
        }

        // Store the blog post...
    }
}

2) Vloeiend regels opstellen

Af en toe moet je misschien unieke regels maken terwijl je werkt met de methode boot() binnen een serviceprovider, en vanaf Laravel 5.4 kun je vloeiend nieuwe regels maken met de klasse Rule .

Als voorbeeld gaan we werken met de UserRequest voor wanneer u een gebruiker wilt invoegen of bijwerken. Voor nu willen we een naam verplicht stellen en het e-mailadres moet uniek zijn. Het probleem met het gebruik van de unique regel is dat als u een gebruiker bewerkt, deze mogelijk dezelfde e-mail bewaart, zodat u de huidige gebruiker van de regel moet uitsluiten. Het volgende voorbeeld laat zien hoe u dit eenvoudig kunt doen door de nieuwe Rule .

<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Http\Request;
use Illuminate\Validation\Rule;

class UserRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules(Request $request)
    {
        $id = $request->route()->getParameter('user');

        return [
            'name'           =>  'required',
            
            // Notice the value is an array and not a string like usual
            'email'         =>  [
                'required',
                Rule::unique('users')->ignore($id)
            ]
        ];
    }
}

Eén formulier verzoekklasse voor POST, PUT, PATCH

In navolging van het voorbeeld 'Formulierverzoekvalidatie' , kan dezelfde verzoekklasse worden gebruikt voor POST , PUT , PATCH zodat u geen andere klasse hoeft te maken met dezelfde / vergelijkbare validaties. Dit is handig als u unieke kenmerken in uw tabel hebt.

/**
 * Get the validation rules that apply to the request.
 *
 * @return array
 */
public function rules() {
    switch($this->method()) {
        case 'GET':
        case 'DELETE':
            return [];
        case 'POST':
            return [
                'name'     => 'required|max:75|unique',
                'category' => 'required',
                'price'    => 'required|between:0,1000',
            ];
        case 'PUT':
        case 'PATCH':
            return [
                'name'     => 'required|max:75|unique:product,name,' . $this->product,
                'category' => 'required',
                'price'    => 'required|between:0,1000',
            ];
        default:break;
    }
}

Beginnend vanaf de bovenkant, gaat onze schakelinstructie kijken naar het type methode van de aanvraag ( GET , DELETE , POST , PUT , PATCH ).

Afhankelijk van de methode retourneert de reeks gedefinieerde regels. Als u een veld dat is uniek hebben, zoals de name het veld in het voorbeeld, moet u een bepaalde id voor de validering te negeren opgeven.

'field_name' => 'unique:table_name,column_name,' . $idToIgnore`

Als u een primaire sleutel hebt met iets anders dan id , geeft u de kolom met de primaire sleutel op als vierde parameter.

'field_name' => 'unique:table_name,column_name,' . $idToIgnore . ',primary_key_column'

In dit voorbeeld gebruiken we PUT en geven we de waarde van de product-id door aan de route ( admin/products/{product} ). Dus $this->product is gelijk aan het te negeren id .

Nu hoeven uw PUT|PATCH en POST validatieregels niet hetzelfde te zijn. Definieer uw logica die aan uw eisen voldoet. Met deze techniek kunt u de aangepaste berichten die u mogelijk hebt gedefinieerd binnen de aangepaste formulieraanvraagklasse opnieuw gebruiken.

Foutmeldingen

Foutmeldingen aanpassen

De bestanden / /resources/lang/[lang]/validation.php validation.php bevatten de foutmeldingen die door de validator moeten worden gebruikt. U kunt ze indien nodig bewerken.

De meeste van hen hebben tijdelijke aanduidingen die automatisch worden vervangen bij het genereren van het foutbericht.

In 'required' => 'The :attribute field is required.' , zal de :attribute placeholder van het :attribute worden vervangen door de veldnaam (u kunt ook de weergavewaarde van elk veld in de attributes in hetzelfde bestand aanpassen).

Voorbeeld

bericht configuratie:

'required' => 'Please inform your :attribute.',
//...
'attributes => [
    'email' => 'E-Mail address'
]

reglement:

`email' => `required`

resulterende foutmelding:

"Geef uw e-mailadres door."

Foutmeldingen aanpassen binnen een verzoekklasse

De klasse Request heeft toegang tot een methode messages() die een array zou moeten retourneren, dit kan worden gebruikt om berichten te negeren zonder in de lang-bestanden te hoeven gaan. Als we bijvoorbeeld een aangepaste file_exists validatie hebben, kunt u berichten zoals hieronder gebruiken.

class SampleRequest extends Request {

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules()
    {
        return [
            'image' =>  'required|file_exists'
        ];
    }

    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    public function messages()
    {
        return [
            'image.file_exists' =>  'That file no longer exists or is invalid'
        ];
    }

}

Foutmeldingen weergeven

De validatiefouten worden naar de sessie geflitst en zijn ook beschikbaar in de variabele $errors , die automatisch wordt gedeeld met alle views.

Voorbeeld van het weergeven van de fouten in een Blade-weergave:

@if (count($errors) > 0)
    <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    </div>
@endif

Aangepaste validatieregels

Als u een aangepaste validatieregel wilt maken, kunt u dit bijvoorbeeld doen in de boot van een serviceprovider, via de Validator-gevel.

<?php
namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use Validator;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Validator::extend('starts_with', function($attribute, $value, $parameters, $validator) {
            return \Illuminate\Support\Str::startsWith($value, $parameters[0]);
        });

        Validator::replacer('starts_with', function($message, $attribute, $rule, $parameters) {
            return str_replace(':needle', $parameters[0], $message);
        });
    }
}

De extend heeft een string nodig die de naam van de regel zal zijn en een functie die op zijn beurt de naam van het attribuut, de waarde die wordt gevalideerd, een array van de regelparameters en de validatorinstantie wordt doorgegeven en moet teruggeven of de validatie is geslaagd. In dit voorbeeld controleren we of de waardereeks begint met een gegeven substring.

Het foutbericht voor deze aangepaste regel kan zoals gebruikelijk worden ingesteld in het bestand / /resources/lang/[lang]/validation.php

'starts_with' => 'The :attribute must start with :needle.'

De replacer neemt een tekenreeks die de naam van de regel is en een functie die op zijn beurt het oorspronkelijke bericht (vóór vervanging), de naam van het kenmerk, de naam van de regel en een reeks regelparameters doorgeeft, en moet het bericht retourneren na het vervangen van de tijdelijke aanduidingen indien nodig.

Gebruik deze regel als elke andere:

$this->validate($request, [
    'phone_number' => 'required|starts_with:+'
]);