Erdemkeren\TemporaryAccess\Token

Complexity

Total Complexity

31

Size/Duplication

Total Lines	325
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	23	5
A	__toString()	0	4	1
A	authenticableId()	0	4	1
A	cipherText()	0	4	1
A	plainText()	0	4	1
A	createdAt()	0	4	1
A	updatedAt()	0	4	1
A	expiryTime()	0	4	1
A	expiresAt()	0	4	1
A	timeLeft()	0	4	1
A	expired()	0	4	1
A	revoke()	0	4	1
A	invalidate()	0	6	1
A	extend()	0	8	2
A	refresh()	0	6	1
A	create()	0	11	1
A	retrieveByAttributes()	0	21	3
A	toNotification()	0	4	1
A	persist()	0	32	3
A	getNow()	0	4	1
A	getTable()	0	4	1
A	getDefaultExpiryTime()	0	4	1

<?php

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

namespace Erdemkeren\TemporaryAccess;

use Carbon\Carbon;
use Illuminate\Support\Facades\DB;
use Illuminate\Notifications\Notification;

/**
 * Class Token.
 */
class Token implements TokenInterface
{
    /**
     * The attributes of the token.
     *
     * @var array
     */
    public $attributes = [
        'authenticable_id' => null,
        'plain_text'       => null,
        'expiry_time'      => null,
        'cipher_text'      => null,
        'created_at'       => null,
        'updated_at'       => null,
    ];

    /**
     * Token constructor.
     *
     * @param int|mixed|string $authenticableId
     * @param string           $cipherText
     * @param null|string      $plainText
     * @param null|int         $expiryTime
     * @param null|Carbon      $createdAt
     * @param null|Carbon      $updatedAt
     */
    public function __construct(
        $authenticableId,
        string $cipherText,
        ?string $plainText = null,
        ?int    $expiryTime = null,
        ?Carbon $createdAt = null,
        ?Carbon $updatedAt = null
    ) {
        $now = $this->getNow();

        if (null === $authenticableId) {
            throw new \LogicException(
                'The unique identifier of token owner shall not be null.'
            );
        }

        $this->attributes['authenticable_id'] = $authenticableId;
        $this->attributes['plain_text'] = $plainText;
        $this->attributes['cipher_text'] = $cipherText;
        $this->attributes['created_at'] = $createdAt ?: $now;
        $this->attributes['updated_at'] = $updatedAt ?: $now;
        $this->attributes['expiry_time'] = null === $expiryTime ? $this->getDefaultExpiryTime() : $expiryTime;
    }

    /**
     * Convert the token to string.
     *
     * @return string
     */
    public function __toString(): string
    {
        return $this->cipherText();
    }

    /**
     * Get the unique identifier of the authenticable
     * who owns the token.
     *
     * @return mixed
     */
    public function authenticableId()
    {
        return $this->attributes['authenticable_id'];
    }

    /**
     * Get the token as cipher text.
     *
     * @return string
     */
    public function cipherText(): string
    {
        return $this->attributes['cipher_text'];
    }

    /**
     * Get the token as plain text.
     *
     * @return null|string
     */
    public function plainText(): ?string
    {
        return $this->attributes['plain_text'];
    }

    /**
     * Get the date token created.
     *
     * @return Carbon
     */
    public function createdAt(): Carbon
    {
        return clone $this->attributes['created_at'];
    }

    /**
     * Get the last update date of the token.
     *
     * @return Carbon
     */
    public function updatedAt(): Carbon
    {
        return clone $this->attributes['updated_at'];
    }

    /**
     * Get the expiry time of the token in seconds.
     *
     * @return int
     */
    public function expiryTime(): int
    {
        return $this->attributes['expiry_time'];
    }

    /**
     * Get the date time the token will expire.
     *
     * @return Carbon
     */
    public function expiresAt(): Carbon
    {
        return (clone $this->createdAt())->addSeconds($this->expiryTime());
    }

    /**
     * Get the validity time left for the token.
     *
     * @return int
     */
    public function timeLeft(): int
    {
        return $this->getNow()->diffInSeconds($this->expiresAt(), false);
    }

    /**
     * Determine if the token is expired or not.
     *
     * @return bool
     */
    public function expired(): bool
    {
        return $this->timeLeft() <= 0;
    }

    /**
     * Alias for invalidate.
     */
    public function revoke(): void
    {
        $this->invalidate();
    }

    /**
     * Invalidate the token.
     */
    public function invalidate(): void
    {
        $this->attributes['expiry_time'] = 0;

        $this->persist();
    }

    /**
     * Extend the validity of the token.
     *
     * @param null|int $seconds
     *
     * @return bool
     */
    public function extend(?int $seconds = null): bool
    {
        $seconds = null === $seconds ? $this->getDefaultExpiryTime() : $seconds;

        $this->attributes['expiry_time'] += $seconds;

        return $this->persist();
    }

    /**
     * Refresh the token.
     *
     * @return bool
     */
    public function refresh(): bool
    {
        return $this->extend(
            $this->getNow()->diffInSeconds($this->updatedAt())
        );
    }

    /**
     * Create a new token.
     *
     * @param $authenticableId
     * @param string      $cipherText
     * @param null|string $plainText
     *
     * @return TokenInterface
     */
    public static function create(
        $authenticableId,
        string $cipherText,
        ?string $plainText = null
    ): TokenInterface {
        $token = new self($authenticableId, $cipherText, $plainText);

        $token->persist();

        return $token;
    }

    /**
     * Retrieve a token by the given attributes from the storage.
     *
     * @param array $attributes
     *
     * @return null|TokenInterface
     */
    public static function retrieveByAttributes(array $attributes): ?TokenInterface
    {
        $query = DB::table(self::getTable());

        foreach ($attributes as $key => $value) {
            $query->where($key, $value);
        }

        if (!$entity = $query->first()) {
            return null;
        }

        return new static(
            $entity->authenticable_id,
            $entity->cipher_text,
            null,
            $entity->expiry_time,
            new Carbon($entity->created_at),
            new Carbon($entity->updated_at)
        );
    }

    /**
     * Convert the token to a token notification.
     *
     * @return Notification
     */
    public function toNotification(): Notification
    {
        return new TokenNotification($this);
    }

    /**
     * Persist the token in the storage.
     *
     * @return bool
     */
    protected function persist(): bool
    {
        $this->attributes['created_at'] = $this->attributes['created_at']->toDateTimeString();
        $this->attributes['updated_at'] = $this->getNow()->toDateTimeString();

        $attributes = $this->attributes;

        if (array_key_exists('plain_text', $attributes)) {
            unset($attributes['plain_text']);
        }

        try {
            DB::beginTransaction();

            DB::table(self::getTable())->updateOrInsert([
                'authenticable_id' => $this->authenticableId(),
                'cipher_text'      => $this->cipherText(),
            ], $attributes);

            DB::commit();
        } catch (\Exception $e) {
            DB::rollBack();

            throw new \RuntimeException(
                'Something went wrong while saving the access token.',
                0,
                $e
            );
        }

        return true;
    }

    /**
     * Get the date time at the moment.
     *
     * @return Carbon
     */
    private function getNow(): Carbon
    {
        return Carbon::now();
    }

    /**
     * Get the name of the table token will be persisted.
     *
     * @return string
     */
    private static function getTable(): string
    {
        return config('temporary_access.table');
    }

    /**
     * Get the default expiry time in seconds.
     *
     * @return int
     */
    private function getDefaultExpiryTime(): int
    {
        return config('temporary_access.expires') * 60;
    }
}