Auth\Repository\User

Complexity

Total Complexity

28

Size/Duplication

Total Lines	260
Duplicated Lines	6.54 %

Coupling/Cohesion

Components	2
Dependencies	10

Importance

Changes	4
Bugs	0	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
B	findBy()	0	16	5
A	find()	0	4	1
A	findOneBy()	9	9	3
A	createQueryBuilder()	8	8	2
A	create()	0	11	1
A	findByProfileIdentifier()	0	4	2
A	isProfileAssignedToAnotherUser()	0	14	1
A	findByLogin()	0	5	1
A	findByEmail()	0	14	1
A	findByLoginOrEmail()	0	11	1
A	findByToken()	0	9	1
A	findByIds()	0	8	1
A	findByQuery()	0	16	2
A	copyUserInfo()	0	5	1
B	assertEntity()	0	9	5

<?php
/**
 * YAWIK
 *
 * @filesource
 * @copyright (c) 2013 - 2016 Cross Solution (http://cross-solution.de)
 * @license   MIT
 */

namespace Auth\Repository;

use \Auth\Entity\Info;
use Auth\Entity\UserInterface;
use Core\Repository\AbstractRepository;
use Doctrine\ODM\MongoDB\Event\LifecycleEventArgs;
use Doctrine\ODM\MongoDB\Events;
use Auth\Exception\UserDeactivatedException;

/**
 * class for accessing a user
 */
class User extends AbstractRepository
{

    /**
     * {@inheritDoc}
     */
    public function findBy(array $criteria, array $sort = null, $limit = null, $skip = null)
    {
        if (!array_key_exists('isDraft', $criteria)) {
            $criteria['isDraft'] = false;
        } elseif (null === $criteria['isDraft']) {
            unset($criteria['isDraft']);
        }
        
        if (!array_key_exists('status.name', $criteria)) {
            $criteria['status.name'] = \Jobs\Entity\StatusInterface::ACTIVE;
        } elseif (null === $criteria['status.name']) {
            unset($criteria['status.name']);
        }
        
        return parent::findBy($criteria, $sort, $limit, $skip);
    }
    
    /**
     * Finds a document by its identifier
     *
     * @param string|object $id The identifier
     * @param int $lockMode
     * @param int $lockVersion

Should the type for parameter $lockVersion not be integer|null?

     * @param array $options
     * @throws Mapping\MappingException
     * @throws LockException
     * @throws UserDeactivatedException
     * @return null | UserInterface

Should the return type not be null|UserInterface?

     */
    public function find($id, $lockMode = \Doctrine\ODM\MongoDB\LockMode::NONE, $lockVersion = null, array $options = [])
    {
        return $this->assertEntity(parent::find($id, $lockMode, $lockVersion), $options);
    }

    /**
     * @param array $criteria
     * @param array $options
     * @throws UserDeactivatedException
     * @return null | UserInterface

Should the return type not be null|UserInterface?

     */
    public function findOneBy(array $criteria, array $options = [])

This method seems to be duplicated in your project.

    {
        if (!array_key_exists('isDraft', $criteria)) {
            $criteria['isDraft'] = false;
        } elseif (null === $criteria['isDraft']) {
            unset($criteria['isDraft']);
        }
        return $this->assertEntity(parent::findOneBy($criteria), $options);
    }
    

    /**
     * {@inheritDoc}
     */
    public function createQueryBuilder($findDrafts = false)

This method seems to be duplicated in your project.

    {
        $qb = parent::createQueryBuilder();
        if (null !== $findDrafts) {
            $qb->field('isDraft')->equals($findDrafts);
        }
        return $qb;
    }

    /**
     * Creates a User
     *
     * @see \Core\Repository\AbstractRepository::create()
     * @return UserInterface

Should the return type not be \Core\Entity\EntityInterface?

     */
    public function create(array $data = null)
    {
        $entity = parent::create($data);
        
        $eventArgs = new LifecycleEventArgs($entity, $this->dm);
        $this->dm->getEventManager()->dispatchEvent(
            Events::postLoad,
            $eventArgs
        );
        return $entity;
    }
    
    /**
     * Finds user by profile identifier
     *
     * @param string $identifier
     * @param string $provider
     * @param array $options
     * @return UserInterface

Should the return type not be UserInterface|null?

     */
    public function findByProfileIdentifier($identifier, $provider, array $options = [])
    {
        return $this->findOneBy(array('profiles.' . $provider . '.auth.identifier' => $identifier), $options) ?: $this->findOneBy(array('profile.identifier' => $identifier), $options);
    }
    
    /**
     * Returns true if profile is already assigned to anotherUser
     *
     * @param int $curentUserId
     * @param string $identifier
     * @param string $provider
     * @return bool
     */
    public function isProfileAssignedToAnotherUser($curentUserId, $identifier, $provider)
    {
        $qb = $this->createQueryBuilder(null);

null is of type null, but the function expects a boolean.

        $qb->field('_id')->notEqual($curentUserId)
            ->addAnd(
                $qb->expr()
                    ->addOr($qb->expr()->field('profiles.' . $provider . '.auth.identifier' )->equals($identifier))
                    ->addOr($qb->expr()->field('profile.identifier')->equals($identifier))
            );
        
        return $qb->count()
            ->getQuery()
            ->execute() > 0;
    }
    
    /**
     * Finds user by login name
     *
     * @param string $login
     * @param array $options
     * @return UserInterface

Should the return type not be UserInterface|null?

     */
    public function findByLogin($login, array $options = [])
    {
        $entity = $this->findOneBy(array('login' => $login), $options);
        return $entity;
    }

    /**
     * @param      $email
     * @param bool $isDraft
     *
     * @return UserInterface|null
     */
    public function findByEmail($email, $isDraft = false)
    {
        $entity = $this->findOneBy(
            array(
            '$or' => array(
                array('email' => $email),
                array('info.email' => $email),
            ),
            'isDraft' => $isDraft,
            )
        );

        return $entity;
    }

    /**
     * Finds user by login name or email
     *
     * @param string $identity
     * @param string $suffix
     *
     * @return UserInterface|null
     */
    public function findByLoginOrEmail($identity, $suffix = '')
    {
        return $this->findOneBy(
            array(
            '$or' => array(
                array('login' => $identity . $suffix),
                array('info.email' => $identity)
            )
            )
        );
    }

    /**
     * Find an user by a token hash.
     *
     * @param string $tokenHash
     *
     * @return UserInterface|null
     */
    public function findByToken($tokenHash)
    {
        $criteria = array(
            'isDraft' => null,
            'tokens.hash' => $tokenHash
        );

        return $this->findOneBy($criteria);
    }
    
    /**
     * Finds user by internal id
     *
     * @param array $ids
     * @return \MongoCursor

Should the return type not be array?

     */
    public function findByIds(array $ids)
    {
        return $this->findBy(
            array(
            '_id' => array('$in' => $ids)
            )
        );
    }
    
    /**
     * Find user by query
     *
     * @param String $query
     * @deprecated since 0.19 not used anymore and probably broken.
     * @return object
     */
    public function findByQuery($query)
    {
        $qb = $this->createQueryBuilder();
        $parts  = explode(' ', trim($query));
        
        foreach ($parts as $q) {
            $regex = new \MongoRegex('/^' . $query . '/i');
            $qb->addOr($qb->expr()->field('info.firstName')->equals($regex));
            $qb->addOr($qb->expr()->field('info.lastName')->equals($regex));
            $qb->addOr($qb->expr()->field('info.email')->equals($regex));
        }
        $qb->sort(array('info.lastName' => 1))
           ->sort(array('info.email' => 1));
        
        return $qb->getQuery()->execute();
    }
    
    /**
     * Copy user info into the applications info Entity
     *
     * @param \Auth\Entity\Info $info
     */
    public function copyUserInfo(Info $info)
    {
        $contact = new Info();
        $contact->fromArray(Info::toArray($info));

The method toArray() does not seem to exist on object<Auth\Entity\Info>.

The method fromArray() does not seem to exist on object<Auth\Entity\Info>.

    }
    
    /**
     * @param UserInterface $user

Should the type for parameter $user not be null|UserInterface?

     * @param array $options
     * @throws UserDeactivatedException
     * @return null | UserInterface

Should the return type not be null|UserInterface?

     */
    protected function assertEntity(UserInterface $user = null, array $options)

Parameters which have default values should be placed at the end.

    {
        if (isset($user) && (!isset($options['allowDeactivated']) || !$options['allowDeactivated']) && !$user->isActive())
        {
            throw new UserDeactivatedException(sprintf('User with ID %s is not active', $user->getId()));
        }
        
        return $user;
    }
}