Moo\FlashCardBundle\Repository\Card

Complexity

Total Complexity

16

Size/Duplication

Total Lines	228
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

96.25%

Importance

Changes	4
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getPaginator()	0	4	1
A	fetchCardsBy()	0	4	1
A	fetchCards()	0	4	1
A	setPaginator()	0	6	1
A	getQueryAllCards()	0	11	1
A	getQuerySearchCards()	0	15	1
A	getQueryBy()	0	22	3
A	searchForOne()	0	15	3
A	findOneBySlugJoinedToCategory()	0	15	2
B	fetchRadomCards()	0	24	1
A	incrementViews()	0	6	1

<?php

/*
 * This file is part of the Moo\FlashCardBundle package.
 *
 * (c) Mohamed Alsharaf <mohamed.alsharaf@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Moo\FlashCardBundle\Repository;

use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\NoResultException;
use Moo\FlashCardBundle\Entity;
use Knp\Bundle\PaginatorBundle\Definition\PaginatorAwareInterface;
use Knp\Component\Pager\Paginator;

/**
 * Card is a repository class for the card entity.
 *
 * @author Mohamed Alsharaf <mohamed.alsharaf@gmail.com>
 */
class Card extends EntityRepository implements PaginatorAwareInterface
{
    /**
     * @var Paginator
     */
    private $paginator;

    /**
     * Set the KnpPaginator instance.
     *
     * @param Paginator $paginator
     *
     * @return $this
     */
    public function setPaginator(Paginator $paginator)
    {
        $this->paginator = $paginator;

        return $this;
    }

    /**
     * Return the KnpPaginator instance.
     *
     * @return Paginator
     */
    public function getPaginator()
    {
        return $this->paginator;
    }

    /**
     * Return query to select all active cards
     *
     * @return \Doctrine\ORM\QueryBuilder
     */
    public function getQueryAllCards()
    {
        $query = $this->getEntityManager()->createQueryBuilder();
        $query->select('p, c')->from('MooFlashCardBundle:Card', 'p');
        $query->join('p.category', 'c');
        $query->where('p.active = 1');
        $query->where('c.active = 1');
        $query->orderBy('p.id', 'ASC');

        return $query;
    }

    /**
     * Return query to search for active cards
     *
     * @param string $search
     *
     * @return \Doctrine\ORM\QueryBuilder
     */
    public function getQuerySearchCards($search)
    {
        $query = $this->getEntityManager()->createQueryBuilder();
        $query->select('p, c')->from('MooFlashCardBundle:Card', 'p');
        $query->join('p.category', 'c');
        $query->where('p.content LIKE :name');
        $query->orWhere('p.title LIKE :name');
        $query->orWhere('p.slug LIKE :name');
        $query->andWhere('p.active = 1');
        $query->andWhere('c.active = 1');
        $query->setParameter('name', '%' . $search . '%');
        $query->orderBy('p.id', 'ASC');

        return $query;
    }

    /**
     * Return query to search cards by a specific criteria.
     * - Cards by category
     * - Cards by keyword
     * - All cards
     *
     * @param array $criteria
     *
     * @return \Knp\Component\Pager\Pagination\PaginationInterface
     */
    public function getQueryBy(array $criteria)
    {
        $query = '';
        $category = 0;
        extract($criteria);

        // Search query or all cards
        if ($query !== '') {
            $cards = $this->getQuerySearchCards($query);
        } else {
            $cards = $this->getQueryAllCards();
        }

        // Filter query by category ID
        if ($category > 0) {
            $cards = $cards
                ->where('c.id = :category')
                ->setParameter('category', $category);
        }

        return $cards;
    }

    /**
     * Return paginated cards by a specific criteria.
     * - Cards by category
     * - Cards by keyword
     * - All cards
     *
     * @param array $criteria
     * @param int   $page
     * @param int   $limit
     *
     * @throws \LogicException
     *
     * @return \Knp\Component\Pager\Pagination\PaginationInterface
     */
    public function fetchCardsBy(array $criteria, $page = 1, $limit = 20)
    {
        return $this->getPaginator()->paginate($this->getQueryBy($criteria), $page, $limit);
    }

    /**
     * Return all cards paginated
     *
     * @param int $page
     * @param int $limit
     *
     * @throws \LogicException
     *
     * @return \Knp\Component\Pager\Pagination\PaginationInterface
     */
    public function fetchCards($page = 1, $limit = 20)
    {
        return $this->fetchCardsBy([], $page, $limit);
    }

    /**
     * Search for a card by keyword
     *
     * @param string $search
     *
     * @return null|\Moo\FlashCardBundle\Entity\Card
     */
    public function searchForOne($search)
    {
        if (empty($search)) {
            return null;
        }

        try {
            return $this->getQuerySearchCards($search)
                ->setMaxResults(1)
                ->getQuery()
                ->getSingleResult();
        } catch (NoResultException $e) {
            return null;
        }
    }

    /**
     * Search for a card by a slug
     *
     * @param string $slug
     *
     * @return null|\Moo\FlashCardBundle\Entity\Card
     */
    public function findOneBySlugJoinedToCategory($slug)
    {
        $query = $this->getEntityManager()->createQueryBuilder();
        $query->select('p, c')->from('MooFlashCardBundle:Card', 'p');
        $query->join('p.category', 'c');
        $query->where('p.slug = :slug');
        $query->setParameter('slug', $slug);
        $query->setMaxResults(1);

        try {
            return $query->getQuery()->getSingleResult();
        } catch (NoResultException $e) {
            return null;
        }
    }

    /**
     * Return random cards
     *
     * @param int $limit
     *
     * @return array
     */
    public function fetchRadomCards($limit = 30)
    {
        $em = $this->getEntityManager();

        // retrieve the highest card id
        $max = $em->createQuery('SELECT MAX(c.id) FROM MooFlashCardBundle:Card c')
            ->getSingleScalarResult();

        // get random cards
        $query = $this->getEntityManager()->createQueryBuilder();
        $query->select('p, c')->from('MooFlashCardBundle:Card', 'p');
        $query->join('p.category', 'c');
        $query->where('p.id >= :rand');
        $query->andWhere('p.active = 1');
        $query->andWhere('c.active = 1');
        $query->setParameter('rand', mt_rand(0, $max - $limit));
        $query->setMaxResults($limit);
        $query->orderBy('p.id', 'ASC');

        $cards = $query->getQuery()->getResult();
        shuffle($cards);

        return $cards;
    }

    /**
     * Update card view counter by 1
     *
     * @param \Moo\FlashCardBundle\Entity\Card $card
     */
    public function incrementViews(Entity\Card $card)
    {
        $card->setViews($card->getViews() + 1);
        $em = $this->getEntityManager();
        $em->flush();
    }
}