SamAsEnd\NeedsAutoRehash\FromAttemptPasswordReHasher

Complexity

Total Complexity

14

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	passwordNeedsRehash()	0	3	1
A	passwordUpdateRehash()	0	3	1
A	getUserProviderName()	0	7	1
A	validCredentials()	0	3	1
A	handle()	0	6	4
A	getUserProviderWithPasswordUpdate()	0	16	4
A	__construct()	0	12	1
A	getHashingOptions()	0	5	1

<?php

namespace SamAsEnd\NeedsAutoRehash;

use Illuminate\Auth\CreatesUserProviders;
use Illuminate\Auth\DatabaseUserProvider;
use Illuminate\Auth\EloquentUserProvider;
use Illuminate\Auth\Events\Attempting;
use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Contracts\Auth\Factory as AuthContract;
use Illuminate\Contracts\Config\Repository as ConfigContract;
use Illuminate\Contracts\Container\BindingResolutionException;
use Illuminate\Contracts\Container\Container as ContainerContract;
use Illuminate\Contracts\Hashing\Hasher as HashContract;
use SamAsEnd\NeedsAutoRehash\Providers\DatabaseUserProviderWithPasswordUpdate;
use SamAsEnd\NeedsAutoRehash\Providers\EloquentUserProviderWithPasswordUpdate;
use SamAsEnd\NeedsAutoRehash\Providers\ProviderWithPasswordUpdate;

class FromAttemptPasswordReHasher
{
    use CreatesUserProviders;

    /** @var ContainerContract */
    private $app;

    /** @var AuthContract */
    protected $auth;

    /** @var HashContract */
    private $hash;

    /** @var ConfigContract */
    private $config;

    /** @var ProviderWithPasswordUpdate */
    protected $provider;

    public function __construct(
        ContainerContract $container,
        AuthContract $auth,
        HashContract $hash,
        ConfigContract $config
    ) {
        $this->app = $container;
        $this->auth = $auth;
        $this->hash = $hash;
        $this->config = $config;

        $this->provider = $this->getUserProviderWithPasswordUpdate();
    }

    protected function getUserProviderWithPasswordUpdate(): ProviderWithPasswordUpdate
    {
        $provider = $this->createUserProvider($this->getUserProviderName());

        if ($provider instanceof DatabaseUserProvider) {
            return new DatabaseUserProviderWithPasswordUpdate($provider);
        }

        if ($provider instanceof EloquentUserProvider) {
            return new EloquentUserProviderWithPasswordUpdate($provider);
        }

        try {
            return $this->app->make(ProviderWithPasswordUpdate::class);
        } catch (BindingResolutionException $e) {
            throw new UnexpectedProviderException('ProviderWithPasswordUpdate could not be found.', $e);
        }
    }

    public function handle(Attempting $event)
    {
        $user = $this->provider->retrieveByCredentials($event->credentials);

        if (!is_null($user) && $this->validCredentials($event) && $this->passwordNeedsRehash($user)) {
            $this->passwordUpdateRehash($user, $event->credentials['password']);
        }
    }

    protected function validCredentials(Attempting $attempting): bool
    {
        return $this->auth->guard($attempting->guard)->validate($attempting->credentials);
    }

    protected function passwordNeedsRehash(Authenticatable $user)
    {
        return $this->hash->needsRehash($user->getAuthPassword(), $this->getHashingOptions());
    }

    protected function passwordUpdateRehash(Authenticatable $user, $password)
    {
        $this->provider->updatePassword($user, $password);
    }

    protected function getUserProviderName()
    {
        $guard = $this->config->get('auth.defaults.guard');

        return
            $this->getDefaultUserProvider() ??
            $this->config->get('auth.guards.'.$guard.'.provider');
    }

    protected function getHashingOptions()
    {
        $driver = $this->config->get('hashing.driver');

        return $this->config->get('hashing.'.$driver);
    }
}