SovBundle/Repository/AbstractRepositoryQuery.php

<?php

namespace Lc\SovBundle\Repository;

use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\ORM\QueryBuilder;
use Knp\Component\Pager\PaginatorInterface;
use Lc\SovBundle\Doctrine\EntityInterface;

abstract class AbstractRepositoryQuery implements RepositoryQueryInterface
{

    protected ServiceEntityRepository $repository;
    protected QueryBuilder $query;
    protected PaginatorInterface $paginator;
    protected string $id;

    public function __construct(ServiceEntityRepository $repository, string $id, PaginatorInterface $paginator = null)
    {
        $this->repository = $repository;
        $this->query = $repository->createQueryBuilder($id);
        $this->paginator = $paginator;
        $this->id = $id;
    }

    public function __call(string $name, $params): self
    {
        foreach ($params as $key => $value) {
            $this->populateDqlId($params[$key]);
        }

        call_user_func_array([$this->query, $name], $params);

        return $this;
    }

    public function create()
    {
        $class = get_called_class();

        return new $class($this->repository, $this->paginator);
    }

    public function call(callable $fn): self
    {
        $fn($this->query, $this);

        return $this;
    }

    public function count(): string
    {
        return $this->query->getQuery()
                ->getSingleScalarResult();
    }

    public function findOne(): ?EntityInterface
    {
        return $this->query->getQuery()
                ->setMaxResults(1)
                ->getOneOrNullResult();
    }

    public function find(): array
    {
        return $this->query->getQuery()->getResult();
    }

    public function limit(int $maxResults):self
    {
        $this->query->setMaxResults($maxResults);
        return $this;
    }

    public function paginate(int $page = 1, int $limit = 20)
    {
        return $this->paginator->paginate($this->query->getQuery(), $page, $limit);
    }

    public function getRepository(): ServiceEntityRepository
    {
        return $this->repository;
    }

    protected function populateDqlId(&$data)
    {
        if (is_string($data)) {
            $words = explode(' ', $data);

            foreach ($words as $k => $v) {
                if (isset($v[0]) && '.' === $v[0]) {
                    $words[$k] = $this->id . $v;
                }
            }

            $data = implode(' ', $words);
        } elseif (is_array($data)) {
            foreach ($data as $k => $v) {
                $this->populateDqlId($data[$k]);
            }
        }

        return $data;
    }

    public function groupBy(string $field): self
    {
        if (substr($field, 0, 1) === '.') {
            return $this->groupBy($field) ;
        } else {
            return $this->groupBy('.'.$field) ;
        }
    }

    public function orderBy(string $field, string $sort = 'ASC'): self
    {
        if (substr($field, 0, 1) === '.') {
            return $this->addOrderBy($field, $sort);
        } else {
            return $this->addOrderBy('.' . $field, $sort);
        }
    }

    public function filterById(int $id):self
    {
        return $this
                ->andWhere('.id = :id')
                ->setParameter('id', $id);
    }

    public function andWhereEqual($field, $value)
    {
        return $this->andWhere('.'.$field.' = :'.$field)->setParameter($field, $value);
    }

    /*
     *  DEVALIAS
     */
    public function filterByDevAlias(string $devAlias): self
    {
        return $this
                ->andWhere('.devAlias = :devAlias')
                ->setParameter('devAlias', $devAlias);
    }

    /*
     *  SLUG
     */
    public function filterBySlug(string $slug):self
    {
        return $this
                ->andWhere('.slug = :slug')
                ->setParameter('slug', $slug);
    }

    /*
     *  TREE
     */
    public function filterIsParent():self
    {
        return $this->andWhere('.parent is NULL');
    }

    public function filterIsChildren():self
    {
        return $this->andWhere('.parent is NOT NULL');
    }

    public function filterByParent(EntityInterface $parent):self
    {
        return $this->andWhere('.parent = :parent')->setParameter('parent', $parent);
    }

    /*
     *  STATUS
     */
    public function filterIsOffline():self
    {
        return  $this->andWhereStatus($this->id, 0);
    }

    public function filterIsOnline():self
    {
        return  $this->andWhereStatus($this->id, 1);
    }

    public function filterIsDeleted():self
    {
        return  $this->andWhereStatus($this->id, -1);
    }

    public function filterIsOnlineAndOffline():self
    {
        return  $this->andWhere('.status >= 0');
    }
}