PHP

laravel form validation

use IlluminateSupportFacadesValidator;

// .... 
  
// On your Store function 
 public function store(Request $request, $id)
// Validation 
        $validator = Validator::make($request, [
            'name' => 'required',
            'username' => 'required|unique:users,username,NULL,id,deleted_at,NULL',
            'email' => 'nullable|email|unique:users,email,NULL,id,deleted_at,NULL',
            'password' => 'required',
        ]);


// Return the message
        if($validator->fails()){
            return response()->json([
                'error' => true,
                'message' => $validator->errors()
            ]);
        }
  // ....
}


// On your Update function 
public function update(Request $request, $id)
    {
		// Validation
        $validator = Validator::make($input, [
            'name' => 'required',
            'username' => 'required|unique:users,username,' . $id. ',id,deleted_at,NULL',
            'email' => 'nullable|email|unique:users,email,' . $id. ',id,deleted_at,NULL',
            'roles' => 'required'
        ]);

        // Return the message
        if($validator->fails()){
            return response()->json([
                'error' => true,
                'msg' => $validator->errors()
            ]);
        }
  // ....
}

validation error message in laravel

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

validation in laravel

use IlluminateSupportFacadesValidator;
 
class PostController extends Controller
{
    /**
     * Store a new blog post.
     *
     * @param  Request  $request
     * @return Response
     */
    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();
        }
 
        // 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...
    }
}

laravel validation in controller

$validator = Validator::make($request->all(), [
            'password' => 'required|string',
            'email' => 'required|string|email',
        ]);

laravel validation

$this->validate([ // 1st array is field rules
  'userid' =>'required|min:3|max:100',
  'username' =>'required|min:3',
  'password' =>'required|max:15|confirmed',
], [ // 2nd array is the rules custom message
  'required' => 'The :attribute field is mandatory.'
], [ // 3rd array is the fields custom name
  'userid' => 'User ID'
]);

laravel validation

use IlluminateSupportFacadesValidator;


$customMessage = [
  'title.max' => "title is too large",
];
$rules = [
  'id' => 'integer|exists:master_advert_bundles',
  'title' => ['required', 'unique:posts', 'max:255'],
  'body' => ['required']
];
$validate = validation($request->all(), $rules);
$validate = Validator::make($request->all(), $rules, $customMessage);
if ($validate->fails()) {
  return  $validate->messages();
}

Laravel Validation

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

validation laravel

/**
 * Store a new blog post.
 *
 * @param  IlluminateHttpRequest  $request
 * @return IlluminateHttpResponse
 */
public function store(Request $request)
{
    $validated = $request->validate([
        'title' => 'required|unique:posts|max:255',
        'body' => 'required',
    ]);
 
    // The blog post is valid...
}

laravel validation types

# <values> = foo,bar,...
# <field> = array field
# <characters> = amount of characters

# accepted					           # active_url
# after:<tomorrow>			           # after_or_equal:<tomorrow>
# alpha						           # alpha_dash
# alpha_num					           # array
# bail 					               # before:<today>
# before_or_equal:<today>              # between:min,max
# boolean					           # confirmed
# date						           # date_equals:<today>
# date_format:<format> 		           # different:<name>
# digits:<value>			           # digits_between:min,max
# dimensions:<min/max_with>	           # distinct
# email						           # ends_with:<values>
# exclude_if:<field>,<value>           # exclude_unless:<field>,<value>
# exists:<table>,<column>	           # file
# filled					           # gt:<field>
# gte:<field>				           # image
# in:<values>				           # in_array:<field>
# integer					           # ip
# ipv4                                 # ipv6  
# json						           # lt:<field>
# lte:<field>       		           # max:<value>
# mimetypes:video/avi,...	           # mimes:jpeg,bmp,png
# min:<value>				           # not_in:<values>
# not_regex:<pattern> 		           # nullable
# numeric					           # password:<auth guard>
# present					           # regex:<pattern>
# required					           # required_if:<field>,<value>
# required_unless:<field>,<value>      # required_with:<fields>
# required_with_all:<fields>	       # required_without:<fields>
# required_without_all:<fields>        # same:<field>
# size:<characters>			           # starts_with:<values>
# string						       # timezone
# unique:<table>,<column>		       # url
# uuid

laravel validation required if

use IlluminateSupportFacadesValidator;
use IlluminateValidationRule;
 
Validator::make($request->all(), [
    'role_id' => Rule::requiredIf($request->user()->is_admin),
]);
 
Validator::make($request->all(), [
    'role_id' => Rule::requiredIf(fn () => $request->user()->is_admin),
]);

Laravel validation

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

sometimes validation in laravel

Docs don't make it clear, But removing required makes it work.

$this->validate($request, [
    'password' => 'sometimes|min:8',
]);

laravel validation on update

public function controllerName(Request $request, $id)
{
    $this->validate($request, [
        "form_field_name" => 'required|unique:db_table_name,db_table_column_name,'.$id
    ]);
    // the rest code
}

laravel validation on update

public function controllerName(Request $request, $id)
{
    $this->validate($request, [
        "form_field_name" => 'required|unique:db_table_name,db_table_column_name,'.$id
    ]);
    // the rest code
}

laravel validation

use IlluminateValidationRule;

Validator::make($data, [
    'email' => [
        'required',
        Rule::unique('users')->ignore($user->id),
    ],
]);

laravel validation messages

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

validate rule on laravel

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

laravel validation

/**
 * Bootstrap any application services.
 *
 * @return void
 */
public function boot()
{
    Validator::extend(...);

    Validator::replacer('foo', function ($message, $attribute, $rule, $parameters) {
        return str_replace(...);
    });
}

laravel validation

'foo.*.id' => 'distinct'

Laravel validation rule

Accepted
Accepted If
Active URL
After (Date)
After Or Equal (Date)
Alpha
Alpha Dash
Alpha Numeric
Array
Bail
Before (Date)
Before Or Equal (Date)
Between
Boolean
Confirmed
Current Password
Date
Date Equals
Date Format
Declined
Declined If
Different
Digits
Digits Between
Dimensions (Image Files)
Distinct
Email
Ends With
Enum
Exclude
Exclude If
Exclude Unless
Exclude With
Exclude Without
Exists (Database)
File
Filled
Greater Than
Greater Than Or Equal
Image (File)
In
In Array
Integer
IP Address
JSON
Less Than
Less Than Or Equal
MAC Address
Max
MIME Types
MIME Type By File Extension
Min
Multiple Of
Not In
Not Regex
Nullable
Numeric
Password
Present
Prohibited
Prohibited If
Prohibited Unless
Prohibits
Regular Expression
Required
Required If
Required Unless
Required With
Required With All
Required Without
Required Without All
Required Array Keys
Same
Size
Sometimes
Starts With
String
Timezone
Unique (Database)
URL
UUID

laravel form validation

php artisan make:controller ValidationController --plain

laravel validation

Validator::extendImplicit('foo', function ($attribute, $value, $parameters, $validator) {
    return $value == 'foo';
});

laravel validation

Rule::unique('users')->ignore($user->id, 'user_id')

laravel validation

Validator::extend('foo', 'FooValidator@validate');

validation.required laravel

9

If it has worked for you before then you should check if you have messages defined in the applangenvalidation.php or by chance you have changed the locale of the app and have not defined the messages for it. There are many possibilities.

laravel validation

Rule::unique('users')->ignore($user)

laravel validation

"foo" => "Your input was invalid!",

"accepted" => "The :attribute must be accepted.",

// The rest of the validation error messages...

laravel validation

$rules = ['name' => 'unique:users,name'];

$input = ['name' => ''];

Validator::make($input, $rules)->passes(); // true