UserManager::updateUser() - Code Metrics - Inspection of "Added user.sql" - awurth/silex-user - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 96ea8b...1276b9 )

by Alexis

created 2017-10-22 11:34 UTC

UserManager::updateUser() A

↳ Parent: UserManager

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	2
eloc	5
nc	2
nop	2

<?php

/*
 * This file is part of the awurth/silex-user package.
 *
 * (c) Alexis Wurth <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace AWurth\Silex\User\Model;

use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\Common\Persistence\ObjectRepository;
use Symfony\Component\Security\Core\Encoder\BCryptPasswordEncoder;
use Symfony\Component\Security\Core\Encoder\EncoderFactoryInterface;

class UserManager implements UserManagerInterface
{
    /**
     * @var string
     */
    protected $class;

    /**
     * @var EncoderFactoryInterface
     */
    protected $encoderFactory;

    /**
     * @var ObjectManager
     */
    protected $objectManager;

    /**
     * Constructor.
     *
     * @param ObjectManager           $objectManager
     * @param EncoderFactoryInterface $encoderFactory
     * @param string                  $class
     */
    public function __construct(ObjectManager $objectManager, EncoderFactoryInterface $encoderFactory, $class)
    {
        $this->objectManager = $objectManager;
        $this->encoderFactory = $encoderFactory;
        $this->class = $class;
    }

    /**
     * Gets the Doctrine repository for the User class.
     *
     * @return ObjectRepository
     */
    protected function getRepository()
    {
        return $this->objectManager->getRepository($this->getClass());
    }

    /**
     * {@inheritdoc}
     */
    public function createUser()
    {
        $class = $this->getClass();

        return new $class();
    }

    /**
     * {@inheritdoc}
     */
    public function deleteUser(UserInterface $user)
    {
        $this->objectManager->remove($user);
        $this->objectManager->flush();
    }

    /**
     * {@inheritdoc}
     */
    public function findUserBy(array $criteria)
    {
        return $this->getRepository()->findOneBy($criteria);
    }

    /**
     * {@inheritdoc}
     */
    public function findUserByEmail($email)
    {
        return $this->findUserBy(array('email' => $email));
    }

    /**
     * {@inheritdoc}
     */
    public function findUserByUsername($username)
    {
        return $this->findUserBy(array('username' => $username));
    }

    /**
     * {@inheritdoc}
     */
    public function findUserByUsernameOrEmail($usernameOrEmail)
    {
        if (preg_match('/^.+\@\S+\.\S+$/', $usernameOrEmail)) {
            return $this->findUserByEmail($usernameOrEmail);
        }

        return $this->findUserByUsername($usernameOrEmail);
    }

    /**
     * {@inheritdoc}
     */
    public function findUserByConfirmationToken($token)
    {
        return $this->findUserBy(['confirmationToken' => $token]);
    }

    /**
     * {@inheritdoc}
     */
    public function findUsers()
    {
        return $this->getRepository()->findAll();
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * {@inheritdoc}
     */
    public function getClass()
    {
        return $this->class;
    }

    /**
     * {@inheritdoc}
     */
    public function updatePassword(UserInterface $user)
    {
        $plainPassword = $user->getPlainPassword();

        if (0 === strlen($plainPassword)) {
            return;
        }

        $encoder = $this->encoderFactory->getEncoder($user);
        if ($encoder instanceof BCryptPasswordEncoder) {
            $user->setSalt(null);
        } else {
            $user->setSalt(rtrim(str_replace('+', '.', base64_encode(random_bytes(32))), '='));
        }

        $user->setPassword($encoder->encodePassword($plainPassword, $user->getSalt()));
        $user->eraseCredentials();
    }

    /**
     * {@inheritdoc}
     */
    public function updateUser(UserInterface $user, $flush = true)
    {
        $this->updatePassword($user);

        $this->objectManager->persist($user);
        if ($flush) {
            $this->objectManager->flush();
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the awurth/silex-user package.
5			*
6			* (c) Alexis Wurth <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace AWurth\Silex\User\Model;
13
14			use Doctrine\Common\Persistence\ObjectManager;
15			use Doctrine\Common\Persistence\ObjectRepository;
16			use Symfony\Component\Security\Core\Encoder\BCryptPasswordEncoder;
17			use Symfony\Component\Security\Core\Encoder\EncoderFactoryInterface;
18
19			class UserManager implements UserManagerInterface
20			{
21			/**
22			* @var string
23			*/
24			protected $class;
25
26			/**
27			* @var EncoderFactoryInterface
28			*/
29			protected $encoderFactory;
30
31			/**
32			* @var ObjectManager
33			*/
34			protected $objectManager;
35
36			/**
37			* Constructor.
38			*
39			* @param ObjectManager $objectManager
40			* @param EncoderFactoryInterface $encoderFactory
41			* @param string $class
42			*/
43			public function __construct(ObjectManager $objectManager, EncoderFactoryInterface $encoderFactory, $class)
44			{
45			$this->objectManager = $objectManager;
46			$this->encoderFactory = $encoderFactory;
47			$this->class = $class;
48			}
49
50			/**
51			* Gets the Doctrine repository for the User class.
52			*
53			* @return ObjectRepository
54			*/
55			protected function getRepository()
56			{
57			return $this->objectManager->getRepository($this->getClass());
58			}
59
60			/**
61			* {@inheritdoc}
62			*/
63			public function createUser()
64			{
65			$class = $this->getClass();
66
67			return new $class();
68			}
69
70			/**
71			* {@inheritdoc}
72			*/
73			public function deleteUser(UserInterface $user)
74			{
75			$this->objectManager->remove($user);
76			$this->objectManager->flush();
77			}
78
79			/**
80			* {@inheritdoc}
81			*/
82			public function findUserBy(array $criteria)
83			{
84			return $this->getRepository()->findOneBy($criteria);
85			}
86
87			/**
88			* {@inheritdoc}
89			*/
90			public function findUserByEmail($email)
91			{
92			return $this->findUserBy(array('email' => $email));
93			}
94
95			/**
96			* {@inheritdoc}
97			*/
98			public function findUserByUsername($username)
99			{
100			return $this->findUserBy(array('username' => $username));
101			}
102
103			/**
104			* {@inheritdoc}
105			*/
106			public function findUserByUsernameOrEmail($usernameOrEmail)
107			{
108			if (preg_match('/^.+\@\S+\.\S+$/', $usernameOrEmail)) {
109			return $this->findUserByEmail($usernameOrEmail);
110			}
111
112			return $this->findUserByUsername($usernameOrEmail);
113			}
114
115			/**
116			* {@inheritdoc}
117			*/
118			public function findUserByConfirmationToken($token)
119			{
120			return $this->findUserBy(['confirmationToken' => $token]);
121			}
122
123			/**
124			* {@inheritdoc}
125			*/
126			public function findUsers()
127			{
128			return $this->getRepository()->findAll();
			0 ignored issues – show Bug Best Practice introduced 2017-10-22 11:42 UTC by Report Bug Copy Issue Report The return type of `return $this->getRepository()->findAll();` (`array`) is incompatible with the return type declared by the interface `AWurth\Silex\User\Model\...gerInterface::findUsers` of type `Traversable`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
129			}
130
131			/**
132			* {@inheritdoc}
133			*/
134			public function getClass()
135			{
136			return $this->class;
137			}
138
139			/**
140			* {@inheritdoc}
141			*/
142			public function updatePassword(UserInterface $user)
143			{
144			$plainPassword = $user->getPlainPassword();
145
146			if (0 === strlen($plainPassword)) {
147			return;
148			}
149
150			$encoder = $this->encoderFactory->getEncoder($user);
151			if ($encoder instanceof BCryptPasswordEncoder) {
152			$user->setSalt(null);
153			} else {
154			$user->setSalt(rtrim(str_replace('+', '.', base64_encode(random_bytes(32))), '='));
155			}
156
157			$user->setPassword($encoder->encodePassword($plainPassword, $user->getSalt()));
158			$user->eraseCredentials();
159			}
160
161			/**
162			* {@inheritdoc}
163			*/
164			public function updateUser(UserInterface $user, $flush = true)
165			{
166			$this->updatePassword($user);
167
168			$this->objectManager->persist($user);
169			if ($flush) {
170			$this->objectManager->flush();
171			}
172			}
173			}
174

awurth / silex-user

Push — master ( 96ea8b...1276b9 )

UserManager::updateUser() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like