UserRepository::loadUserByUsername()   B
last analyzed

Complexity

Conditions 2
Paths 2

Size

Total Lines 24
Code Lines 18

Duplication

Lines 0
Ratio 0 %
Metric Value
dl 0
loc 24
rs 8.9713
cc 2
eloc 18
nc 2
nop 1
1
<?php
2
namespace Vivait\AuthBundle\Entity;
3
4
use Symfony\Component\Security\Core\User\UserInterface;
5
use Symfony\Component\Security\Core\User\UserProviderInterface;
6
use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
7
use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
8
use Doctrine\ORM\EntityRepository;
9
use Doctrine\ORM\NoResultException;
10
11
class UserRepository extends EntityRepository implements UserProviderInterface {
12
	public function loadUserByUsername($username) {
13
		$q = $this
14
			->createQueryBuilder('u')
15
			->select('u, g, t')
16
			->leftJoin('u.groups', 'g')
17
			->leftJoin('u.tenants', 't')
18
			->where('(LOWER(u.username) = :username OR LOWER(u.email) = :email)')
19
			->setParameter('username', $username)
20
			->setParameter('email', $username)
21
			->getQuery();
22
		try {
23
			// The Query::getSingleResult() method throws an exception
24
			// if there is no record matching the criteria.
25
			$user = $q->getSingleResult();
26
		} catch (NoResultException $e) {
0 ignored issues
show
Bug introduced by
The class Doctrine\ORM\NoResultException does not exist. Did you forget a USE statement, or did you not list all dependencies?

Scrutinizer analyzes your composer.json/composer.lock file if available to determine the classes, and functions that are defined by your dependencies.

It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis.

Loading history...
27
			$message = sprintf(
28
				'Unable to find an active user object identified by "%s".',
29
				$username
30
			);
31
			throw new UsernameNotFoundException($message, 0, $e);
32
		}
33
34
		return $user;
35
	}
36
37
	public function findAllFull() {
0 ignored issues
show
Documentation introduced by
The return type could not be reliably inferred; please add a @return annotation.

Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a @return annotation as described here.

Loading history...
38
		return $this
39
			->createQueryBuilder('u')
40
			->select('u, g, t')
41
			->leftJoin('u.groups', 'g')
42
			->leftJoin('u.tenants', 't')
43
			->getQuery();
44
	}
45
46
	public function refreshUser(UserInterface $user) {
47
		$class = get_class($user);
48
		if (!$this->supportsClass($class)) {
49
			throw new UnsupportedUserException(
50
				sprintf(
51
					'Instances of "%s" are not supported.',
52
					$class
53
				)
54
			);
55
		}
56
57
		return $this->find($user->getId());
0 ignored issues
show
Bug introduced by
It seems like you code against a concrete implementation and not the interface Symfony\Component\Security\Core\User\UserInterface as the method getId() does only exist in the following implementations of said interface: Vivait\AuthBundle\Entity\User.

Let’s take a look at an example:

interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break.

Available Fixes

  1. Change the type-hint for the parameter:

    class AuthSystem
    {
        public function authenticate(MyUser $user) { /* ... */ }
    }
    
  2. Add an additional type-check:

    class AuthSystem
    {
        public function authenticate(User $user)
        {
            if ($user instanceof MyUser) {
                $this->logger->info(/** ... */);
            }
    
            // or alternatively
            if ( ! $user instanceof MyUser) {
                throw new \LogicException(
                    '$user must be an instance of MyUser, '
                   .'other instances are not supported.'
                );
            }
    
        }
    }
    
Note: PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case.
  1. Add the method to the interface:

    interface User
    {
        /** @return string */
        public function getPassword();
    
        /** @return string */
        public function getDisplayName();
    }
    
Loading history...
58
	}
59
60
	public function supportsClass($class) {
61
		return $this->getEntityName() === $class
62
					 || is_subclass_of($class, $this->getEntityName());
63
	}
64
}
65
66
?>
0 ignored issues
show
Best Practice introduced by
It is not recommended to use PHP's closing tag ?> in files other than templates.

Using a closing tag in PHP files that only contain PHP code is not recommended as you might accidentally add whitespace after the closing tag which would then be output by PHP. This can cause severe problems, for example headers cannot be sent anymore.

A simple precaution is to leave off the closing tag as it is not required, and it also has no negative effects whatsoever.

Loading history...
67