mmucklo / DtcGridBundle

Grid/Source/EntityGridSource.php

<?php

namespace Dtc\GridBundle\Grid\Source;

use Doctrine\ORM\EntityManager;

The type Doctrine\ORM\EntityManager was not found. Maybe you did not declare it correctly or list all dependencies?

use Doctrine\ORM\Mapping\ClassMetadata;

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

use Dtc\GridBundle\Grid\Column\GridColumn;

class EntityGridSource extends AbstractDoctrineGridSource
{
    /**
     * @return \Doctrine\ORM\QueryBuilder

The type Doctrine\ORM\QueryBuilder was not found. Maybe you did not declare it correctly or list all dependencies?

     *
     * @throws \Exception
     */
    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 = [];
        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 = [];
            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;
    }

    /**
     * @return \Doctrine\Common\Persistence\Mapping\ClassMetadata

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

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

        return $classInfo;
    }

    /**
     * @return mixed
     *
     * @throws \Exception
     * @throws \Doctrine\ORM\NoResultException
     * @throws \Doctrine\ORM\NonUniqueResultException
     */
    public function getCount()
    {
        $oldOrderBy = $this->orderBy;
        $this->orderBy = [];
        $qb = $this->getQueryBuilder();
        $this->orderBy = $oldOrderBy;

        $qb->add('select', 'count(u)')
            ->setFirstResult(null)
            ->setMaxResults(null);

        return $qb->getQuery()
            ->getSingleScalarResult();
    }

    /**
     * @return array
     *
     * @throws \Exception
     */
    public function getRecords()
    {
        return $this->getQueryBuilder()->getQuery()
            ->getResult();
    }

    /**
     * @param $id
     *
     * @return mixed|null
     *
     * @throws \Exception
     */
    public function find($id)
    {
        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().

        }

        if (!$this->hasIdColumn()) {
            throw new \Exception('No id column found for '.$this->objectName);
        }
        $qb = $this->objectManager->createQueryBuilder();
        $qb->from($this->objectName, 'a');
        $qb->select('a.'.implode(',a.', $this->getClassMetadata()->getFieldNames()));
        $qb->where('a.'.$this->idColumn.' = :id')->setParameter(':id', $id);
        $result = $qb->getQuery()->execute();
        if (isset($result[0])) {
            return $result[0];
        }
    }

    /**
     * @param $id
     *
     * @return bool
     *
     * @throws \Exception|\Doctrine\ORM\OptimisticLockException
     */
    public function remove($id)
    {
        if (!$this->hasIdColumn()) {
            throw new \Exception('No id column found for '.$this->objectName);
        }

        $repository = $this->objectManager->getRepository($this->objectName);
        $entity = $repository->find($id);

        if ($entity) {
            $this->objectManager->remove($entity);
            $this->objectManager->flush();

            return true;
        }

        return false;
    }
}