Erdemkeren\TemporaryAccess\TemporaryAccessService

Complexity

Total Complexity

16

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	33	4
A	check()	0	6	2
A	setPasswordGenerator()	0	4	1
A	create()	0	11	3
A	retrieveByPlainText()	0	4	1
A	retrieveByCipherText()	0	11	2
A	addPasswordGenerator()	0	4	1
A	getPasswordGenerator()	0	4	2

<?php

/*
 * @copyright 2018 Hilmi Erdem KEREN
 * @license MIT
 */

namespace Erdemkeren\TemporaryAccess;

use Illuminate\Contracts\Auth\Authenticatable;

/**
 * Class TemporaryAccessService.
 */
final class TemporaryAccessService
{
    /**
     * The password generator manager.
     *
     * @var PasswordGeneratorManagerInterface
     */
    private $manager;

    /**
     * The encryptor implementation.
     *
     * @var EncryptorInterface
     */
    private $encryptor;

    /**
     * The password length.
     *
     * @var int
     */
    private $passwordLength;

    /**
     * The default temporary access password generator.
     *
     * @var string
     */
    private $defaultGenerator;

    /**
     * The password generator.
     *
     * @var callable
     */
    private $passwordGenerator;

    /**
     * The name of the token class being used
     * by the temporary access service.
     *
     * @var string
     */
    private $tokenClass;

    /**
     * TemporaryAccessService constructor.
     *
     * @param PasswordGeneratorManagerInterface $manager
     * @param EncryptorInterface                $encryptor
     * @param string                            $defaultGenerator
     * @param int                               $passwordLength
     * @param string                            $tokenClass
     */
    public function __construct(
        PasswordGeneratorManagerInterface $manager,
        EncryptorInterface $encryptor,
        string $defaultGenerator,
        int $passwordLength,
        string $tokenClass
    ) {
        $this->manager = $manager;
        $this->encryptor = $encryptor;
        $this->passwordLength = $passwordLength;
        $this->defaultGenerator = $defaultGenerator;

        if (!class_exists($tokenClass)) {
            throw new \RuntimeException(
                "The token implementation [{$tokenClass}] could not be found."
            );
        }

        $generatorReflection = new \ReflectionClass($tokenClass);
        if (!$generatorReflection->isInstantiable()) {
            throw new \RuntimeException(
                "The token implementation [{$tokenClass}] is not instantiable."
            );
        }

        if (! is_subclass_of($tokenClass, TokenInterface::class)) {
            throw new \TypeError(
                'The token class should be an instance of '.TokenInterface::class

The call to TypeError::__construct() has too many arguments starting with 'The token class should be an instance of ' . \Erdemkeren\TemporaryAccess\TokenInterface::class.

            );
        }

        $this->tokenClass = $tokenClass;
    }

    /**
     * Check the temporary access of the authenticable
     * with the given cipher text.
     *
     * @param mixed  $authenticableId
     * @param string $token
     *
     * @return bool
     */
    public function check($authenticableId, string $token): bool
    {
        $token = $this->retrieveByCipherText($authenticableId, $token);

        return (bool) $token && ! $token->expired();
    }

    /**
     * Set the active password generator of the temporary access service.
     *
     * @param string $name
     */
    public function setPasswordGenerator(string $name): void
    {
        $this->passwordGenerator = $this->manager->get($name);
    }

    /**
     * Create a new temporary access token.
     *
     * @param Authenticatable|mixed $authenticatableId
     * @param int                   $length
     *
     * @return Token
     */
    public function create($authenticatableId, ?int $length = null): TokenInterface
    {
        $plainText = $this->getPasswordGenerator()($length ?: $this->passwordLength);
        $cipherText = $this->encryptor->encrypt($plainText);

        if ($authenticatableId instanceof Authenticatable) {
            $authenticatableId = $authenticatableId->getAuthIdentifier();
        }

        return $this->tokenClass::create($authenticatableId, $cipherText, $plainText);

The method create cannot be called on $this->tokenClass (of type string).

    }

    /**
     * Retrieve the token of the authenticable
     * by the given plain text.
     *
     * @param mixed  $authenticableId
     * @param string $plainText
     *
     * @return null|TokenInterface
     */
    public function retrieveByPlainText($authenticableId, string $plainText): ?TokenInterface
    {
        return $this->retrieveByCipherText($authenticableId, $this->encryptor->encrypt($plainText));
    }

    /**
     * Retrieve the token of the authenticable
     * by the given cipher text.
     *
     * @param mixed  $authenticableId
     * @param string $cipherText
     *
     * @return null|TokenInterface
     */
    public function retrieveByCipherText($authenticableId, string $cipherText): ?TokenInterface
    {
        if ($authenticableId instanceof Authenticatable) {
            $authenticableId = $authenticableId->getAuthIdentifier();
        }

        return $this->tokenClass::retrieveByAttributes([

The method retrieveByAttributes cannot be called on $this->tokenClass (of type string).

            'authenticable_id' => $authenticableId,
            'cipher_text'      => $cipherText,
        ]);
    }

    /**
     * Add a new password generator implementation.
     *
     * @param string                                     $name
     * @param callable|PasswordGeneratorInterface|string $generator
     */
    public function addPasswordGenerator(string $name, $generator): void
    {
        $this->manager->register($name, $generator);
    }

    /**
     * Get the active password generator.
     *
     * @return callable
     */
    private function getPasswordGenerator(): callable
    {
        return $this->passwordGenerator ?: $this->passwordGenerator = $this->manager->get($this->defaultGenerator);
    }
}