Dtc\GridBundle\Grid\Source\DocumentGridSource

Complexity

Total Complexity

27

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Importance

Changes	4
Bugs	1	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	remove()	0	15	3
A	getClassMetadata()	0	6	1
A	find()	0	13	4
C	getQueryBuilder()	0	62	16
A	__construct()	0	4	1
A	getCount()	0	5	1
A	getRecords()	0	3	1

<?php

namespace Dtc\GridBundle\Grid\Source;

use Doctrine\ODM\MongoDB\DocumentManager;

The type Doctrine\ODM\MongoDB\DocumentManager was not found. Maybe you did not declare it correctly or list all dependencies?

use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;

The type Doctrine\ODM\MongoDB\Mapping\ClassMetadata was not found. Maybe you did not declare it correctly or list all dependencies?

use Dtc\GridBundle\Grid\Column\GridColumn;

class DocumentGridSource extends AbstractDoctrineGridSource
{
    protected $repository;
    protected $findCache;

    public function __construct(DocumentManager $documentManager, $documentName)
    {
        parent::__construct($documentManager, $documentName);
        $this->repository = $documentManager->getRepository($documentName);
    }

    /**
     * @return \Doctrine\ODM\MongoDB\Query\Builder

The type Doctrine\ODM\MongoDB\Query\Builder was not found. Maybe you did not declare it correctly or list all dependencies?

     *
     * @throws \Exception
     */
    protected function getQueryBuilder()
    {
        if (!$this->objectManager instanceof DocumentManager) {
            throw new \Exception("Should be DocumentManager, instead it's ".get_class($this->objectManager));
        }
        $qb = $this->objectManager->createQueryBuilder($this->objectName);

        /** @var ClassMetadata $classMetaData */
        $classMetaData = $this->getClassMetadata();
        $classFields = $classMetaData->fieldMappings;

        $columns = $this->getColumns();
        $fieldList = [];
        foreach ($columns as $column) {
            if ($column instanceof GridColumn && $column->isSearchable()) {
                $fieldList[$column->getField()] = true;
            }
        }
        if ($this->filter) {

The expression $this->filter of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $validFilters = array_intersect_key($this->filter, $classFields);

            $query = [];
            foreach ($validFilters as $key => $value) {
                if (isset($fieldList[$key])) {
                    if (is_array($value)) {
                        $qb->field($key)->in($value);
                    } else {
                        $qb->field($key)->equals($value);
                    }
                }
            }
            if (!$query) {

The expression $query of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

$query is an empty array, thus ! $query is always true.

                $starFilter = array_intersect_key($this->filter, ['*' => null]);
                if ($starFilter) {

The expression $starFilter of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                    $value = current($starFilter);
                    foreach ($classFields as $key => $info) {
                        if (isset($fieldList[$key])) {
                            $expr = $qb->expr()->field($key);
                            switch ($info['type']) {
                                case 'integer':
                                    $expr = $expr->equals(intval($value));
                                    break;
                                default:
                                    $expr = $expr->equals($value);
                            }
                            $qb->addOr($expr);
                        }
                        // @TODO - maybe allow pattern searches some day: new \MongoRegex('/.*'.$value.'.*/')
                    }
                }
            }
        }
        if ($this->orderBy) {

The expression $this->orderBy of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($this->orderBy as $key => $direction) {
                $qb->sort($key, $direction);
            }
        }

        $qb->limit($this->limit);
        $qb->skip($this->offset);

        return $qb;
    }

    /**
     * @return mixed
     *
     * @throws \Exception
     */
    public function getClassMetadata()
    {
        $metaFactory = $this->objectManager->getMetadataFactory();
        $classInfo = $metaFactory->getMetadataFor($this->objectName);

        return $classInfo;
    }

    /**
     * @return mixed
     *
     * @throws \Doctrine\ODM\MongoDB\MongoDBException
     * @throws \Exception
     */
    public function getCount()
    {
        $result = $this->getQueryBuilder()->limit(0)->skip(0)->count()->getQuery()->execute();

        return $result;
    }

    /**
     * @return mixed
     *
     * @throws \Doctrine\ODM\MongoDB\MongoDBException
     * @throws \Exception
     */
    public function getRecords()
    {
        return $this->getQueryBuilder()->getQuery()->execute()->toArray(false);
    }

    /**
     * @param $id
     *
     * @return mixed|null
     *
     * @throws \Exception
     */
    public function find($id)
    {
        if (!$this->objectManager instanceof DocumentManager) {
            throw new \Exception('should be DocumentManager, instead'.get_class($this->objectManager));
        }
        if (!$this->hasIdColumn()) {
            throw new \Exception('No id column found for '.$this->objectName);
        }
        $qb = $this->objectManager->createQueryBuilder($this->objectName);
        $qb->field($this->idColumn)->equals($id);
        $result = $qb->getQuery()->execute()->toArray(false);
        if (isset($result[0])) {
            return $result[0];
        }
    }

    /**
     * @param $id
     * @param bool   $soft
     * @param string $softColumn
     * @param string $softColumnType
     *
     * @return bool
     *
     * @throws \Exception
     */
    public function remove($id, $soft = false, $softColumn = 'deletedAt', $softColumnType = 'datetime')
    {
        if (!$this->hasIdColumn()) {
            throw new \Exception('No id column found for '.$this->objectName);
        }
        $repository = $this->objectManager->getRepository($this->objectName);
        $document = $repository->find($id);
        if ($document) {
            $this->objectManager->remove($document);
            $this->objectManager->flush();

            return true;
        }

        return false;
    }
}