OAuth2Framework\Component\OpenIdConnect\UserInfo\UserInfo

Complexity

Total Complexity

28

Size/Duplication

Total Lines	160
Duplicated Lines	0 %

Importance

Changes	7
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getPairwiseSubjectIdentifierAlgorithm()	0	3	1
A	calculateSubjectIdentifier()	0	16	4
A	getClaimValues()	0	6	2
A	getClaimsFromClaimScope()	0	15	4
A	getUserinfo()	0	14	1
A	isPairwiseSubjectIdentifierSupported()	0	3	1
A	enablePairwiseSubject()	0	3	1
A	getSectorIdentifierHost()	0	14	4
B	getUserClaim()	0	24	9

<?php

declare(strict_types=1);

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2019 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace OAuth2Framework\Component\OpenIdConnect\UserInfo;

use OAuth2Framework\Component\Core\Client\Client;
use OAuth2Framework\Component\Core\UserAccount\UserAccount;
use OAuth2Framework\Component\OpenIdConnect\UserInfo\Claim\ClaimManager;
use OAuth2Framework\Component\OpenIdConnect\UserInfo\Claim\ClaimSourceManager;
use OAuth2Framework\Component\OpenIdConnect\UserInfo\Pairwise\PairwiseSubjectIdentifierAlgorithm;
use OAuth2Framework\Component\OpenIdConnect\UserInfo\ScopeSupport\UserInfoScopeSupportManager;

class UserInfo
{
    /**
     * @var null|PairwiseSubjectIdentifierAlgorithm
     */
    private $pairwiseAlgorithm;

    /**
     * @var UserInfoScopeSupportManager
     */
    private $userinfoScopeSupportManager;

    /**
     * @var ClaimSourceManager
     */
    private $claimSourceManager;

    /**
     * @var ClaimManager
     */
    private $claimManager;

    /**
     * UserInfo constructor.
     */
    public function __construct(UserInfoScopeSupportManager $userinfoScopeSupportManager, ClaimManager $claimManager, ClaimSourceManager $claimSourceManager)
    {
        $this->userinfoScopeSupportManager = $userinfoScopeSupportManager;
        $this->claimManager = $claimManager;
        $this->claimSourceManager = $claimSourceManager;
    }

    public function getUserinfo(Client $client, UserAccount $userAccount, string $redirectUri, array $requestedClaims, ?string $scope, ?string $claimsLocales): array
    {
        $requestedClaims = array_merge(
            $this->getClaimsFromClaimScope($scope),
            $requestedClaims
        );
        $claims = $this->getClaimValues($userAccount, $requestedClaims, $claimsLocales);
        /*$claims = array_merge(
            $claims,
            $this->claimSourceManager->getUserInfo($userAccount, $scope, [])
        );*/
        $claims['sub'] = $this->calculateSubjectIdentifier($client, $userAccount, $redirectUri);

        return $claims;
    }

    public function enablePairwiseSubject(PairwiseSubjectIdentifierAlgorithm $pairwiseAlgorithm): void
    {
        $this->pairwiseAlgorithm = $pairwiseAlgorithm;
    }

    public function isPairwiseSubjectIdentifierSupported(): bool
    {
        return null !== $this->pairwiseAlgorithm;
    }

    public function getPairwiseSubjectIdentifierAlgorithm(): ?PairwiseSubjectIdentifierAlgorithm
    {
        return $this->pairwiseAlgorithm;
    }

    private function getClaimsFromClaimScope(?string $scope): array
    {
        $result = [];
        $scope = $scope ?? '';

        foreach (explode(' ', $scope) as $scp) {
            if ($this->userinfoScopeSupportManager->has($scp)) {
                $scope_claims = $this->userinfoScopeSupportManager->get($scp)->getAssociatedClaims();
                foreach ($scope_claims as $scope_claim) {
                    $result[$scope_claim] = null;
                }
            }
        }

        return $result;
    }

    private function getClaimValues(UserAccount $userAccount, array $requestedClaims, ?string $claimsLocales): array
    {
        $result = [];

The assignment to $result is dead and can be removed.

        $claimsLocales = null === $claimsLocales ? [] : array_unique(explode(' ', $claimsLocales));

        return $this->claimManager->getUserInfo($userAccount, $requestedClaims, $claimsLocales);
        /*foreach ($requestedClaims as $claim => $config) {
            foreach ($claimsLocales as $claims_locale) {
                $claim_locale = $this->computeClaimWithLocale($claim, $claims_locale);
                $claim_value = $this->getUserClaim($userAccount, $claim_locale, $config);
                if (null !== $claim_value) {
                    $result[$claim_locale] = $claim_value;

                    break;
                }
            }
        }*/
    }

    /**
     * @return null|mixed
     */
    private function getUserClaim(UserAccount $userAccount, string $claimName, ?array $config)

The method getUserClaim() is not used, and could be removed.

    {
        // FIXME: "acr" claim support has to be added.
        if ($userAccount->has($claimName)) {
            $claim = $userAccount->get($claimName);
            switch (true) {
                case \is_array($config) && \array_key_exists('value', $config):
                    if ($claim === $config['value']) {
                        return $claim;
                    }

                    break;
                case \is_array($config) && \array_key_exists('values', $config) && \is_array($config['values']):
                    if (\in_array($claim, $config['values'], true)) {
                        return $claim;
                    }

                    break;
                default:
                    return $claim;
            }
        }

        return null;
    }

    private function calculateSubjectIdentifier(Client $client, UserAccount $userAccount, string $redirectUri): string
    {
        $sub = $userAccount->getUserAccountId()->getValue();
        if (null === $this->pairwiseAlgorithm) {
            return $sub;
        }
        if ($client->has('subject_type') && ('pairwise' === $client->get('subject_type'))) {
            $sectorIdentifierHost = $this->getSectorIdentifierHost($client, $redirectUri);

            return $this->pairwiseAlgorithm->calculateSubjectIdentifier(
                $userAccount,
                $sectorIdentifierHost
            );
        }

        return $sub;
    }

    private function getSectorIdentifierHost(Client $client, string $redirectUri): string
    {
        $uri = $redirectUri;

        if (true === $client->has('sector_identifier_uri')) {
            $uri = $client->get('sector_identifier_uri');
        }

        $data = \Safe\parse_url($uri);

It seems like $uri can also be of type null; however, parameter $url of Safe\parse_url() does only seem to accept string, maybe add an additional type check?

        if (!\is_array($data) || !\array_key_exists('host', $data)) {

The condition is_array($data) is always false.

            throw new \InvalidArgumentException(\Safe\sprintf('Invalid Sector Identifier Uri "%s".', $uri));
        }

        return $data['host'];
    }
}