Surfnet\StepupSelfService\SelfServiceBundle\Service\ActivationFlowService::process()

Complexity

Conditions	4
Paths	6

Size

Total Lines	39
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	ActivationFlowService::processPreferenceFromUri()	0	9	2
A	ActivationFlowService::getPreference()	0	20	3

<?php

declare(strict_types = 1);

/**
 * Copyright 2022 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 Psr\Log\LoggerInterface;
use Surfnet\StepupSelfService\SelfServiceBundle\Exception\LogicException;
use Surfnet\StepupSelfService\SelfServiceBundle\Security\Authentication\AuthenticatedSessionStateHandler;
use Surfnet\StepupSelfService\SelfServiceBundle\Value\ActivationFlowPreference;
use Surfnet\StepupSelfService\SelfServiceBundle\Value\ActivationFlowPreferenceInterface;
use Surfnet\StepupSelfService\SelfServiceBundle\Value\ActivationFlowPreferenceNotExpressed;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;

class ActivationFlowService

Missing doc comment for class ActivationFlowService

{
    private const ACTIVATION_FLOW_ENTITLEMENT_SAML_ATTRIBUTE = 'urn:mace:dir:attribute-def:eduPersonEntitlement';

    /**

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

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

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

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

     * Handle preferred activation flow logic
     *
     * 1. On the / path, the preferred activation flow can be set using the configured
     *    query string field. This field can have an option indicating the preferred flow.
     *    This is stored in session.
     * 2. If this preference was set, the list of available options is limited to just that
     *    option.
     * 3. The option can be reset by the Identity, removing it from session.
     *
     * Note that:
     * - fieldName and options are configured in the SelfServiceExtension
     *
     * @param string[] $options

Missing parameter comment

Expected 14 spaces after parameter type; 1 found

Doc comment for parameter $options does not match actual variable name $sessionState

     * @param array<string, string> $attributes

Missing parameter comment

Doc comment for parameter $attributes does not match actual variable name $tokenStorage

     */
    public function __construct(
        private readonly AuthenticatedSessionStateHandler $sessionState,
        private readonly TokenStorageInterface $tokenStorage,
        private readonly LoggerInterface $logger,
        private readonly string $fieldName,
        private readonly array $options,
        private readonly array $attributes
    ) {
    }

    public function processPreferenceFromUri(string $uri): void

Missing doc comment for function processPreferenceFromUri()

    {
        $requestedActivationPreference = $this->getFlowPreferenceFromUri($uri);
        if ($requestedActivationPreference instanceof ActivationFlowPreferenceNotExpressed) {
            return;
        }

        $this->logger->info('Storing the preference in session');
        $this->sessionState->setRequestedActivationFlowPreference($requestedActivationPreference);
    }

    public function getPreference(): ActivationFlowPreferenceInterface

Missing doc comment for function getPreference()

    {
        $requestedActivationPreference = $this->sessionState->getRequestedActivationFlowPreference();
        $availableActivationPreferences = $this->getFlowPreferencesFromSamlAttributes();

        if (count($availableActivationPreferences) == 0) {
            $this->logger->info('No entitlement attributes found to determine the allowed flow, allowing all flows');
            $availableActivationPreferences = [
                'ra', 'self'
            ];
        }

        if (in_array($requestedActivationPreference, $availableActivationPreferences)) {
            $this->logger->info('Found allowed activation flow');
            return $requestedActivationPreference;
        }

        $this->logger->info('Not found allowed activation flow');

        return new ActivationFlowPreferenceNotExpressed();
    }

    private function getFlowPreferenceFromUri(string $uri): ActivationFlowPreferenceInterface

Private method name "ActivationFlowService::getFlowPreferenceFromUri" must be prefixed with an underscore

Missing doc comment for function getFlowPreferenceFromUri()

    {
        $this->logger->info(sprintf('Analysing uri "%s" for activation flow query parameter', $uri));

        $parts = parse_url($uri);
        /** @var array<string, string> $parameters */

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

        $parameters = [];

        if (array_key_exists('query', $parts)) {
            $this->logger->debug('Found a query string in the uri');
            parse_str($parts['query'], $parameters);
        }

        // Is the configured field name in the querystring?
        if (!array_key_exists($this->fieldName, $parameters)) {
            $this->logger->notice(
                sprintf(
                    'The configured query string field name "%s" was not found in the uri "%s"',
                    $this->fieldName,
                    $uri
                )
            );
            return new ActivationFlowPreferenceNotExpressed();
        }

        $option = $parameters[$this->fieldName];
        switch ($option) {
            case 'ra':

Line indented incorrectly; expected 8 spaces, found 12

                return ActivationFlowPreference::createRa();
            case 'self':

Line indented incorrectly; expected 8 spaces, found 12

                return ActivationFlowPreference::createSelf();
        }


        $this->logger->notice(
            sprintf(
                'Field "%s" contained an invalid option "%s", must be one of: %s',
                $this->fieldName,
                $option,
                implode(', ', $this->options)
            )
        );
        return new ActivationFlowPreferenceNotExpressed();
    }

    /**

Missing short description in doc comment

     * @return ActivationFlowPreferenceInterface[]
     */
    private function getFlowPreferencesFromSamlAttributes(): array

Private method name "ActivationFlowService::getFlowPreferencesFromSamlAttributes" must be prefixed with an underscore

    {
        $this->logger->info('Analysing saml entitlement attributes for allowed activation flows');

        $token = $this->tokenStorage->getToken();
        if (!$token instanceof TokenInterface) {
            throw new LogicException("A authentication token should be set at this point");
        }

        $activationFlows = [];
        $attributes = $token->getAttributes();
        if (array_key_exists(self::ACTIVATION_FLOW_ENTITLEMENT_SAML_ATTRIBUTE, $attributes)) {
            $this->logger->debug('Found entitlement saml attributes');
            if (in_array($this->attributes['ra'], $attributes[self::ACTIVATION_FLOW_ENTITLEMENT_SAML_ATTRIBUTE])) {
                $activationFlows[] = ActivationFlowPreference::createRa();
            }
            if (in_array($this->attributes['self'], $attributes[self::ACTIVATION_FLOW_ENTITLEMENT_SAML_ATTRIBUTE])) {
                $activationFlows[] = ActivationFlowPreference::createSelf();
            }
        }
        return $activationFlows;
    }
}