Authentifizierung mit 2 verschiedenen Tabellen

Beim Versuch, dieses problem zu lösen mich, ich fand einen viel einfacheren Weg. Ich im Grunde erstellt eine benutzerdefinierte ServiceProvider, um ersetzen Sie die Standard-Auth ein, die dient als eine factory-Klasse für Auth, und ermöglicht es Ihnen, mehrere Instanzen für mehrere login-Typen. Auch ich steckte Sie alle in einem Paket, die Sie hier finden: https://github.com/ollieread/multiauth

Es ist ziemlich einfach, um wirklich zu nutzen, ersetzen Sie einfach die AuthServiceProvider in app/config/app.php mit Ollieread\Multiauth\MultiauthServiceProvider, dann ändern app/config/auth.php Aussehen:

return array(

    'multi' => array(
        'account' => array(
            'driver' => 'eloquent',
            'model' => 'Account'
        ),
        'user' => array(
            'driver' => 'database',
            'table' => 'users'
        )
    ),

    'reminder' => array(

        'email' => 'emails.auth.reminder',

        'table' => 'password_reminders',

        'expire' => 60,

    ),

);

Jetzt können Sie nur verwenden, Auth die gleiche Weise wie zuvor, aber mit einem kleinen Unterschied:

Auth::account()->attempt(array(
    'email'     => $attributes['email'],
    'password'  => $attributes['password'],
));
Auth::user()->attempt(array(
    'email'     => $attributes['email'],
    'password'  => $attributes['password'],
));
Auth::account()->check();
Auth::user()->check();

Ermöglicht es auch, Sie eingeloggt sein, wie mehrere Benutzer-Typen gleichzeitig die Voraussetzung für ein Projekt, das ich arbeiten war. Hoffe es hilft jemand anderem als mir.

UPDATE - 27/02/2014

Für diejenigen von Euch, die gerade erst über diese Antwort, ich habe gerade vor kurzem Hinzugefügt-Unterstützung für Erinnerungen, die zugegriffen werden kann, die in der gleichen Fabrik Stil Weg.

InformationsquelleAutor der Antwort ollieread

Ich hatte das gleiche problem gestern auch, und ich landete eine viel einfachere Lösung.

Meine Anforderungen, wenn von 2 verschiedenen Tabellen in zwei verschiedenen Datenbanken. Ein Tisch war für admins, die andere war für den normalen Benutzer. Auch, jeder Tisch hatte seine eigene Art und Weise der Vermischung. Ich landete mit dem folgenden Code (auch als gist auf Github: https://gist.github.com/Xethron/6790029)

Erstellen Sie eine neue UserProvider. Ich rief mir MultiUserProvider.php

<?php

//app/libraries/MultiUserProvider.php

use Illuminate\Auth\UserProviderInterface,
    Illuminate\Auth\UserInterface,
    Illuminate\Auth\GenericUser;

class MultiUserProvider implements UserProviderInterface {

  protected $providers;

    public function __construct() {

        //This should be moved to the config later...
        //This is a list of providers that can be used, including
        //their user model, hasher class, and hasher options...
        $this->providers = array(
            'joomla' => array(
                'model' => 'JoomlaUser',
                'hasher' => 'JoomlaHasher',
                )
            'another' => array(
                'model' => 'AnotherUser',
                'hasher' => 'AnotherHasher',
                'options' => array(
                    'username' => 'empolyee_number',
                    'salt' => 'salt',
                    )
                ),
            );
    }
    /**
     * Retrieve a user by their unique identifier.
     *
     * @param  mixed  $identifier
     * @return \Illuminate\Auth\UserInterface|null
     */
    public function retrieveById($identifier)
    {
        //Returns the current provider from the session.
        //Should throw an error if there is none...
        $provider = Session::get('user.provider');

        $user = $this->createModel($this->providers[$provider]['model'])->newQuery()->find($identifier);

        if ($user){
            $user->provider = $provider;
        }

        return $user;
    }

    /**
     * Retrieve a user by the given credentials.
     *
     * @param  array  $credentials
     * @return \Illuminate\Auth\UserInterface|null
     */
    public function retrieveByCredentials(array $credentials)
    {
        //First we will add each credential element to the query as a where clause.
        //Then we can execute the query and, if we found a user, return it in a
        //Eloquent User "model" that will be utilized by the Guard instances.

        //Retrieve the provider from the $credentials array.
        //Should throw an error if there is none...
        $provider = $credentials['provider'];

        $query = $this->createModel($this->providers[$provider]['model'])->newQuery();

        foreach ($credentials as $key => $value)
        {
            if ( ! str_contains($key, 'password') && ! str_contains($key, 'provider'))
                $query->where($key, $value);
        }

        $user = $query->first();

        if ($user){
            Session::put('user.provider', $provider);
            $user->provider = $provider;
        }

        return $user;
    }

    /**
     * Validate a user against the given credentials.
     *
     * @param  \Illuminate\Auth\UserInterface  $user
     * @param  array  $credentials
     * @return bool
     */
    public function validateCredentials(UserInterface $user, array $credentials)
    {
        $plain = $credentials['password'];

        //Retrieve the provider from the $credentials array.
        //Should throw an error if there is none...
        $provider = $credentials['provider'];

        $options = array();

        if (isset($this->providers[$provider]['options'])){
            foreach ($this->providers[$provider]['options'] as $key => $value) {
                $options[$key] = $user->$value;
            }
        }

        return $this->createModel($this->providers[$provider]['hasher'])
            ->check($plain, $user->getAuthPassword(), $options);
    }

    /**
     * Create a new instance of a class.
     *
     * @param string $name Name of the class
     * @return Class
     */
    public function createModel($name)
    {
        $class = '\\'.ltrim($name, '\\');

        return new $class;
    }

}

Dann erzählte ich Laravel über meine UserProvider durch hinzufügen der folgenden Zeilen an den Anfang der meine app/start/global.php Datei.

//app/start/global.php

//Add the following few lines to your global.php file
Auth::extend('multi', function($app) {
    $provider =  new \MultiUserProvider();

    return new \Illuminate\Auth\Guard($provider, $app['session']);
});

Und dann habe ich gesagt, Laravel, um meine Benutzer-provider anstelle von EloquentUserProvider in app/config/auth.php

'driver' => 'multi',

Wenn ich jetzt authentifizieren, ich mache es so:

Auth::attempt(array(
    'email' => $email,
    'password' => $password,
    'provider'=>'joomla'
    )
)

Klasse wäre dann verwenden Sie die joomlaUser Modell, mit dem joomlaHasher, und keine Optionen für die hasher... Wenn die mit 'anderen' Anbieter, so wird es unter anderem Optionen für die hasher.

Diese Klasse wurde gebaut, für das, was ich erforderlich, kann aber leicht geändert werden, um suite Ihre Bedürfnisse.

PS: Stellen Sie sicher, dass der autoloader finden MultiUserProvider, sonst funktioniert es nicht.

InformationsquelleAutor der Antwort Xethron