Del\Repository\UserRepository

Complexity

Total Complexity

18

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	checkCriteriaForRegistrationDate()	0	5	2
A	checkCriteriaForState()	0	5	2
A	save()	0	8	2
A	checkCriteriaForEmail()	0	8	2
A	delete()	0	7	2
A	findByCriteria()	0	17	4
A	checkCriteriaForLastLoginDate()	0	5	2
A	checkCriteriaForId()	0	8	2

<?php

namespace Del\Repository;

use Del\Criteria\UserCriteria;
use Del\Entity\UserInterface;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\QueryBuilder;

class UserRepository extends EntityRepository
{
    /** @var QueryBuilder $qb */
    private $qb;

    /**
     * @param UserInterface $user
     * @return UserInterface
     * @throws \Exception
     */
    public function save(UserInterface $user)
    {
        if(!$user->getID()) {

The expression $user->getID() of type integer|null is loosely compared to false; this is ambiguous if the integer can be 0. You might want to explicitly use === null instead.

            $this->_em->persist($user);
        }
        $this->_em->flush($user);
        $this->_em->flush($user->getPerson());
        return $user;
    }

    /**
     * @param UserInterface $user
     * @param bool $deletePerson
     * @throws \Exception
     */
    public function delete(UserInterface $user, $deletePerson = false)
    {
        if($deletePerson) {
            $this->_em->remove($user->getPerson());
        }
        $this->_em->remove($user);
        $this->_em->flush($user);
    }

    /**
     * @param UserCriteria $criteria
     * @return UserCriteria
     */
    private function checkCriteriaForId(UserCriteria $criteria)
    {
        if($criteria->hasId()) {
            $this->qb->where('u.id = :id');
            $this->qb->setParameter('id', $criteria->getId());
            $criteria->setLimit(1);
        }
        return $criteria;
    }

    /**
     * @param UserCriteria $criteria
     * @return UserCriteria
     */
    private function checkCriteriaForEmail(UserCriteria $criteria)
    {
        if($criteria->hasEmail()) {
            $this->qb->where('u.email = :email');
            $this->qb->setParameter('email', $criteria->getEmail());
            $criteria->setLimit(1);
        }
        return $criteria;
    }

    private function checkCriteriaForState(UserCriteria $criteria)
    {
        if($criteria->hasState()) {
            $this->qb->andWhere('u.state = :state');
            $this->qb->setParameter('state', $criteria->getState());
        }
    }

    private function checkCriteriaForRegistrationDate(UserCriteria $criteria)
    {
        if($criteria->hasRegistrationDate()) {
            $this->qb->andWhere('u.registrationDate = :regdate');
            $this->qb->setParameter('regdate', $criteria->getRegistrationDate());
        }
    }

    private function checkCriteriaForLastLoginDate(UserCriteria $criteria)
    {
        if($criteria->hasLastLoginDate()) {
            $this->qb->andWhere('u.lastLoginDate = :lastlogin');
            $this->qb->setParameter('lastlogin', $criteria->getLastLoginDate());
        }
    }

    /**
     * @param UserCriteria $criteria
     * @return array
     */
    public function findByCriteria(UserCriteria $criteria)
    {
        $this->qb = $this->createQueryBuilder('u');

        $criteria = $this->checkCriteriaForId($criteria);
        $criteria = $this->checkCriteriaForEmail($criteria);
        $this->checkCriteriaForState($criteria);
        $this->checkCriteriaForRegistrationDate($criteria);
        $this->checkCriteriaForLastLoginDate($criteria);

        $criteria->hasOrder() ? $this->qb->addOrderBy('u.'.$criteria->getOrder(),$criteria->getOrderDirection()) : null;
        $criteria->hasLimit() ? $this->qb->setMaxResults($criteria->getLimit()) : null;
        $criteria->hasOffset() ? $this->qb->setFirstResult($criteria->getOffset()) : null;

        $query = $this->qb->getQuery();

        return $query->getResult();

The expression return $query->getResult() also could return the type integer which is incompatible with the documented return type array.

    }
}