Laravel: Gültige Validierung beim Update

Es gibt einen eleganten Weg, dies zu tun. Wenn Sie Ressourcen-Controller verwenden, sieht Ihr Link zur Bearbeitung Ihres Datensatzes folgendermaßen aus:

/ users/{user}/editODER/ users/1/bearbeiten

Und in Ihrer UserRequest sollte die Regel so sein:

public function rules()
{
    return [
        'name' => [
            'required',
            'unique:users,name,' . $this->user
        ],
    ];
}

Oder wenn Ihr Link zum Bearbeiten Ihres Datensatzes folgendermaßen aussieht:

/ Benutzer/Bearbeiten/1

Sie können dies auch versuchen:

public function rules()
{
    return [
        'name' => [
            'required',
            'unique:users,name,' . $this->id
        ],
    ];
}

Nur eine Randbemerkung, die meisten Antworten auf diese Frage beziehen sich auf email_address, während der E-Mail-Feldname in Laravels eingebautem Auth-System nur email ist. Hier ein Beispiel, wie Sie ein eindeutiges Feld überprüfen können, d. H. Eine E-Mail zum Update:

In einer Formularanfrage gefällt Ihnen das:

public function rules()
{
  return [
      'email' => 'required|email|unique:users,email,'.$this->user->id,
  ];
}

Oder wenn Sie Ihre Daten direkt in einer Steuerung überprüfen:

public function update(Request $request, User $user)
{
  $request->validate([
      'email' => 'required|email|unique:users,email,'.$user->id,
  ]);
}

PS: Ich habe einige andere Regeln hinzugefügt, d. H. Erforderliche und E-Mail-Adresse, um dieses Beispiel für Neulinge klarer zu machen.

Wenn ich verstehe, was du willst:

'email' => 'erforderlich | email | unique: Benutzer, email_address'. $ id. ''

In der Modellaktualisierungsmethode sollte zum Beispiel der Parameter $ id with mit dem Parameter erhalten werden.

Entschuldigung für mein schlechtes Englisch. 

Ab Laravel 5.7 funktioniert das hervorragend

use Illuminate\Validation\Rule;

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

Eine eindeutige Regel zwingen, eine gegebene ID zu ignorieren:

public function rules()
{

    switch($this->method())
    {
        case 'GET':
        case 'DELETE':
        {
            return [];
        }
        case 'POST':
        {
            return [
                'name' => 'required|unique:permissions|max:255',
                'display_name' => 'required',
            ];
        }
        case 'PUT':
        case 'PATCH':
        {
            return [                    
                'name' => 'unique:permissions,name,'.$this->get('id').'|max:255',
                'display_name' => 'required',
            ];
        }
        default:break;
    }    
}

$rules = [
    "email" => "email|unique:users, email, {{$id}}, user_id"
];

In Illuminate\Validation\Rules\Unique;

Bei der eindeutigen Überprüfung wird die Zeichenfolgenüberprüfung für das Regelobjekt analysiert

Eindeutige Validierung hat Muster: eindeutig:% s,% s,% s,% s,% s '

Entspricht: Tabellenname, Spalte, Ignorieren, ID-Spalte, Format wheres

/**
 * Convert the rule to a validation string.
 *
 * @return string
 */
public function __toString()
{
    return rtrim(sprintf('unique:%s,%s,%s,%s,%s',
        $this->table,
        $this->column,
        $this->ignore ?: 'NULL',
        $this->idColumn,
        $this->formatWheres()
    ), ',');
}

ich würde das lösen, indem ich so etwas tue

public function rules()
{
    return [
         'name' => 
            'required|min:2|max:255|unique:courses,name,'.\Request::get('id'),
    ];
}

Woher bekommst du die ID aus der Anfrage und gibst sie in der Regel weiter?

eine noch einfachere Lösung, die mit Version 5.2 getestet wurde

in deinem Modell 

// validator rules
public static $rules = array(
    ...
    'email_address' => 'email|required|unique:users,id'
);

Am einfachsten gefunden, funktioniert gut, während ich Laravel 5.2 verwende

public function rules()

{

switch ($this->method()) {
    case 'PUT':
        $rules = [
            'name'                  => 'required|min:3',
            'gender'                => 'required',
            'email'                 => 'required|email|unique:users,id,:id',
            'password'              => 'required|min:5',
            'password_confirmation' => 'required|min:5|same:password',
        ];
        break;

    default:
        $rules = [
            'name'                  => 'required|min:3',
            'gender'                => 'required',
            'email'                 => 'required|email|unique:users',
            'password'              => 'required|min:5',
            'password_confirmation' => 'required|min:5|same:password',
        ];
        break;
}

return $rules;
}

Beim Aktualisieren eines vorhandenen Data Write-Validators wie folgt:

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

Dadurch wird der eindeutige Wert der vorhandenen Benutzer-ID für die jeweilige Spalte übersprungen/ignoriert.

Meine Lösung:

$rules = $user->isDirty('email') ? \User::$rules : array_except(\User::$rules, 'email');

Dann zur Bestätigung:

$validator = \Validator::make(\Input::all(), $rules, \User::$messages);

Die Logik ist, wenn die E-Mail-Adresse im Formular anders ist, müssen wir sie überprüfen. Wenn sich die E-Mail nicht geändert hat, müssen wir sie nicht überprüfen. Entfernen Sie daher die Regel von der Überprüfung.

$ validator = Validator :: make ( array ( 'E-mail') => $ request ['email'], .__ > 'required | email | unique: Benutzer, email,'. $ request ['id'], ));

'email' => 'erforderlich | email | unique: Benutzer, email_address'. $ id.'ID '

Dabei ist ID die primäre ID der Tabelle

Für die Regel unique im Controller - die sich offensichtlich für die Methode store und die Methode update unterscheidet - erstelle ich normalerweise innerhalb des Controllers eine Funktion für rules gibt ein Array von Regeln zurück.

protected function rules($request)
{
    $commonRules = [
        'first_name' => "required",
        'last_name' => "required",
        'password' => "required|min:6|same:password_confirm",
        'password_confirm' => "required:min:6|same:password",
        'password_current' => "required:min:6"
    ];

    $uniqueRules = $request->id

          //update
        ? ['email_address' => ['required', 'email', 'unique:users,email' . $request->get('id')]]

          //store
        : ['email_address' => ['required', 'email', 'unique:users,email']];


    return array_merge($commonRules, $uinqueRules);
}

Dann in den jeweiligen store und update Methoden

$validatedData = $request->validate($this->rules($request));

Dies erspart die Definition von zwei unterschiedlichen Regelsätzen für Speicher- und Aktualisierungsmethoden.

Wenn Sie es sich leisten können, bei der Lesbarkeit Kompromisse einzugehen, kann dies auch der Fall sein

protected function rules($request)
{
    return [
        'first_name' => "required",
        'last_name' => "required",
        'password' => "required|min:6|same:password_confirm",
        'password_confirm' => "required:min:6|same:password",
        'password_current' => "required:min:6",
        'email_address' => ['required', 'email', 'unique:users,email' . $request->id ?: null]
    ];
}

Das habe ich am Ende getan. Ich bin sicher, dass es einen effizienteren Weg gibt, dies zu tun.

Model/User.php

protected $rules = [
    'email_address' => 'sometimes|required|email|unique:users,email_address, {{$id}}',
];

Model/BaseModel.php

public function validate($data, $id = null) {


      $rules = $this->$rules_string;

     //let's loop through and explode the validation rules
     foreach($rules as $keys => $value) {

        $validations = explode('|', $value);

        foreach($validations as $key=>$value) {

            // Seearch for {{$id}} and replace it with $id
            $validations[$key] = str_replace('{{$id}}', $id, $value);

        }
        //Let's create the pipe seperator 
        $implode = implode("|", $validations);
        $rules[$keys] = $implode;

     }
     ....

  }

Ich übergebe die $ user_id zur Validierung im Controller

Controller/UserController.php

public function update($id) { 

   .....

    $user = User::find($user_id);

    if($user->validate($formRequest, $user_id)) {
      //validation succcess 
    } 

    ....


}