LoginCidadao\RemoteClaimsBundle\Fetcher\RemoteClaimFetcher

Complexity

Total Complexity

19

Size/Duplication

Total Lines	154
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	14

Test Coverage

Coverage

98.33%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	fetchRemoteClaim()	0	16	2
B	discoverClaimUri()	0	30	6
B	getRemoteClaim()	0	24	4
A	findClaimProvider()	0	10	3
A	getExistingClaimProvider()	0	16	3

<?php
/**
 * This file is part of the login-cidadao project or it's bundles.
 *
 * (c) Guilherme Donato <guilhermednt on github>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace LoginCidadao\RemoteClaimsBundle\Fetcher;

use Doctrine\ORM\EntityManagerInterface;
use GuzzleHttp\Client;
use LoginCidadao\OAuthBundle\Entity\ClientRepository;
use LoginCidadao\OAuthBundle\Model\ClientInterface;
use LoginCidadao\RemoteClaimsBundle\Entity\RemoteClaim;
use LoginCidadao\RemoteClaimsBundle\Entity\RemoteClaimRepository;
use LoginCidadao\RemoteClaimsBundle\Exception\ClaimProviderNotFoundException;
use LoginCidadao\RemoteClaimsBundle\Model\ClaimProviderInterface;
use LoginCidadao\RemoteClaimsBundle\Model\HttpUri;
use LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimFetcherInterface;
use LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimInterface;
use LoginCidadao\RemoteClaimsBundle\Model\TagUri;
use LoginCidadao\RemoteClaimsBundle\Parser\RemoteClaimParser;
use LoginCidadao\OAuthBundle\Entity\Client as ClaimProvider;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

class RemoteClaimFetcher implements RemoteClaimFetcherInterface
{
    /** @var  Client */
    private $httpClient;

    /** @var RemoteClaimRepository */
    private $claimRepo;

    /** @var ClientRepository */
    private $clientRepo;

    /** @var EntityManagerInterface */
    private $em;

    /**
     * RemoteClaimFetcher constructor.
     * @param Client $httpClient
     * @param EntityManagerInterface $em
     * @param RemoteClaimRepository $claimRepository
     * @param ClientRepository $clientRepository
     */
    public function __construct(
        Client $httpClient,
        EntityManagerInterface $em,
        RemoteClaimRepository $claimRepository,
        ClientRepository $clientRepository
    ) {
        $this->em = $em;
        $this->httpClient = $httpClient;
        $this->claimRepo = $claimRepository;
        $this->clientRepo = $clientRepository;
    }

    public function fetchRemoteClaim($claimUri)
    {
        try {
            $uri = HttpUri::createFromString($claimUri);
        } catch (\Exception $e) {
            $claimName = TagUri::createFromString($claimUri);
            $uri = $this->discoverClaimUri($claimName);
        }

        $response = $this->httpClient->get($uri);
        $body = $response->getBody()->__toString();

        $remoteClaim = RemoteClaimParser::parseClaim($body, new RemoteClaim(), new ClaimProvider());

        return $remoteClaim;
    }

    /**
     * @param TagUri $claimName
     * @return string
     */
    public function discoverClaimUri($claimName)
    {
        if (!$claimName instanceof TagUri) {
            $claimName = TagUri::createFromString($claimName);
        }

        $uri = HttpUri::createFromComponents([
            'scheme' => 'https',
            'host' => $claimName->getAuthorityName(),
            'path' => '/.well-known/webfinger',
            'query' => http_build_query([
                'resource' => $claimName->__toString(),
                'rel' => 'http://openid.net/specs/connect/1.0/claim',
            ]),
        ]);

        $response = $this->httpClient->get($uri->__toString());
        $json = json_decode($response->getBody());

        if (property_exists($json, 'links')) {
            foreach ($json->links as $link) {
                if ($link->rel === 'http://openid.net/specs/connect/1.0/claim'
                    && $json->subject === $claimName->__toString()) {
                    return $link->href;
                }
            }
        }

        throw new NotFoundHttpException("Couldn't find the Claim's URI");
    }

    /**
     * Fetches a RemoteClaimInterface via <code>fetchRemoteClaim</code>, persisting and returning the result.
     * @param TagUri|string $claimUri
     * @return RemoteClaimInterface
     * @throws ClaimProviderNotFoundException
     */
    public function getRemoteClaim($claimUri)
    {
        $remoteClaim = $this->fetchRemoteClaim($claimUri);

        $existingClaim = $this->claimRepo->findOneBy(['name' => $remoteClaim->getName()]);
        if ($existingClaim instanceof RemoteClaimInterface) {
            $remoteClaim = $existingClaim;
            $newClaim = false;
        } else {
            $newClaim = true;
        }

        $provider = $this->getExistingClaimProvider($remoteClaim->getProvider());
        if ($provider instanceof ClaimProviderInterface) {
            $remoteClaim->setProvider($provider);
        }

        if ($newClaim) {
            $this->em->persist($remoteClaim);
            $this->em->flush();
        }

        return $remoteClaim;
    }

    /**
     * @param string[] $redirectUris
     * @return ClientInterface
     */
    private function findClaimProvider($redirectUris)
    {
        $clients = $this->clientRepo->findByRedirectUris($redirectUris);

        if (count($clients) > 1) {
            throw new \InvalidArgumentException('Ambiguous redirect_uris. More than one Relying Party found.');
        }

        return empty($clients) ? null : reset($clients);

The expression empty($clients) ? null : reset($clients); of type LoginCidadao\OAuthBundle\Model\ClientInterface|false adds false to the return on line 157 which is incompatible with the return type documented by LoginCidadao\RemoteClaimsBundle\Fetcher\RemoteClaimFetcher::findClaimProvider of type LoginCidadao\OAuthBundle\Model\ClientInterface. It seems like you forgot to handle an error condition.

    }

    /**
     * Gets the persisted/ORM-attached ClaimProvider
     * @param ClaimProviderInterface|null $provider
     * @return ClientInterface|null
     * @throws ClaimProviderNotFoundException
     */
    private function getExistingClaimProvider(ClaimProviderInterface $provider = null)
    {
        $existingProvider = null;
        if ($provider instanceof ClaimProviderInterface) {
            $existingProvider = $this->findClaimProvider($provider->getRedirectUris());
        }

        if ($existingProvider instanceof ClaimProviderInterface) {
            return $existingProvider;
        }

        // No pre-existing provider was found. Throw Exception!
        throw new ClaimProviderNotFoundException(
            "A Claim Provider was not found. This Identity Provider does NOT support Dynamic Claim Provider registration, so make sure it is already registered."
        );
    }
}