Surfnet\StepupSelfService\SelfServiceBundle\Service\SelfAssertedTokens\RecoveryTokenService

Complexity

Total Complexity

30

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	authenticateSafeStore()	0	3	1
A	hasStepUpRequest()	0	3	1
A	resetReturnTo()	0	3	1
A	deleteStepUpRequest()	0	3	1
A	startStepUpRequest()	0	3	1
A	getRecoveryToken()	0	3	1
A	getStepUpRequest()	0	3	1
A	getRemainingTokenTypes()	0	14	3
A	delete()	0	3	1
A	resetStepUpGiven()	0	3	1
A	getRecoveryTokensForIdentity()	0	3	1
A	getAvailableTokens()	0	21	5
A	excludeDisabledRecoveryTokens()	0	11	6
A	__construct()	0	7	1
A	returnTo()	0	3	1
A	hasRecoveryToken()	0	3	1
A	setReturnTo()	0	3	1
A	wasStepUpGiven()	0	3	1
A	stepUpGiven()	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\SelfAssertedTokens;

use Psr\Log\LoggerInterface;
use Surfnet\StepupMiddlewareClient\Identity\Dto\RecoveryToken;
use Surfnet\StepupMiddlewareClientBundle\Identity\Dto\Identity;
use Surfnet\StepupMiddlewareClientBundle\Identity\Dto\VerifiedSecondFactor;
use Surfnet\StepupMiddlewareClientBundle\Identity\Service\RecoveryTokenService as MiddlewareRecoveryTokenService;
use Surfnet\StepupSelfService\SelfServiceBundle\Command\SafeStoreAuthenticationCommand;
use Surfnet\StepupSelfService\SelfServiceBundle\Service\SelfAssertedTokens\Dto\ReturnTo;

readonly class RecoveryTokenService

Missing doc comment for class RecoveryTokenService

{
    public function __construct(

Missing doc comment for function __construct()

        private MiddlewareRecoveryTokenService $recoveryTokenService,
        private SafeStoreService $safeStoreService,
        private RecoveryTokenState $stateStore,
        private RecoveryTokenConfig $config,
        private LoggerInterface $logger
    ) {
    }

    public function hasRecoveryToken(Identity $identity): bool

Missing doc comment for function hasRecoveryToken()

    {
        return $this->recoveryTokenService->hasRecoveryToken($identity);
    }

    public function getRecoveryToken(string $recoveryTokenId): RecoveryToken

Missing doc comment for function getRecoveryToken()

    {
        return $this->recoveryTokenService->findOne($recoveryTokenId);
    }

    /**

Missing short description in doc comment

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

     * @return RecoveryToken[]
     */
    public function getRecoveryTokensForIdentity(Identity $identity): array
    {
        return $this->recoveryTokenService->findAllFor($identity);
    }

    public function getRemainingTokenTypes(Identity $identity): array

Missing doc comment for function getRemainingTokenTypes()

    {
        $tokens = $this->getRecoveryTokensForIdentity($identity);
        $tokenTypes = $this->excludeDisabledRecoveryTokens(
            $this->recoveryTokenService->getAvailableRecoveryTokenTypes()
        );

        /** @var RecoveryToken $token */

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

        foreach ($tokens as $token) {
            if (in_array($token->type, $tokenTypes)) {
                unset($tokenTypes[$token->type]);
            }
        }
        return $tokenTypes;
    }

    public function delete(RecoveryToken $recoveryToken): void

Missing doc comment for function delete()

    {
        $this->recoveryTokenService->delete($recoveryToken);

The method delete() does not exist on Surfnet\StepupMiddlewareClientBundle\Identity\Service\RecoveryTokenService.

    }

    /**

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

     * Verify the password hash with the secret specified on the command.
     */

Missing @return tag in function comment

    public function authenticateSafeStore(SafeStoreAuthenticationCommand $command): bool
    {
        return $this->safeStoreService->authenticate($command->secret, $command->recoveryToken->identifier);
    }

    public function getAvailableTokens(Identity $identity, VerifiedSecondFactor $secondFactor): array

Missing doc comment for function getAvailableTokens()

    {
        $tokens = $this->getRecoveryTokensForIdentity($identity);
        if ($secondFactor->type === 'sms' && array_key_exists('sms', $tokens)) {
            // Check if the phone number of the recovery token is the same as that of the second factor token
            $smsRecoveryToken = $tokens['sms'];
            if ($smsRecoveryToken->identifier === $secondFactor->secondFactorIdentifier) {
                $this->logger->info(
                    sprintf(
                        'Filtering the SMS recovery token from the available recovery tokens: [%s]. As the phone ' .
                        ' numbers are the same for both second factor and recovery tokens.',
                        implode(', ', array_keys($tokens))
                    )
                );
                unset($tokens['sms']);
            }
        }
        if ($tokens === []) {
            $this->logger->info('No recovery tokens are available for second factor registration');
        }
        return $tokens;
    }

    public function startStepUpRequest(string $requestId): void

Missing doc comment for function startStepUpRequest()

    {
        $this->stateStore->startStepUpRequest($requestId);
    }

    public function hasStepUpRequest(): bool

Missing doc comment for function hasStepUpRequest()

    {
        return $this->stateStore->hasStepUpRequest();
    }

    public function getStepUpRequest(): string

Missing doc comment for function getStepUpRequest()

    {
        return $this->stateStore->getStepUpRequest();
    }

    public function deleteStepUpRequest(): void

Missing doc comment for function deleteStepUpRequest()

    {
        $this->stateStore->deleteStepUpRequest();
    }

    public function wasStepUpGiven(): bool

Missing doc comment for function wasStepUpGiven()

    {
        return $this->stateStore->getStepUpGiven();
    }

    public function stepUpGiven(): void

Missing doc comment for function stepUpGiven()

    {
        $this->stateStore->setStepUpGiven(true);
    }

    public function setReturnTo(string $route, array $parameters = []): void

Missing doc comment for function setReturnTo()

    {
        $this->stateStore->setReturnTo($route, $parameters);
    }

    public function returnTo(): ReturnTo

Missing doc comment for function returnTo()

    {
        return $this->stateStore->returnTo();
    }

    public function resetReturnTo() :void

Missing doc comment for function resetReturnTo()

    {
        $this->stateStore->resetReturnTo();
    }

    public function resetStepUpGiven(): void

Missing doc comment for function resetStepUpGiven()

    {
        $this->stateStore->resetStepUpGiven();
    }

    private function excludeDisabledRecoveryTokens(array $availableRecoveryTokenTypes): array

Private method name "RecoveryTokenService::excludeDisabledRecoveryTokens" must be prefixed with an underscore

Missing doc comment for function excludeDisabledRecoveryTokens()

    {
        foreach ($availableRecoveryTokenTypes as $identifier => $token) {
            if ($token === 'sms' && $this->config->isSmsDisabled()) {
                unset($availableRecoveryTokenTypes[$identifier]);
            }
            if ($token === 'safe-store' && $this->config->isSafeStoreCodeDisabled()) {
                unset($availableRecoveryTokenTypes[$identifier]);
            }
        }
        return $availableRecoveryTokenTypes;
    }
}