DanielRobert\Otp\OtpGenerator

Complexity

Total Complexity

19

Size/Duplication

Total Lines	207
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	createPin()	0	14	3
A	__construct()	0	9	1
A	generate()	0	37	4
A	deleteOldOtps()	0	5	1
A	validate()	0	37	5
A	expiredAt()	0	14	2
A	__call()	0	17	3

<?php

namespace DanielRobert\Otp;

use Carbon\Carbon;
use DanielRobert\Otp\Models\OtpModel;
use Illuminate\Support\Str;


class OtpGenerator {
    /**
     * Length of the generated Otp
     *
     * @var int
     */
    protected $length;

    /**
     * Generated OPT type
     *
     * @var bool
     */
    protected $onlyDigits;

    /**
     * use same token to resending opt
     *
     *  @var bool
     */
    protected $useSameToken;

    /**
     * Otp Validity time
     *
     * @var int
     */
    protected $validity;

    /**
     * Delete old otps
     *
     * @var int
     */
    protected $deleteOldOtps;

    /**
     * Maximum otps allowed to generate
     *
     *  @var int
     */
    protected $maximumOtpsAllowed;

    /**
     * Maximum number of times to allowed to validate
     *
     * @var int
     */
    protected $allowedAttempts;

    public function __construct()
    {
        $this->length = config('otp-generator.length');
        $this->onlyDigits = config('otp-generator.onlyDigits');
        $this->useSameToken = config('otp-generator.useSameToken');
        $this->validity = config('otp-generator.validity');
        $this->deleteOldOtps = config('otp-generator.deleteOldOtps');
        $this->maximumOtpsAllowed = config('otp-generator.maximumOtpsAllowed');
        $this->allowedAttempts = config('otp-generator.allowedAttempts');
    }

    /**
     * When a method is called, look for the 'set' prefix and attempt to set the
     * matching property to the value passed to the method and return a chainable
     * object to the caller.
     *
     * @param string $method
     * @param mixed $params
     * @return mixed
     */
    public function __call(string $method, $params)
    {
        if (substr($method, 0, 3) != 'set') {
            return;
        }

        $property = Str::camel(substr($method, 3));


        // Does the property exist on this object?
        if (! property_exists($this, $property)) {
            return;
        }

        $this->{$property} = $params[0] ?? null;

        return $this;
    }

    public function generate(string $identifier): object
    {
        $this->deleteOldOtps();

        $otp = OtpModel::where('identifier', $identifier)->first();

        if ($otp == null) {
            $otp = OtpModel::create([
                'identifier' => $identifier,
                'token' => $this->createPin(),
                'validity' => $this->validity,
                'generated_at' => Carbon::now(),
            ]);
        } else {
            if ($otp->no_times_generated == $this->maximumOtpsAllowed) {

The property no_times_generated does not seem to exist on Illuminate\Database\Eloquent\Relations\HasOneThrough.

The property no_times_generated does not seem to exist on Illuminate\Database\Eloquent\Relations\HasManyThrough.

                return (object) [
                    'status' => false,
                    'message' => "Reached the maximum times to generate Otp",
                ];
            }

            $otp->update([
                'identifier' => $identifier,
                'token' => $this->useSameToken ? $otp->token : $this->createPin(),

The property token does not seem to exist on Illuminate\Database\Eloquent\Relations\HasOneThrough.

The property token does not seem to exist on Illuminate\Database\Eloquent\Relations\HasManyThrough.

                'validity' => $this->validity,
                'generated_at' => Carbon::now(),
            ]);
        }


        $otp->increment('no_times_generated');


        return (object) [
            'status' => true,
            'token' => $otp->token,
            'message' => "Otp generated",
        ];
    }

    public function validate(string $identifier, string $token): object
    {
        $otp = OtpModel::where('identifier', $identifier)->first();

        if (! $otp) {
            return (object) [
                'status' => false,
                'message' => 'Otp does not exists, Please generate new Otp',
            ];
        }

        if ($otp->isExpired()) {
            return (object) [
                'status' => false,
                'message' => 'Otp is expired',
            ];
        }

        if ($otp->no_times_attempted == $this->allowedAttempts) {

The property no_times_attempted does not seem to exist on Illuminate\Database\Eloquent\Relations\HasOneThrough.

The property no_times_attempted does not seem to exist on Illuminate\Database\Eloquent\Relations\HasManyThrough.

            return (object) [
                'status' => false,
                'message' => "Reached the maximum allowed attempts",
            ];
        }

        $otp->increment('no_times_attempted');

        if ($otp->token == $token) {

The property token does not seem to exist on Illuminate\Database\Eloquent\Relations\HasOneThrough.

The property token does not seem to exist on Illuminate\Database\Eloquent\Relations\HasManyThrough.

            return (object) [
                'status' => true,
                'message' => 'Otp is valid',
            ];
        }

        return (object) [
            'status' => false,
            'message' => 'Otp does not match',
        ];
    }

    public function expiredAt(string $identifier): object
    {
        $otp = OtpModel::where('identifier', $identifier)->first();

        if (! $otp) {
            return (object) [
                'status' => false,
                'message' => 'Otp does not exists, Please generate new Otp',
            ];
        }

        return (object) [
            'status' => true,
            'expired_at' => $otp->expiredAt(),
        ];
    }

    private function deleteOldOtps()
    {
        OtpModel::where('expired', true)
            ->orWhere('created_at', '<', Carbon::now()->subMinutes($this->deleteOldOtps))
            ->delete();
    }

    private function createPin(): string
    {
        if ($this->onlyDigits) {
            $characters = '0123456789';
        } else {
            $characters = '123456789abcdefghABCDEFGH';
        }
        $length = strlen($characters);
        $pin = '';
        for ($i = 0; $i < $this->length; $i++) {
            $pin .= $characters[rand(0, $length - 1)];
        }

        return $pin;
    }
}