OAuth2Framework\Component\OpenIdConnect\UserInfo\UserInfo

Complexity

Total Complexity

29

Size/Duplication

Total Lines	223
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getSupportedClaims()	0	9	2
A	getUserinfo()	0	15	1
A	getClaimsFromClaimScope()	0	15	4
B	getClaimValues()	0	23	6
A	computeClaimWithLocale()	0	8	2
A	getUserClaim()	0	8	2
A	enablePairwiseSubject()	0	4	1
A	isPairwiseSubjectIdentifierSupported()	0	4	1
A	getPairwiseSubjectIdentifierAlgorithm()	0	4	1
A	calculateSubjectIdentifier()	0	17	4
A	getSectorIdentifierHost()	0	15	4

<?php

declare(strict_types=1);

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2018 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\OpenIdConnect\UserInfo\ClaimSource\ClaimSourceManager;
use OAuth2Framework\Component\OpenIdConnect\UserInfo\Pairwise\PairwiseSubjectIdentifierAlgorithm;
use OAuth2Framework\Component\OpenIdConnect\UserInfo\ScopeSupport\UserInfoScopeSupportManager;
use OAuth2Framework\Component\Core\Client\Client;
use OAuth2Framework\Component\Core\UserAccount\UserAccount;

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

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

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

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

    /**
     * @return string[]
     */
    public function getSupportedClaims(): array
    {
        $claimsSupported = [];
        foreach ($this->userinfoScopeSupportManager->all() as $infoScopeSupport) {
            $claimsSupported += $infoScopeSupport->getClaims();
        }

        return array_unique($claimsSupported);
    }

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

        return $claims;
    }

    /**
     * @param string $scope
     *
     * @return array
     */
    private function getClaimsFromClaimScope(string $scope): array
    {
        $result = [];

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

        return $result;
    }

    /**
     * @param UserAccount $userAccount
     * @param string|null $claimsLocales
     * @param array       $claims
     *
     * @return array
     */
    private function getClaimValues(UserAccount $userAccount, array $claims, ? string $claimsLocales): array
    {
        $result = [];
        if (null === $claimsLocales) {
            $claimsLocales = [];
        } elseif (true === is_string($claimsLocales)) {
            $claimsLocales = explode(' ', $claimsLocales);
        }
        $claimsLocales[] = '';
        foreach ($claims 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 $result;
    }

    /**
     * @param string $claim
     * @param string $locale
     *
     * @return string
     */
    private function computeClaimWithLocale($claim, $locale): string
    {
        if (empty($locale)) {
            return $claim;
        }

        return sprintf('%s#%s', $claim, $locale);
    }

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

The parameter $config is not used and could be removed.

    {
        //The parameter $config is not yet used and the claim is returned as-is whatever the client requested
        //FIXME
        if ($userAccount->has($claim)) {
            return $userAccount->get($claim);
        }
    }

    /**
     * @param PairwiseSubjectIdentifierAlgorithm $pairwiseAlgorithm
     * @param bool                               $isPairwiseSubjectDefault
     */
    public function enablePairwiseSubject(PairwiseSubjectIdentifierAlgorithm $pairwiseAlgorithm, bool $isPairwiseSubjectDefault)

The parameter $isPairwiseSubjectDefault is not used and could be removed.

    {
        $this->pairwiseAlgorithm = $pairwiseAlgorithm;
    }

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

    /**
     * @return PairwiseSubjectIdentifierAlgorithm|null
     */
    public function getPairwiseSubjectIdentifierAlgorithm(): ? PairwiseSubjectIdentifierAlgorithm
    {
        return $this->pairwiseAlgorithm;
    }

    /**
     * @param Client      $client
     * @param UserAccount $userAccount
     * @param string      $redirectUri
     *
     * @return string
     */
    private function calculateSubjectIdentifier(Client $client, UserAccount $userAccount, string $redirectUri): string
    {
        $sub = $userAccount->getUserAccountId()->getValue();
        if (false === $this->isPairwiseSubjectIdentifierSupported()) {
            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;
    }

    /**
     * @param Client $client
     * @param string $redirectUri
     *
     * @return string
     */
    private function getSectorIdentifierHost(Client $client, string $redirectUri): string
    {
        $uri = $redirectUri;

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

        $data = parse_url($uri);
        if (!is_array($data) || !array_key_exists('host', $data)) {
            throw new \InvalidArgumentException(sprintf('Invalid Sector Identifier Uri "%s".', $uri));
        }

        return $data['host'];
    }
}