Surfnet\StepupSelfService\SelfServiceBundle\Service\SelfVetMarshaller

Complexity

Total Complexity

10

Size/Duplication

Total Lines	81
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	isSelfVettingEnabledFor()	0	17	2
B	isAllowed()	0	36	7

<?php

declare(strict_types = 1);

/**
 * Copyright 2021 SURFnet B.V.
 *
 * 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 Psr\Log\LoggerInterface;
use Surfnet\StepupBundle\Service\SecondFactorTypeService;
use Surfnet\StepupBundle\Value\SecondFactorType;
use Surfnet\StepupBundle\Value\VettingType;
use Surfnet\StepupMiddlewareClientBundle\Identity\Dto\Identity;
use Surfnet\StepupMiddlewareClientBundle\Identity\Dto\VettedSecondFactor;

class SelfVetMarshaller implements VettingMarshaller

Missing doc comment for class SelfVetMarshaller

{
    public function __construct(

Missing doc comment for function __construct()

        private readonly SecondFactorService $secondFactorService,
        private readonly SecondFactorTypeService $secondFactorTypeService,
        private readonly InstitutionConfigurationOptionsService $institutionConfigurationService,
        private readonly AuthorizationService $authorizationService,
        private readonly LoggerInterface $logger
    ) {
    }

    /**

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

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

     * You are allowed to self vet when:
     * 1. You already have a vetted token
     * 2. The vetted token has higher LoA (or equal) to the one being vetted
     *
     * Or
     *
     * When you have a self asserted token, you are allowed to self-vet any
     * token with the self-vetted token. Resulting in tokens that are of the
     * self-asserted token type.
     */

Missing @return tag in function comment

    public function isAllowed(Identity $identity, string $secondFactorId): bool
    {
        if (!$this->isSelfVettingEnabledFor($identity)) {
            return false;
        }
        $vettedSecondFactors = $this->secondFactorService->findVettedByIdentity($identity->id);

It seems like $identity->id can also be of type null; however, parameter $identityId of Surfnet\StepupSelfService\SelfServiceBundle\Service\SecondFactorService::findVettedByIdentity() does only seem to accept string, maybe add an additional type check?

        if ($vettedSecondFactors->getTotalItems() === 0) {
            $this->logger->info('Self vetting is not allowed, no vetted tokens are available');
            return false;
        }
        $candidateToken = $this->secondFactorService->findOneVerified($secondFactorId);
        if ($candidateToken !== null) {
            /** @var VettedSecondFactor $authoringSecondFactor */

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 ($vettedSecondFactors->getElements() as $authoringSecondFactor) {
                $hasSuitableToken = $this->secondFactorTypeService->hasEqualOrLowerLoaComparedTo(
                    new SecondFactorType($candidateToken->type),
                    new VettingType(VettingType::TYPE_SELF_VET),
                    new SecondFactorType($authoringSecondFactor->type),
                    new VettingType($authoringSecondFactor->vettingType)
                );
                if ($hasSuitableToken) {
                    $this->logger->info('Self vetting is allowed, a suitable token was found');
                    return true;
                }
            }
        }

        // Finally, we allow vetting with self-asserted tokens. Using the SAT authorization service
        // we ascertain if the user is allowed to use SAT.
        if ($this->authorizationService->maySelfVetSelfAssertedTokens($identity)) {
            $this->logger->info('Self vetting is allowed, by utilizing self-asserted tokens');
            return true;
        }

        $this->logger->info('Self vetting is not allowed, no suitable tokens are available');
        return false;
    }

    /**

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

     * Does the institution allow for self vetting?
     */

There must be no blank lines after the function comment

Missing @return tag in function comment

    private function isSelfVettingEnabledFor(Identity $identity): bool

Private method name "SelfVetMarshaller::isSelfVettingEnabledFor" must be prefixed with an underscore

    {
        $this->logger->info('Determine if self vetting is allowed');
        $configurationOptions = $this->institutionConfigurationService->getInstitutionConfigurationOptionsFor(
            $identity->institution
        );
        if ($configurationOptions->selfVet === false) {
            $this->logger->info(
                sprintf(
                    'Self vetting is not allowed, as the option is not enabled for institution %s',
                    $identity->institution
                )
            );
            return false;
        }
        $this->logger->info(sprintf('Self vetting is allowed for %s', $identity->institution));
        return true;
    }
}