UserInfo::calculateSubjectIdentifier() - Code Metrics - Inspection of "Userinfo Endpoint" - OAuth2-Framework/oauth2-framework - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( acffac...83c99e )

by Florent

created 2018-06-06 10:48 UTC

UserInfo::calculateSubjectIdentifier() A

↳ Parent: UserInfo

Complexity

Conditions	4
Paths	3

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	17
rs	9.2
c	0
b	0
f	0
cc	4
eloc	10
nc	3
nop	3

<?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 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)

    {
        $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'];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* The MIT License (MIT)
7			*
8			* Copyright (c) 2014-2018 Spomky-Labs
9			*
10			* This software may be modified and distributed under the terms
11			* of the MIT license. See the LICENSE file for details.
12			*/
13
14			namespace OAuth2Framework\Component\OpenIdConnect\UserInfo;
15
16			use OAuth2Framework\Component\OpenIdConnect\UserInfo\ClaimSource\ClaimSourceManager;
17			use OAuth2Framework\Component\OpenIdConnect\UserInfo\Pairwise\PairwiseSubjectIdentifierAlgorithm;
18			use OAuth2Framework\Component\OpenIdConnect\UserInfo\ScopeSupport\UserInfoScopeSupportManager;
19			use OAuth2Framework\Component\Core\Client\Client;
20			use OAuth2Framework\Component\Core\UserAccount\UserAccount;
21
22			class UserInfo
23			{
24			/**
25			* @var null\|PairwiseSubjectIdentifierAlgorithm
26			*/
27			private $pairwiseAlgorithm = null;
28
29			/**
30			* @var UserInfoScopeSupportManager
31			*/
32			private $userinfoScopeSupportManager;
33
34			/**
35			* @var ClaimSourceManager
36			*/
37			private $claimSourceManager;
38
39			/**
40			* UserInfo constructor.
41			*
42			* @param UserInfoScopeSupportManager $userinfoScopeSupportManager
43			* @param ClaimSourceManager $claimSourceManager
44			*/
45			public function __construct(UserInfoScopeSupportManager $userinfoScopeSupportManager, ClaimSourceManager $claimSourceManager)
46			{
47			$this->userinfoScopeSupportManager = $userinfoScopeSupportManager;
48			$this->claimSourceManager = $claimSourceManager;
49			}
50
51			/**
52			* @return string[]
53			*/
54			public function getSupportedClaims(): array
55			{
56			$claimsSupported = [];
57			foreach ($this->userinfoScopeSupportManager->all() as $infoScopeSupport) {
58			$claimsSupported += $infoScopeSupport->getClaims();
59			}
60
61			return array_unique($claimsSupported);
62			}
63
64			/**
65			* @param Client $client
66			* @param UserAccount $userAccount
67			* @param string $redirectUri
68			* @param array $requestClaims
69			* @param string $scope
70			* @param string\|null $claimsLocales
71			*
72			* @return array
73			*/
74			public function getUserinfo(Client $client, UserAccount $userAccount, string $redirectUri, array $requestClaims, string $scope, ? string $claimsLocales): array
75			{
76			$requestClaims = array_merge(
77			$this->getClaimsFromClaimScope($scope),
78			$requestClaims
79			);
80			$claims = $this->getClaimValues($userAccount, $requestClaims, $claimsLocales);
81			$claims = array_merge(
82			$claims,
83			$this->claimSourceManager->getUserInfo($userAccount, $scope, [])
84			);
85			$claims['sub'] = $this->calculateSubjectIdentifier($client, $userAccount, $redirectUri);
86
87			return $claims;
88			}
89
90			/**
91			* @param string $scope
92			*
93			* @return array
94			*/
95			private function getClaimsFromClaimScope(string $scope): array
96			{
97			$result = [];
98
99			foreach (explode(' ', $scope) as $scp) {
100			if ($this->userinfoScopeSupportManager->has($scp)) {
101			$scope_claims = $this->userinfoScopeSupportManager->get($scp)->getClaims();
102			foreach ($scope_claims as $scope_claim) {
103			$result[$scope_claim] = null;
104			}
105			}
106			}
107
108			return $result;
109			}
110
111			/**
112			* @param UserAccount $userAccount
113			* @param string\|null $claimsLocales
114			* @param array $claims
115			*
116			* @return array
117			*/
118			private function getClaimValues(UserAccount $userAccount, array $claims, ? string $claimsLocales): array
119			{
120			$result = [];
121			if (null === $claimsLocales) {
122			$claimsLocales = [];
123			} elseif (true === is_string($claimsLocales)) {
124			$claimsLocales = explode(' ', $claimsLocales);
125			}
126			$claimsLocales[] = '';
127			foreach ($claims as $claim => $config) {
128			foreach ($claimsLocales as $claims_locale) {
129			$claim_locale = $this->computeClaimWithLocale($claim, $claims_locale);
130			$claim_value = $this->getUserClaim($userAccount, $claim_locale, $config);
131			if (null !== $claim_value) {
132			$result[$claim_locale] = $claim_value;
133
134			break;
135			}
136			}
137			}
138
139			return $result;
140			}
141
142			/**
143			* @param string $claim
144			* @param string $locale
145			*
146			* @return string
147			*/
148			private function computeClaimWithLocale($claim, $locale): string
149			{
150			if (empty($locale)) {
151			return $claim;
152			}
153
154			return sprintf('%s#%s', $claim, $locale);
155			}
156
157			/**
158			* @param UserAccount $userAccount
159			* @param string $claim
160			* @param null\|array $config
161			*
162			* @return null\|mixed
163			*/
164			private function getUserClaim(UserAccount $userAccount, $claim, $config)
			0 ignored issues – show Unused Code introduced 2018-01-05 14:16 UTC by Report Bug Copy Issue Report The parameter `$config` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
165			{
166			//The parameter $config is not yet used and the claim is returned as-is whatever the client requested
167			//FIXME
168			if ($userAccount->has($claim)) {
169			return $userAccount->get($claim);
170			}
171			}
172
173			/**
174			* @param PairwiseSubjectIdentifierAlgorithm $pairwiseAlgorithm
175			* @param bool $isPairwiseSubjectDefault
176			*/
177			public function enablePairwiseSubject(PairwiseSubjectIdentifierAlgorithm $pairwiseAlgorithm, bool $isPairwiseSubjectDefault)
			0 ignored issues – show Unused Code introduced 2018-06-06 11:00 UTC by Report Bug Copy Issue Report The parameter `$isPairwiseSubjectDefault` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
178			{
179			$this->pairwiseAlgorithm = $pairwiseAlgorithm;
180			}
181
182			/**
183			* @return bool
184			*/
185			public function isPairwiseSubjectIdentifierSupported(): bool
186			{
187			return null !== $this->pairwiseAlgorithm;
188			}
189
190			/**
191			* @return PairwiseSubjectIdentifierAlgorithm\|null
192			*/
193			public function getPairwiseSubjectIdentifierAlgorithm(): ? PairwiseSubjectIdentifierAlgorithm
194			{
195			return $this->pairwiseAlgorithm;
196			}
197
198			/**
199			* @param Client $client
200			* @param UserAccount $userAccount
201			* @param string $redirectUri
202			*
203			* @return string
204			*/
205			private function calculateSubjectIdentifier(Client $client, UserAccount $userAccount, string $redirectUri): string
206			{
207			$sub = $userAccount->getUserAccountId()->getValue();
208			if (false === $this->isPairwiseSubjectIdentifierSupported()) {
209			return $sub;
210			}
211			if (($client->has('subject_type') && ('pairwise' === $client->get('subject_type')))) {
212			$sectorIdentifierHost = $this->getSectorIdentifierHost($client, $redirectUri);
213
214			return $this->pairwiseAlgorithm->calculateSubjectIdentifier(
215			$userAccount,
216			$sectorIdentifierHost
217			);
218			}
219
220			return $sub;
221			}
222
223			/**
224			* @param Client $client
225			* @param string $redirectUri
226			*
227			* @return string
228			*/
229			private function getSectorIdentifierHost(Client $client, string $redirectUri): string
230			{
231			$uri = $redirectUri;
232
233			if (true === $client->has('sector_identifier_uri')) {
234			$uri = $client->get('sector_identifier_uri');
235			}
236
237			$data = parse_url($uri);
238			if (!is_array($data) \|\| !array_key_exists('host', $data)) {
239			throw new \InvalidArgumentException(sprintf('Invalid Sector Identifier Uri "%s".', $uri));
240			}
241
242			return $data['host'];
243			}
244			}
245

OAuth2-Framework / oauth2-framework

Push — master ( acffac...83c99e )

UserInfo::calculateSubjectIdentifier() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like