So überprüfen Sie die aktuelle, neue, und neues Passwort Bestätigung in Laravel 5?

Ich habe das Kennwort route, Ansicht und Methode in UserController@getProfilePassword und UserController@postProfilePassword

In dem moment, wenn ich füllen Sie das new_password Feld, es wird ein Hashwert und übermittelt, korrekt in der Datenbank, dann kann ich mit dem neuen Passwort einloggen.

Aber ich muss in der Lage sein zu überprüfen, die new_password und new_password_confirm um sicherzustellen, dass Sie identisch sind und überprüfen Sie den Benutzer das aktuelle Kennwort als gut.

Wie kann ich das tun?

EDIT: ich Hinzugefügt $this->validate zu der Methode, aber jetzt bekomme ich immer den Fehler The password confirmation confirmation does not match. auch wenn Sie nicht übereinstimmen, wie ich bin, mit einem einfachen Passwort. Auch ich denke, dass ich brauchen, um zu überprüfen, die gegen das aktuelle Kennwort manuell als validator wird es nicht tun für mich.

public function getProfilePassword(Request $request) {
    return view('profile/password', ['user' => Auth::user()]);
}

public function postProfilePassword(Request $request) {
    $user = Auth::user();

    $this->validate($request, [
        'old_password'          => 'required',
        'password'              => 'required|min:4',
        'password_confirmation' => 'required|confirmed'
    ]);

    $user->password = Hash::make(Input::get('new_password'));
    $user->save();
}

- Und dies ist die Ansicht

<form action="{{ route('profile/updatepassword') }}" method="post" enctype="multipart/form-data">
    <div class="form-group">
          <label for="name">Current Password</label>
          <input type="password" name="old_password" class="form-control" id="old_password">
    </div>
    <div class="form-group">
          <label for="name">Password</label>
          <input type="password" name="password" class="form-control" id="password">
    </div>
    <div class="form-group">
          <label for="name">New Password</label>
          <input type="password" name="password_confirmation" class="form-control" id="password_confirmation">
    </div>
    <button type="submit" class="btn btn-primary">Change Password</button>
    <input type="hidden" value="{{ Session::token() }}" name="_token">
 </form>

InformationsquelleAutor Halnex | 2016-06-01

43

Gibt es eine Hash::check() - Funktion, die Ihnen erlaubt zu prüfen, ob das alte Passwort vom Benutzer eingegeben korrekt ist oder nicht.

usage
```
if (Hash::check("param1", "param2")) {
 //add logic here
}

param1 - user password that has been entered on the form
param2 - old password hash stored in database
```
wird true zurückgegeben, wenn alte Passwort korrekt eingegeben wurden, und Sie können fügen Sie Ihre Logik entsprechend

für new_password und new_confirm_password gleich sind, können Sie Ihre Validierung in form Anfrage wie
```
'new_password' => 'required',
'new_confirm_password' => 'required|same:new_password'
```
- Vielen Dank für diese nützlichen Tipps. Ich war mit confirmation statt same:new_password - gerade geändert und es hat funktioniert. Und ich werde mit der Hash::check() überprüfen Sie das aktuelle Kennwort ein.
- froh, dass es geholfen 🙂
- Ein weiterer guter trick, um in der Bestätigungs-Feld: die confirmed Gültigkeitsregel <link>. Ihre eigentliche Regel wäre nur eine Zeile wie diese: 'new_password' => 'required|confirmed'. Und in der Bestätigungs-Feld name sollte new_password_confirmation.
InformationsquelleAutor Sid
6

Wenn du nur die Funktionalität eine benutzerdefinierte Regel einmal in der gesamten Anwendung, die Sie verwenden möglicherweise eine Schließung statt einem Regel-Objekt. Die Closure erhält das Attribut name, der Wert für das Attribut, und ein $fail-callback, die aufgerufen werden soll, wenn die Validierung fehlschlägt
```
$request->validate([
    'new_password' => 'required|confirmed|min:4',
    'current_password' => ['required', function ($attribute, $value, $fail) use ($user) {
        if (!\Hash::check($value, $user->password)) {
            return $fail(__('The current password is incorrect.'));
        }
    }],
]);
```
https://laravel.com/docs/5.6/validation#using-closures

InformationsquelleAutor Steve
4

Können Sie dies tun, indem Sie eine benutzerdefinierte Gültigkeitsregel (für dieses Beispiel verwende ich current_password und new_password wie die Eingabe von Namen).

Setzen Sie diese in AppServiceProvider::boot():
```
Validator::extend('current_password', function ($attribute, $value, $parameters, $validator) {
    $user = User::find($parameters[0]);

    return $user && Hash::check($value, $user->password);
});
```
Nun können Sie die folgenden in Ihrem controller:
```
$user = auth()->user(); //or pass an actual user here

$this->validate($request, [
    'current_password' => 'required_with:new_password|current_password,'.$user->id,
]);
```
- Hatte zu ändern, um 'required_with:new_password|current_password:'.$user->id (Doppelpunkt statt Komma), mit Laravel 5.6
InformationsquelleAutor kjdion84
2

Können Sie hinzufügen confirmed als es zu bestätigen alte Passwort ein.
Und 'required|confirmed' Sie ändern zu 'required|same:password' zu vergleichen password und password confirmation

'old_password' => 'required|confirmed', 'password' => 'required|min:4', 'password_confirmation' => 'required|same:password'

Glück!
- Das bestätigt unter Validierung muss ein entsprechendes Feld von foo_confirmation. Zum Beispiel, wenn das Feld unter Validierung ist durch ein Passwort, eine passende password_confirmation Feld muss vorhanden sein, in der Eingabe.
- Das ist falsch laut der Dokumentation: laravel.com/docs/5.1/validation#rule-confirmed
InformationsquelleAutor Sanji

Eine komplette Funktion, die überprüfen alles. Sie müssen nur senden Sie old_password, new_password und confirm_password.

public function changePassword(Request $request) {
            try {
                $valid = validator($request->only('old_password', 'new_password', 'confirm_password'), [
                    'old_password' => 'required|string|min:6',
                    'new_password' => 'required|string|min:6|different:old_password',
                    'confirm_password' => 'required_with:new_password|same:new_password|string|min:6',
                        ], [
                    'confirm_password.required_with' => 'Confirm password is required.'
                ]);

                if ($valid->fails()) {
                    return response()->json([
                                'errors' => $valid->errors(),
                                'message' => 'Faild to update password.',
                                'status' => false
                                    ], 200);
                }
    //           Hash::check("param1", "param2")
    //           param1 - user password that has been entered on the form
    //           param2 - old password hash stored in database
                if (Hash::check($request->get('old_password'), Auth::user()->password)) {
                    $user = User::find(Auth::user()->id);
                    $user->password = (new BcryptHasher)->make($request->get('new_password'));
                    if ($user->save()) {
                        return response()->json([
                                    'data' => [],
                                    'message' => 'Your password has been updated',
                                    'status' => true
                                        ], 200);
                    }
                } else {
                    return response()->json([
                                'errors' => [],
                                'message' => 'Wrong password entered.',
                                'status' => false
                                    ], 200);
                }
            } catch (Exception $e) {
                return response()->json([
                            'errors' => $e->getMessage(),
                            'message' => 'Please try again',
                            'status' => false
                                ], 200);
            }
        }

InformationsquelleAutor PHP Worm...

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.