Dtc\GridBundle\Grid\Source\EntityGridSource::getQueryBuilder()

Complexity

Conditions	17
Paths	73

Size

Total Lines	76
Code Lines	48

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

<?php
    protected function getQueryBuilder()
    {
        if (!$this->objectManager instanceof EntityManager) {
            throw new \Exception("Expected EntityManager, instead it's: ", get_class($this->objectManager));

get_class($this->objectManager) of type string is incompatible with the type integer expected by parameter $code of Exception::__construct().

        }

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

        $qb = $this->objectManager->createQueryBuilder();
        $orderBy = array();
        foreach ($this->orderBy as $key => $value) {
            $orderBy[] = "u.{$key} {$value}";
        }

        $qb->add('select', 'u')
            ->add('from', "{$this->objectName} u")
            ->setFirstResult($this->offset)
            ->setMaxResults($this->limit);

        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.

            $orderByStr = implode(',', $orderBy);
            $qb->add('orderBy', $orderByStr);
        }

        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.

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

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

            $query = array();
            foreach ($validFilters as $key => $value) {
                if (isset($fieldList[$key])) {
                    if (is_array($value)) {
                        $query[] = "u.{$key} IN :{$key}";
                    } else {
                        $query[] = "u.{$key} = :{$key}";
                    }
                }
                $qb->setParameter($key, $value);
            }
            if ($query) {
                $qb->add('where', implode(' and ', $query));
            } else {
                $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);
                    $starQuery = [];
                    foreach (array_keys($classFields) as $key) {
                        if (isset($fieldList[$key])) {
                            $starQuery[] = "u.{$key} like :{$key}";
                            $qb->setParameter($key, $value);
                        }
                    }

                    if ($starQuery) {
                        $star = implode(' or ', $starQuery);

                        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 is always false.

                            $qb->andWhere($star);
                        } else {
                            $qb->add('where', $star);
                        }
                    }
                }
            }
        }

        return $qb;
    }