Pourquoi est-ce que j'obtiens ce message "These credentials do not match our records" après une authentification Custom User Providers dans Laravel ?

Question

Je suis assez novice en matière de PHP et en Laravel .

Je suis ce tutoriel pour mettre en place un fournisseur d'utilisateurs personnalisé :

https://blog.georgebuckingham.com/laravel-52-auth-custom-user-providers-drivers/

J'utilise Laravel 5.3 version.

J'explique brièvement ce dont j'ai besoin : mon Laravel n'est qu'une application frontale, toute la logique commerciale, y compris l'authentification de l'utilisateur, est exécutée par une application de type Application back-end Java qui expose Services web REST .

Effectuer un appel à :

http://localhost:8080/Extranet/login

et en passant le nom d'utilisateur et le mot de passe comme authentification de base, j'obtiens une réponse JSON comme celle-ci qui représente l'utilisateur connecté :

{
  "userName": "Painkiller",
  "email": "painkiller@gmail.com",
  "enabled": true
}

Dans mon application Laravel, je dois donc effectuer cet appel et analyser le résultat de l'appel précédent. Objet JSON pour générer l'objet authentifié dans la session de l'application frontale.

J'ai mis en œuvre les 4 étapes du tutoriel précédent et je pense que j'ai correctement remplacé le fournisseur d'utilisateur par mon fournisseur d'utilisateur personnalisé qui effectue l'appel au service web, voici mon code :

Ce n'est pas encore terminé mais cela semble fonctionner correctement car la soumission du formulaire de connexion Laravel de l'application http://localhost:8000/login page il entre dans le retrieveByCredentials(array $credentials) et l'appel à mon service web REST est correctement effectué.

Pour l'instant, je n'utilise pas l'identifiant inséré mais je le simule uniquement parce que je suis paresseux et que je ne veux pas insérer le nom d'utilisateur et le mot de passe dans le formulaire de connexion à chaque fois que je fais un test...

Lire aussi ce tutoriel officiel :

https://laravel.com/docs/5.3/authentication#adding-custom-user-providers

il est dit que :

Les retrieveByCredentials reçoit l'ar transmis à la méthode Auth::attempt de la méthode de l'analyse de l'information lors d'une tentative de application. La méthode doit ensuite "interroger" la mémoire persistante sous-jacente pour trouver l'utilisateur correspondant à ces données. sous-jacente pour trouver l'utilisateur correspondant à ces informations d'identification. T exécute une requête avec une condition "where" sur $credentials['username']. La méthode devrait alors r d'Authenticatable . Cette méthode ne doit pas tenter de de valider ou d'authentifier un mot de passe.

Les validateCredentials méthode doit comparer les $u $credentials pour authentifier l'utilisateur. . Par exemple, cette méthode devrait probablement utiliser Hash::check pour comparer la valeur de $user->getAuthPassword() à la valeur de $credentials['password']. Cette méthode devrait renvoyer true ou false selon que le mot de passe est valide ou non. mot de passe est valide.

Ainsi, par souci de simplicité, le retrieveByCredentials() renvoie une méthode Utilisateur (qui met en œuvre l'objet Authentique interface).

Voici mon code :

<?php

namespace App\Authentication;

use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Contracts\Auth\UserProvider as IlluminateUserProvider;
use GuzzleHttp\Client;
use function GuzzleHttp\json_encode;
use function GuzzleHttp\json_decode;
use Illuminate\Support\Facades\Log;

class UserProvider implements IlluminateUserProvider
{
    public function retrieveById($identifier)
    {
        // TODO: Implement retrieveById() method.
        \Log::info('retrieveById START');

    }

    public function retrieveByToken($identifier, $token)
    {
        // TODO: Implement retrieveByToken() method.
        \Log::info('retrieveByToken START');
    }

    public function updateRememberToken(Authenticatable $user, $token)
    {
        // TODO: Implement updateRememberToken() method.
        \Log::info('updateRememberToken START');
    }

    public function retrieveByCredentials(array $credentials) {

        // TODO: Implement retrieveByCredentials() method.

        \Log::info('retrieveByCredentials START');
        \Log::info('INSERTED USER CREDENTIAL: '.$credentials['email'] . ' ' .$credentials['password']);

        $client = new Client(); //GuzzleHttp\Client

        $response = $client->get('http://localhost:8080/Extranet/login',
            [
                'auth' => [
                    'nobili.andrea@gmail.com',
                    'pswd'
                ]
            ]);

        $dettagliLogin = json_decode($response->getBody());

        \Log::info('response: '.(json_encode($dettagliLogin)));

        $user = new User('Pippo', 'pippo@google.com', true);

        \Log::info('USER: '.(json_encode($user)));

        return $user;

    }

    public function validateCredentials(Authenticatable $user, array $credentials)
    {
        // TODO: Implement validateCredentials() method.
        \Log::info('validateCredentials START');
    }

}

et voici le code de l'article retourné Utilisateur (comme vous pouvez le voir, il contient les informations obtenues par l'objet JSON de mon service web) :

<?php

namespace App\Authentication;

use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Support\Facades\Log;

class User implements Authenticatable {

    private $username;
    private $email;
    private $enabled;

    /**
     * User constructor.
     * @param $username
     * @param $email
     * @param $enabled
     */
    public function __construct($username, $email, $enabled)
    {
        $this->username = $username;
        $this->email = $email;
        $this->enabled = $enabled;
    }

    /**
     * @return string
     */
    public function getAuthIdentifierName() {
        // Return the name of unique identifier for the user (e.g. "id")

    }

    /**
     * @return mixed
     */
    public function getAuthIdentifier() {
        // Return the unique identifier for the user (e.g. their ID, 123)
    }

    /**
     * @return string
     */
    public function getAuthPassword() {
        // Returns the (hashed) password for the user
    }

    /**
     * @return string
     */
    public function getRememberToken() {
        // Return the token used for the "remember me" functionality
    }

    /**
     * @param  string $value
     * @return void
     */
    public function setRememberToken($value) {
        // Store a new token user for the "remember me" functionality
    }

    /**
     * @return string
     */
    public function getRememberTokenName() {
        // Return the name of the column / attribute used to store the "remember me" token
    }

    /**
     * @return mixed
     */
    public function getUsername()
    {
        return $this->username;
    }

    /**
     * @param mixed $username
     */
    public function setUsername($username)
    {
        $this->username = $username;
    }

    /**
     * @return mixed
     */
    public function getEmail()
    {
        return $this->email;
    }

    /**
     * @param mixed $email
     */
    public function setEmail($email)
    {
        $this->email = $email;
    }

    /**
     * @return mixed
     */
    public function getEnabled()
    {
        return $this->enabled;
    }

    /**
     * @param mixed $enabled
     */
    public function setEnabled($enabled)
    {
        $this->enabled = $enabled;
    }

}

Ainsi, mon retrieveByCredentials() renvoie cette méthode Utilisateur contenant les informations de l'utilisateur simulé, mais je rencontre le problème suivant :

après la soumission du formulaire de connexion, le retrieveByCredentials() est exécuté et le Utilisateur est renvoyée mais je n'accède pas à la page d'index et je vois ce message d'erreur : Ces références ne correspondent pas à nos dossiers.

D'après ce que j'ai compris, ce message d'erreur devrait faire référence à l'authentification standard de Laravel (sur la base de données), mais je ne suis absolument pas sûr de cette affirmation.

Comment cela est-il possible ? Je crée un fournisseur d'utilisateurs personnalisé dans lequel mon retrieveByCredentials() met en œuvre ma logique personnalisée.

Qu'est-ce qui ne va pas ? Que me manque-t-il ? Comment puis-je essayer de résoudre ce problème et d'obtenir l'accès après ma Fournisseurs d'utilisateurs personnalisés login ?

Answer 1

Vous devrez fournir le nom d'utilisateur et le mot de passe de votre formulaire dans la demande. Vous pouvez le faire de manière classique en php ou avec ajax. Quoi qu'il en soit, vous aurez besoin du code suivant dans votre fonction backend.

Pour connecter un utilisateur à l'aide d'informations personnalisées, vous pouvez utiliser Auth::attempt. Par exemple :

if(Auth::attempt([
 'username' => $request->username, 
 'password' => $request->password
])){

   # success -> redirect user to home page.
   return redirect()->route('home');

}else{
   # return error.
   $errors = new MessageBag(['password' => ['Email and/or password invalid.']]);

   return redirect()->back()->with(['errors' => $errors]); // For PHP.
   return response()->json(['errors' => $errors]); // For Ajax.
}

Vous pouvez également utiliser la méthode loginUsingId. Mais vous devez d'abord trouver l'utilisateur dans votre base de données.

$user = User::where('email', $request->email)->first();

if($user){
 # Check for password match.
 if($request->password == $user->getAuthPassword()){
   Auth::loginUsingId($user->id, true) /*You will have to get user id from database
                                       or to know somehow what user id is. 
                                       Second param (true) is for remembering user.*/
 }
}
else{
  # User does not exist. return error.
}

N'oubliez pas d'inclure des classes dans votre classe.

use App\Auth;
use Illuminate\Support\MessageBag;