Erdemkeren\Otp\OtpService

Complexity

Total Complexity

8

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	15	1
A	getPasswordGenerator()	0	3	1
A	refresh()	0	7	1
A	save()	0	3	1
A	addPasswordGenerator()	0	3	1
A	extend()	0	7	1
A	__construct()	0	5	1
A	invalidate()	0	7	1

<?php
/*
 * Copyright (c) 2021. Hilmi Erdem Keren
 * license MIT
 */

namespace Erdemkeren\Otp;

use Erdemkeren\Otp\Contracts\EncryptorContract;
use Erdemkeren\Otp\Contracts\GeneratorManagerContract;
use Erdemkeren\Otp\Contracts\TokenRepositoryContract;
use Erdemkeren\Otp\Exceptions\UnregisteredGeneratorException;

/**
 * Class OtpService.
 */
class OtpService
{
    public function __construct(
        private GeneratorManagerContract $manager,
        private EncryptorContract $encryptor,
        private TokenRepositoryContract $tokenRepository,
    ) {
        //
    }

    /**
     * Create a new token and get it.
     *
     * @param  int|string  $authenticableId
     * @param  string  $generator
     * @return OtpToken
     */
    public function create(int|string $authenticableId, string $generator = 'default'): OtpToken
    {
        $plainText = $this->getPasswordGenerator($generator)();
        $cipherText = $this->encryptor->encrypt($plainText);

        $token = new OtpToken([
            'plain_text' => $plainText,
            'cipher_text' => $cipherText,
            'expiry_time' => 300,
            'authenticable_id' => $authenticableId,
        ]);

        $this->tokenRepository->persist($token);

        return $token;
    }

    /**
     * Save the given token to the storage.
     *
     * @param  OtpToken  $token
     * @return bool
     */
    public function save(OtpToken $token): bool
    {
        return $this->tokenRepository->persist($token);
    }

    /**
     * Extend the given token and get the extended instance.
     *
     * @param  OtpToken  $token
     * @param  int  $secs
     * @return OtpToken
     */
    public function extend(OtpToken $token, int $secs): OtpToken
    {
        $extended = $token->extend($secs);

        $this->tokenRepository->persist($extended);

        return $extended;
    }

    /**
     * Refresh the given token and get the refreshed instance.
     *
     * @param  OtpToken  $token
     * @return OtpToken
     */
    public function refresh(OtpToken $token): OtpToken
    {
        $refreshed = $token->refresh();

        $this->tokenRepository->persist($refreshed);

        return $refreshed;
    }

    /**
     * Invalidate the given token and get the invalidated instance.
     *
     * @param  OtpToken  $token
     * @return OtpToken
     */
    public function invalidate(OtpToken $token): OtpToken
    {
        $invalidated = $token->invalidate();

        $this->tokenRepository->persist($invalidated);

        return $invalidated;
    }

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

    /**
     * Get the token generator by the given name.
     *
     * @param  string  $name
     * @return callable
     *
     * @throws UnregisteredGeneratorException
     */
    private function getPasswordGenerator(string $generator): callable
    {
        return $this->manager->get($generator);
    }
}