Kunstmaan\AdminBundle\Service\UserManager

Complexity

Total Complexity

22

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	deleteUser()	0	5	1
A	findUsers()	0	4	1
A	getRepository()	0	4	1
A	getClass()	0	9	2
A	reloadUser()	0	4	1
A	updateUser()	0	9	2
A	updatePassword()	0	21	3
A	createUser()	0	7	1
A	findUserByUsernameOrEmail()	0	11	3
A	findUserByEmail()	0	4	1
A	findUserBy()	0	4	1
A	findUserByUsername()	0	4	1
A	findUserByConfirmationToken()	0	4	1
A	changePassword()	0	13	1
A	setResetToken()	0	7	1

<?php

namespace Kunstmaan\AdminBundle\Service;

use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Kunstmaan\AdminBundle\Entity\UserInterface;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Core\Encoder\BCryptPasswordEncoder;
use Symfony\Component\Security\Core\Encoder\EncoderFactoryInterface;

class UserManager
{
    /** @var EntityManagerInterface */
    private $em;

    /** @var string */
    private $class;

    /** @var string */
    private $encoderFactory;

    public function __construct(EncoderFactoryInterface $encoderFactory, EntityManagerInterface $em, string $class)
    {
        $this->em = $em;
        $this->class = $class;
        $this->encoderFactory = $encoderFactory;

It seems like $encoderFactory of type object<Symfony\Component\Security\Core\Encoder\EncoderFactoryInterface> is incompatible with the declared type string of property $encoderFactory.

    }

    public function deleteUser(UserInterface $user)
    {
        $this->em->remove($user);
        $this->em->flush();
    }

    public function findUsers()
    {
        return $this->getRepository()->findAll();
    }

    protected function getRepository(): EntityRepository
    {
        return $this->em->getRepository($this->getClass());
    }

    public function getClass()
    {
        if (false !== strpos($this->class, ':')) {
            $metadata = $this->em->getClassMetadata($this->class);
            $this->class = $metadata->getName();
        }

        return $this->class;
    }

    public function reloadUser(UserInterface $user)
    {
        $this->em->refresh($user);
    }

    public function updateUser(UserInterface $user, $andFlush = true)
    {
        $this->updatePassword($user);

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

    public function updatePassword(UserInterface $user)
    {
        $plainPassword = $user->getPlainPassword();

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

        $encoder = $this->encoderFactory->getEncoder($user);

The method getEncoder cannot be called on $this->encoderFactory (of type string).

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

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

    public function createUser()
    {
        $class = $this->getClass();
        $user = new $class();

        return $user;
    }

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

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

    public function findUserByEmail($email)
    {
        return $this->findUserBy(['email' => $email]);
    }

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

    public function findUserByUsername($username)
    {
        return $this->findUserBy(['username' => $username]);
    }

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

    /**
     * Change the user password and update the security token
     */
    public function changePassword(UserInterface $user, string $newPassword)
    {
        $encoder = $this->encoderFactory->getEncoder($user);

The method getEncoder cannot be called on $this->encoderFactory (of type string).

        $password = $encoder->encodePassword($user, $newPassword);

        $user->setPassword($password);
        $user->setConfirmationToken(null);
        $this->em->flush();

        $token = new UsernamePasswordToken($user, $password, 'main');
        $this->tokenStorage->setToken($token);

The property tokenStorage does not exist. Did you maybe forget to declare it?

        $this->session->set('_security_main', serialize($token));

The property session does not exist. Did you maybe forget to declare it?

    }

    public function setResetToken(UserInterface $user)
    {
        $token = bin2hex(random_bytes(32));
        $user->setConfirmationToken($token);

        $this->em->flush();
    }
}