Laravel
Validación

Parámetros

Ejemplo básico

Puede validar los datos de solicitud utilizando el método de validate (disponible en el Controlador base, proporcionado por el rasgo ValidatesRequests ).

Si las reglas pasan, su código seguirá ejecutándose normalmente; sin embargo, si la validación falla, una respuesta de error que contiene los errores de validación se devolverá automáticamente:

• para solicitudes de formulario HTML típicas, el usuario será redirigido a la página anterior, con el formulario manteniendo los valores enviados
• para solicitudes que esperan una respuesta JSON, se generará una respuesta HTTP con el código 422

Por ejemplo, en su UserController , puede estar guardando un nuevo usuario en el método de store , que necesitaría validación antes de guardar.

/**
 * @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
}

En el ejemplo anterior, validamos que el campo de name existe con un valor no vacío. En segundo lugar, verificamos que el campo de email tenga un formato de correo electrónico válido, sea único en la tabla de la base de datos "usuarios" y tenga una longitud máxima de 255 caracteres.

El | El carácter (pipe) combina diferentes reglas de validación para un campo.

En ocasiones, es posible que desee dejar de ejecutar reglas de validación en un atributo después del primer error de validación. Para hacerlo, asigne la regla de bail al atributo:

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

La lista completa de reglas de validación disponibles se puede encontrar en la sección de parámetros a continuación .

Validación de Array

La validación de los campos de entrada de la matriz es muy simple.

Supongamos que tiene que validar cada nombre, correo electrónico y nombre de padre en una matriz dada. Podrías hacer lo siguiente:

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

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

Laravel muestra los mensajes por defecto para la validación. Sin embargo, si desea mensajes personalizados para campos basados ​​en matrices, puede agregar el siguiente código:

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

Tu código final se verá así:

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

Otros enfoques de validación

1) Formulario de Validación de Solicitud

Puede crear una "solicitud de formulario" que puede contener la lógica de autorización, las reglas de validación y los mensajes de error para una solicitud particular en su aplicación.

El comando make:request Artisan CLI genera la clase y la coloca en el directorio app/Http/Requests :

php artisan make:request StoreBlogPostRequest

El método de authorize se puede anular con la lógica de autorización para esta solicitud:

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

El método de las rules se puede anular con las reglas específicas para esta solicitud:

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

El método de messages se puede anular con los mensajes específicos para esta solicitud:

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',
    ];
}

Para validar la solicitud, escriba la clase de solicitud específica en el método del controlador correspondiente. Si la validación falla, se enviará una respuesta de error.

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

2) Creación manual de validadores

Para una mayor flexibilidad, puede crear un validador manualmente y manejar la validación fallida directamente:

<?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) Crear reglas con fluidez.

Ocasionalmente, puede que necesite crear reglas únicas sobre la marcha, ya que trabajar con el método boot() dentro de un Proveedor de Servicios puede ser superior, ya que en Laravel 5.4 puede crear nuevas reglas con fluidez usando la clase de Rule .

Como ejemplo, vamos a trabajar con UserRequest para cuando desee insertar o actualizar un usuario. Por ahora queremos que se requiera un nombre y la dirección de correo electrónico debe ser única. El problema con el uso de la regla unique es que si está editando un usuario, es posible que mantengan el mismo correo electrónico, por lo que debe excluir al usuario actual de la regla. El siguiente ejemplo muestra cómo puede hacer esto fácilmente utilizando la nueva clase de 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)
            ]
        ];
    }
}

Clase de solicitud de formulario único para POST, PUT, PATCH

Siguiendo el ejemplo de 'Validación de solicitud de formulario' , la misma clase de solicitud puede usarse para POST , PUT , PATCH para que no tenga que crear otra clase utilizando las validaciones iguales / similares. Esto es útil si tiene atributos en su tabla que son únicos.

/**
 * 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;
    }
}

A partir de la parte superior, nuestra instrucción de conmutación examinará el tipo de método de la solicitud ( GET , DELETE , POST , PUT , PATCH ).

Dependiendo del método se devolverá la matriz de reglas definida. Si tiene un campo que es único, como el campo de name en el ejemplo, debe especificar un ID particular para que la validación se ignore.

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

Si tiene una clave primaria etiquetada de otra manera que no sea id , especificará la columna de clave primaria como el cuarto parámetro.

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

En este ejemplo, usamos PUT y pasamos a la ruta ( admin/products/{product} ) el valor de la identificación del producto. Así que $this->product será igual al id para ignorar.

Ahora sus reglas de validación PUT|PATCH y POST no necesitan ser las mismas. Define tu lógica que se ajuste a tus necesidades. Esta técnica le permite reutilizar los mensajes personalizados que puede haber definido dentro de la Clase de solicitud de formulario personalizada.

Error de mensajes

Personalizando mensajes de error

Los archivos /resources/lang/[lang]/validation.php contienen los mensajes de error que utilizará el validador. Puede editarlos según sea necesario.

La mayoría de ellos tienen marcadores de posición que se reemplazarán automáticamente al generar el mensaje de error.

Por ejemplo, en 'required' => 'The :attribute field is required.' , el marcador de posición del :attribute será reemplazado por el nombre del campo (alternativamente, también puede personalizar el valor de visualización de cada campo en la matriz de attributes en el mismo archivo).

Ejemplo

configuración del mensaje:

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

reglas:

`email' => `required`

mensaje de error resultante:

"Por favor, informe a su dirección de correo electrónico".

Personalizando mensajes de error dentro de una clase de Solicitud

La clase de Solicitud tiene acceso a un método de messages() que debería devolver una matriz, esto se puede usar para anular mensajes sin tener que ir a los archivos lang. Por ejemplo, si tenemos una validación personalizada de file_exists , puede enviar los siguientes mensajes.

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'
        ];
    }

}

Mostrando mensajes de error

Los errores de validación se transmiten a la sesión y también están disponibles en la variable $errors , que se comparte automáticamente en todas las vistas.

Ejemplo de visualización de los errores en una vista Blade:

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

Reglas de validación personalizadas

Si desea crear una regla de validación personalizada, puede hacerlo, por ejemplo, en el método de boot de un proveedor de servicios, a través de la fachada Validator.

<?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);
        });
    }
}

El método de extend toma una cadena que será el nombre de la regla y una función que, a su vez, pasará el nombre del atributo, el valor que se valida, una matriz de los parámetros de la regla y la instancia del validador, y debe devolver si La validación pasa. En este ejemplo, estamos comprobando si la cadena de valor comienza con una subcadena dada.

El mensaje de error para esta regla personalizada se puede configurar como es habitual en el archivo /resources/lang/[lang]/validation.php , y puede contener marcadores de posición, por ejemplo, para valores de parámetros:

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

El método de replacer toma una cadena que es el nombre de la regla y una función que, a su vez, pasará el mensaje original (antes de reemplazarlo), el nombre del atributo, el nombre de la regla y una matriz de los parámetros de la regla. y debe devolver el mensaje después de reemplazar los marcadores de posición según sea necesario.

Usa esta regla como cualquier otra:

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