Surfnet\StepupSelfService\SelfServiceBundle\Service\SmsRecoveryTokenService

Complexity

Total Complexity

20

Size/Duplication

Total Lines	136
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	forgetTokenCreatedDuringSecondFactorRegistration()	0	3	1
A	wasTokenCreatedDuringSecondFactorRegistration()	0	3	1
A	tokenCreatedDuringSecondFactorRegistration()	0	3	1
A	sendChallenge()	0	15	1
A	__construct()	0	6	1
A	forgetRecoveryTokenState()	0	3	1
A	getMaximumOtpRequestsCount()	0	3	1
A	clearSmsVerificationState()	0	3	1
A	provePossession()	0	30	5
A	hasSmsVerificationState()	0	3	1
A	verifyAuthentication()	0	19	4
A	authenticate()	0	10	1
A	getOtpRequestsRemainingCount()	0	3	1

<?php

declare(strict_types = 1);

/**
 * Copyright 2014 SURFnet bv
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

PHP version not specified

Missing @category tag in file comment

Missing @package tag in file comment

Missing @author tag in file comment

Missing @license tag in file comment

Missing @link tag in file comment

namespace Surfnet\StepupSelfService\SelfServiceBundle\Service;

use Surfnet\StepupBundle\Command\SendRecoveryTokenSmsChallengeCommand as StepupSendRecoveryTokenSmsChallengeCommand;
use Surfnet\StepupBundle\Command\SendSmsChallengeCommandInterface;
use Surfnet\StepupBundle\Command\VerifyPossessionOfPhoneForRecoveryTokenCommand;
use Surfnet\StepupBundle\Service\Exception\TooManyChallengesRequestedException;
use Surfnet\StepupBundle\Service\SmsRecoveryTokenServiceInterface;
use Surfnet\StepupBundle\Value\PhoneNumber\InternationalPhoneNumber;
use Surfnet\StepupBundle\Value\PhoneNumber\PhoneNumber;
use Surfnet\StepupMiddlewareClientBundle\Identity\Command\ProvePhoneRecoveryTokenPossessionCommand;
use Surfnet\StepupMiddlewareClientBundle\Uuid\Uuid;
use Surfnet\StepupSelfService\SelfServiceBundle\Command\SendRecoveryTokenSmsAuthenticationChallengeCommand;
use Surfnet\StepupSelfService\SelfServiceBundle\Command\SendRecoveryTokenSmsChallengeCommand;
use Surfnet\StepupSelfService\SelfServiceBundle\Command\VerifySmsRecoveryTokenChallengeCommand;
use Surfnet\StepupSelfService\SelfServiceBundle\Service\SelfAssertedTokens\ProofOfPossessionResult;

The type Surfnet\StepupSelfService\SelfServiceBundle\Service\SelfAssertedTokens\ProofOfPossessionResult was not found. Maybe you did not declare it correctly or list all dependencies?

use Surfnet\StepupSelfService\SelfServiceBundle\Service\SelfAssertedTokens\RecoveryTokenState;
use Symfony\Contracts\Translation\TranslatorInterface;

/**
 * Directs the different state keeping for SMS based
 * Recovery Tokens. This means it communicates with the
 * Middleware via the command service to register RT's,
 * Keeps state of SMS verifications (RecoveryTokenState).
 * And it tracks the overall registration state of
 * a RT via SmsRecoveryTokenServiceInterface
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */

Missing @category tag in class comment

Missing @package tag in class comment

Missing @author tag in class comment

Missing @license tag in class comment

Missing @link tag in class comment

class SmsRecoveryTokenService
{
    final public const REGISTRATION_RECOVERY_TOKEN_ID = 'registration';

    public function __construct(

Missing doc comment for function __construct()

        private readonly SmsRecoveryTokenServiceInterface $smsService,
        private readonly TranslatorInterface $translator,
        private readonly CommandService $commandService,
        private readonly RecoveryTokenState $stateHandler,
    ) {
    }

    public function getOtpRequestsRemainingCount(string $identifier): int

Missing doc comment for function getOtpRequestsRemainingCount()

    {
        return $this->smsService->getOtpRequestsRemainingCount($identifier);
    }

    public function getMaximumOtpRequestsCount(): int

Missing doc comment for function getMaximumOtpRequestsCount()

    {
        return $this->smsService->getMaximumOtpRequestsCount();
    }

    public function hasSmsVerificationState(string $secondFactorId): bool

Missing doc comment for function hasSmsVerificationState()

    {
        return $this->smsService->hasSmsVerificationState($secondFactorId);
    }

    public function clearSmsVerificationState(string $secondFactorId): void

Missing doc comment for function clearSmsVerificationState()

    {
        $this->smsService->clearSmsVerificationState($secondFactorId);
    }

    public function authenticate(SendRecoveryTokenSmsAuthenticationChallengeCommand $command): bool

Missing doc comment for function authenticate()

    {
        $stepupCommand = new StepupSendRecoveryTokenSmsChallengeCommand();
        $stepupCommand->phoneNumber = $command->identifier;
        $stepupCommand->body = $this->translator->trans('ss.registration.sms.challenge_body');
        $stepupCommand->identity = $command->identity;
        $stepupCommand->institution = $command->institution;
        $stepupCommand->recoveryTokenId = $command->recoveryTokenId;

        return $this->smsService->sendChallenge($stepupCommand);
    }

    /**

Parameter $command should have a doc-comment as per coding-style.

Missing short description in doc comment

     * @return bool Whether SMS sending did not fail.
     * @throws TooManyChallengesRequestedException
     */
    public function sendChallenge(SendRecoveryTokenSmsChallengeCommand|SendSmsChallengeCommandInterface $command): bool
    {
        $phoneNumber = new InternationalPhoneNumber(
            $command->country->getCountryCode(),
            new PhoneNumber($command->subscriber)
        );

        $stepupCommand = new StepupSendRecoveryTokenSmsChallengeCommand();
        $stepupCommand->phoneNumber = $phoneNumber;
        $stepupCommand->body = $this->translator->trans('ss.registration.sms.challenge_body');
        $stepupCommand->identity = $command->identity;
        $stepupCommand->institution = $command->institution;
        $stepupCommand->recoveryTokenId = $command->recoveryTokenId;

        return $this->smsService->sendChallenge($stepupCommand);
    }

    public function provePossession(VerifySmsRecoveryTokenChallengeCommand $challengeCommand): ProofOfPossessionResult

Missing doc comment for function provePossession()

    {
        $stepupCommand = new VerifyPossessionOfPhoneForRecoveryTokenCommand();
        $stepupCommand->challenge = $challengeCommand->challenge;
        $stepupCommand->recoveryTokenId = $challengeCommand->recoveryTokenId;

        $verification = $this->smsService->verifyPossession($stepupCommand);

        if ($verification->didOtpExpire()) {
            return ProofOfPossessionResult::challengeExpired();
        }
        if ($verification->wasAttemptedTooManyTimes()) {
            return ProofOfPossessionResult::tooManyAttempts();
        }
        if (!$verification->wasSuccessful()) {
            return ProofOfPossessionResult::incorrectChallenge();
        }

        $command = new ProvePhoneRecoveryTokenPossessionCommand();
        $command->identityId = $challengeCommand->identity;
        $command->recoveryTokenId = Uuid::generate();
        $command->phoneNumber = $verification->getPhoneNumber();

        $result = $this->commandService->execute($command);

        if (!$result->isSuccessful()) {
            return ProofOfPossessionResult::proofOfPossessionCommandFailed();
        }

        return ProofOfPossessionResult::recoveryTokenCreated($command->recoveryTokenId);
    }

    public function wasTokenCreatedDuringSecondFactorRegistration(): bool

Missing doc comment for function wasTokenCreatedDuringSecondFactorRegistration()

    {
        return $this->stateHandler->wasRecoveryTokenCreatedDuringSecondFactorRegistration();
    }

    public function forgetTokenCreatedDuringSecondFactorRegistration(): void

Missing doc comment for function forgetTokenCreatedDuringSecondFactorRegistration()

    {
        $this->stateHandler->forgetTokenCreatedDuringSecondFactorRegistration();
    }

    public function tokenCreatedDuringSecondFactorRegistration(): void

Missing doc comment for function tokenCreatedDuringSecondFactorRegistration()

    {
        $this->stateHandler->tokenCreatedDuringSecondFactorRegistration();
    }

    public function forgetRecoveryTokenState(): void

Missing doc comment for function forgetRecoveryTokenState()

    {
        $this->stateHandler->forget();
    }

    public function verifyAuthentication(VerifySmsRecoveryTokenChallengeCommand $command): ProofOfPossessionResult

Missing doc comment for function verifyAuthentication()

    {
        $stepupCommand = new VerifyPossessionOfPhoneForRecoveryTokenCommand();
        $stepupCommand->challenge = $command->challenge;
        $stepupCommand->recoveryTokenId = $command->recoveryTokenId;

        $verification = $this->smsService->verifyPossession($stepupCommand);

        if ($verification->didOtpExpire()) {
            return ProofOfPossessionResult::challengeExpired();
        }
        if ($verification->wasAttemptedTooManyTimes()) {
            return ProofOfPossessionResult::tooManyAttempts();
        }
        if (!$verification->wasSuccessful()) {
            return ProofOfPossessionResult::incorrectChallenge();
        }

        return ProofOfPossessionResult::recoveryTokenVerified();
    }
}