Bludata\Doctrine\ORM\Repositories\QueryWorker

Complexity

Total Complexity

131

Size/Duplication

Total Lines	814
Duplicated Lines	4.18 %

Coupling/Cohesion

Components	2
Dependencies	0

Importance

Changes

0

34 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getEntityName()	0	4	1
A	getPrimaryKeyEntity()	0	4	1
A	getQuery()	0	10	2
A	getResult()	0	10	2
A	getOneResult()	0	4	1
A	toArray()	0	14	3
A	getClassMetaData()	0	4	1
A	count()	0	4	1
C	withFilters()	0	42	13
A	paginate()	0	12	3
B	whereFieldJoin()	0	25	3
A	andWhere()	11	11	2
A	orWhere()	11	11	2
A	manyToManyJoin()	0	11	2
A	makeExpressions()	0	16	3
B	addGroupBy()	0	19	5
A	andHaving()	0	4	1
A	orHaving()	0	4	1
A	addOrderBy()	12	12	2
A	fkAddOrderBy()	0	8	1
C	select()	0	27	7
A	getPathRepository()	0	4	1
A	getMetaRepository()	0	6	2
C	associationQueryFields()	0	75	20
B	addQueryField()	0	18	5
C	fkAssociation()	0	45	11
A	fieldJoin()	0	17	3
A	fkArrayAssociation()	0	14	3
A	getFkMetaAlias()	0	11	2
A	getSelectExpression()	0	10	3
A	getFullFieldName()	0	4	1
C	makeExpression()	0	70	21
A	tableAlias()	0	4	1

<?php

namespace Bludata\Doctrine\ORM\Repositories;

use Doctrine\ORM\Query;

class QueryWorker
{
    const CUSTOM_FILTERS_KEY = 'custom';

Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space

    const DEFAULT_TABLE_ALIAS = 't';

    /**
     * @var Doctrine\ORM\EntityRepository
     */
    protected $repository;

    /**
     * @var Doctrine\ORM\QueryBuilder
     */
    protected $queryBuilder;

    /**
     * @var Doctrine\ORM\Mapping\ClassMetadata
     */
    protected $classMetadata;

    /**
     * @var array
     */
    protected $entitys = [];

    /**
     * @var array
     */
    protected $queryFields = [];

    public function __construct($repository)
    {
        $this->repository = $repository;

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        $this->queryBuilder = $this->repository->createQueryBuilder(self::DEFAULT_TABLE_ALIAS);

Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space

This line exceeds maximum limit of 80 characters; contains 95 characters

        $this->classMetadata = $this->repository->getClassMetadata();
    }

    /**
     * Retorna o nome da entity.
     *
     * @return string

Should the return type not be string|null?

     */
    public function getEntityName()
    {
        $this->repository->getEntityName();
    }

    /**
     * Retorna a chave primária da entity.
     *
     * @return string
     */
    public function getPrimaryKeyEntity()
    {
        return $this->getClassMetaData()->identifier[0];
    }

    /**
     * @return Doctrine\ORM\Query
     */
    public function getQuery()
    {
        $query = $this->queryBuilder->getQuery();

        if (method_exists($query, 'setHint')) {
            $query->setHint(Query::HINT_INCLUDE_META_COLUMNS, true);
        }

        return $query;
    }

    /**
     * Retorna um array com os objetos do resultado de $this->queryBuilder.
     *
     * @return array
     */
    public function getResult()
    {
        $query = $this->getQuery();

        if (method_exists($query, 'getResult')) {
            return $query->getResult();
        }

        return $query->execute();
    }

    /**
     * Retorna um objeto do resultado de $this->queryBuilder.
     *
     * @return Bludata\Doctrine\ORM\Entities\BaseEntity | null
     */
    public function getOneResult()
    {
        return $this->getQuery()->getOneOrNullResult();
    }

    /**
     * Converte os objetos de $this->getResult() em array.
     *
     * @return array
     */
    public function toArray(array $options = null)
    {
        $array = [];

        foreach ($this->getResult() as $item) {
            if (method_exists($item, 'toArray')) {
                array_push($array, $item->toArray($options));
            } else {
                array_push($array, $item);
            }
        }

        return $array;
    }

    /**
     * @return Doctrine\ORM\Mapping\ClassMetadata
     */
    public function getClassMetaData()
    {
        return $this->classMetadata;
    }

    /**
     * Retorna a quantidade de elementos em $this->getResult().
     *
     * @return int
     */
    public function count()
    {
        return count($this->getResult());
    }

    /**
     * Aplica filtros em $this->queryBuilder.
     *
     * @param array $filters

Should the type for parameter $filters not be null|array?

     *
     * @return Bludata\Doctrine\ORM\Repositories\QueryWorker

Should the return type not be QueryWorker?

     */
    public function withFilters(array $filters = null)
    {
        if ($filters) {
            foreach ($filters as $filter) {
                switch ($filter['type']) {
                    case 'select':
                        $this->select($filter['fields']);
                        break;
                    case 'andWhere':
                        $this->andWhere($filter['field'], $filter['operation'], $filter['value']);

This line exceeds maximum limit of 80 characters; contains 98 characters

                        break;
                    case 'orWhere':
                        $this->orWhere($filter['field'], $filter['operation'], $filter['value']);

This line exceeds maximum limit of 80 characters; contains 97 characters

                        break;
                    case 'andHaving':
                        $this->andHaving($filter['field'], $filter['operation'], $filter['value']);

This line exceeds maximum limit of 80 characters; contains 99 characters

                        break;
                    case 'orHaving':
                        $this->orHaving($filter['field'], $filter['operation'], $filter['value']);

This line exceeds maximum limit of 80 characters; contains 98 characters

                        break;
                    case 'addGroupBy':
                        $this->addGroupBy($filter['field']);
                        break;
                    case 'addOrderBy':
                        $this->addOrderBy($filter['field'], $filter['order']);
                        break;
                    case 'fkAddOrderBy':
                        $this->fkAddOrderBy($filter['field'], $filter['fkField'], $filter['order']);

This line exceeds maximum limit of 80 characters; contains 100 characters

                        break;
                    case 'paginate':
                        if (isset($filter['page'])) {
                            $this->paginate($filter['limit'], $filter['page']);
                        } else {
                            $this->paginate($filter['limit']);
                        }
                        break;
                }
            }
        }

        return $this;
    }

    /**
     * Set the page with paginate attribute.
     *
     * @param int $page
     * @param int $limit
     *
     * @return $this
     */
    public function paginate($limit = 25, $page = 0)
    {
        if ($limit > 0) {
            $this->queryBuilder->setMaxResults($limit);
        }

        if ($page > 0) {
            $this->queryBuilder->setFirstResult($page * $limit);
        }

        return $this;
    }

    /**
     * Add  joins.
     *
     * @param string $field
     *
     * @return $array

The doc-type $array could not be parsed: Unknown type name "$array" at position 0. (view supported doc-types)

     */
    private function whereFieldJoin($field, $value = null, $operation = null)
    {
        $arr = explode('.', $field);

Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space

        $tempField = end($arr);
        $alias = prev($arr);

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

            // verifica se está solicitando um many to many
            $meta = $this->getClassMetaData();
        if (!empty($meta->associationMappings[$alias]['joinTable'])) {
            $table = $this->getFullFieldName($meta->associationMappings[$alias]['fieldName'], self::DEFAULT_TABLE_ALIAS);

This line exceeds maximum limit of 80 characters; contains 121 characters

            $alias = $this->tableAlias();
            if (!$operation) {
                $operation = '=';

Consider using a different name than the parameter $operation. This often makes code more readable.

            }
            $condicao = $this->makeExpression($tempField, $operation, $value, $alias);

This line exceeds maximum limit of 80 characters; contains 86 characters

            $this->queryBuilder->leftJoin($table, $alias, 'WITH', $condicao);

            return ['alias' => $alias, 'field' => $tempField];
        }
            //monta os joins
            $this->associationQueryFields($field);
            //monta os dados do where
            $field = $tempField;

Consider using a different name than the parameter $field. This often makes code more readable.

        return ['alias' => $alias, 'field' => $field];
    }

    /**
     * Add a "and where" filter.
     *
     * @param string $field
     * @param string $operation
     * @param string $value

Should the type for parameter $value not be string|null?

     *
     * @return $this
     */
    public function andWhere($field, $operation, $value = null, $alias = self::DEFAULT_TABLE_ALIAS)

This method seems to be duplicated in your project.

This line exceeds maximum limit of 80 characters; contains 99 characters

    {
        if (strpos($field, '.') > 0) {
            $newValues = $this->whereFieldJoin($field, $value, $operation);
            $alias = $newValues['alias'];

Consider using a different name than the parameter $alias. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

            $field = $newValues['field'];

Consider using a different name than the parameter $field. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

        }
        $this->queryBuilder->andWhere($this->makeExpression($field, $operation, $value, $alias));

It seems like $value defined by parameter $value on line 255 can also be of type string; however, Bludata\Doctrine\ORM\Repositories\QueryWorker::makeExpression() does only seem to accept null, maybe add an additional type check?

This line exceeds maximum limit of 80 characters; contains 97 characters

        return $this;
    }

    /**
     * Add a "or where" filter.
     *
     * @param string $field
     * @param string $operation
     * @param string $value

Should the type for parameter $value not be string|null?

     *
     * @return $this
     */
    public function orWhere($field, $operation, $value = null, $alias = self::DEFAULT_TABLE_ALIAS)

This method seems to be duplicated in your project.

This line exceeds maximum limit of 80 characters; contains 98 characters

    {
        if (strpos($field, '.') > 0) {
            $newValues = $this->whereFieldJoin($field, $value, $operation);
            $alias = $newValues['alias'];

Consider using a different name than the parameter $alias. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

            $field = $newValues['field'];

Consider using a different name than the parameter $field. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

        }
        $this->queryBuilder->orWhere($this->makeExpression($field, $operation, $value, $alias));

It seems like $value defined by parameter $value on line 276 can also be of type string; however, Bludata\Doctrine\ORM\Repositories\QueryWorker::makeExpression() does only seem to accept null, maybe add an additional type check?

This line exceeds maximum limit of 80 characters; contains 96 characters

        return $this;
    }

    /**
     * Add a join filter.
     *
     * @param array  $meta
     * @param string $alias
     *
     * @return $this
     */
    public function manyToManyJoin($meta, $alias, $defaultAlias = self::DEFAULT_TABLE_ALIAS)

This line exceeds maximum limit of 80 characters; contains 92 characters

    {
        $table = $this->getFullFieldName($meta->associationMappings[$alias]['fieldName'], $defaultAlias);

This line exceeds maximum limit of 80 characters; contains 105 characters

        if (!in_array($table, $this->entitys)) {
            $this->queryBuilder->join($table, $alias);
            $this->entitys[] = $table;
        }

        return $this;
    }

    /**
     * Create an array of expressions.
     *
     * @param array $conditions
     *
     * @return $this

Should the return type not be array?

     */
    private function makeExpressions($conditions, $alias = self::DEFAULT_TABLE_ALIAS)

This line exceeds maximum limit of 80 characters; contains 85 characters

    {
        $expressions = [];
        foreach ($conditions as $attr) {
            $field = $attr['field'];
            if (strpos($field, '.') > 0) {
                $newValues = $this->whereFieldJoin($field, $attr['value'], $attr['operation']);

This line exceeds maximum limit of 80 characters; contains 95 characters

                $alias = $newValues['alias'];

Consider using a different name than the parameter $alias. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

                $field = $newValues['field'];

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

            }

            $expressions[] = $this->makeExpression($field, $attr['operation'], $attr['value'], $alias);

This line exceeds maximum limit of 80 characters; contains 103 characters

        }

        return $expressions;
    }

    /**
     * Add a "group by" key.
     *
     * @param string $field
     */
    public function addGroupBy($field)
    {
        $alias = self::DEFAULT_TABLE_ALIAS;

Equals sign not aligned with surrounding assignments; expected 9 spaces but found 1 space

        $newAliasField = $this->fieldJoin($this->getClassMetaData(), $field, $alias);

This line exceeds maximum limit of 80 characters; contains 85 characters

        $alias = $newAliasField['alias'];

Equals sign not aligned with surrounding assignments; expected 9 spaces but found 1 space

        $field = $newAliasField['field'];

Consider using a different name than the parameter $field. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 9 spaces but found 1 space

        if (count($this->queryFields) > 0) {
            if (!in_array($this->getFullFieldName($field, $alias), $this->queryFields)) {

This line exceeds maximum limit of 80 characters; contains 89 characters

                $this->queryFields[] = $this->getFullFieldName($field, $alias);
            }
            foreach ($this->queryFields as $item) {
                if (strpos($item, '(') === false) {
                    $this->queryBuilder->addGroupBy($item);
                }
            }
        }

        return $this;
    }

    /**
     * Add a "and having" filter.
     *
     * @param string $field
     * @param string $operation
     * @param string $value

Should the type for parameter $value not be string|null?

     *
     * @return $this
     */
    public function andHaving($field, $operation, $value = null)

The parameter $field is not used and could be removed.

The parameter $operation is not used and could be removed.

The parameter $value is not used and could be removed.

    {
        throw new \Exception('Not implemented');
    }

    /**
     * Add a "or having" filter.
     *
     * @param string $field
     * @param string $order

There is no parameter named $order. Was it maybe removed?

     */
    public function orHaving($field, $operation, $value = null)

The parameter $field is not used and could be removed.

The parameter $operation is not used and could be removed.

The parameter $value is not used and could be removed.

    {
        throw new \Exception('Not implemented');
    }

    /**
     * Add a "order by" filter.
     *
     * @param string $field
     * @param string $order
     */
    public function addOrderBy($field, $order = 'ASC')

This method seems to be duplicated in your project.

    {
        $alias = self::DEFAULT_TABLE_ALIAS;
        if (strpos($field, '.') > 0) {
            $newValues = $this->whereFieldJoin($field);
            $alias = $newValues['alias'];

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

            $field = $newValues['field'];

Consider using a different name than the parameter $field. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

        }
        $this->queryBuilder->addOrderBy($this->getFullFieldName($field, $alias), $order);

This line exceeds maximum limit of 80 characters; contains 89 characters

        return $this;
    }

    /**
     * Add a "order by" filter.
     *
     * @param string $field
     * @param string $order
     */
    public function fkAddOrderBy($field, $fkField, $order = 'ASC')
    {
        $alias = $this->tableAlias();
        $this->queryBuilder->join($this->getFullFieldName($field), $alias);
        $this->queryBuilder->addOrderBy($this->getFullFieldName($fkField, $alias), $order);

This line exceeds maximum limit of 80 characters; contains 91 characters

        return $this;
    }

    /**
     * Add a select statement.
     *
     * @param associationField.fkField
     * @param $field
     */
    public function select($fields)
    {
        foreach ($fields as $key => $value) {
            if (is_int($key)) {
                $valor = $value;
                if (is_array($value)) {
                    if (!empty($value['expression'])) {
                        //é uma expressão
                        $expression = ['expression' => $value['expression'], 'alias' => $value['alias']];

This line exceeds maximum limit of 80 characters; contains 105 characters

                        $valor = $value['field'];

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

                        $this->associationQueryFields($valor, $expression);

$expression is of type array<string,?,{"expression":"?","alias":"?"}>, but the function expects a integer.

                    }
                } else {
                    $this->associationQueryFields($valor);
                }
            } elseif (is_array($value)) {
                $alias = $this->tableAlias();
                $this->queryBuilder->join($this->getFullFieldName($key, self::DEFAULT_TABLE_ALIAS), $alias);

This line exceeds maximum limit of 80 characters; contains 108 characters

                foreach ($value as $valueField) {
                    $this->queryFields[] = $this->getFullFieldName($valueField, $alias);

This line exceeds maximum limit of 80 characters; contains 88 characters

                }
            }
        }
        $this->queryBuilder->select(implode(',', $this->queryFields));

        return $this;
    }

    /**
     * get the repository.
     *
     * @param associationField.fkField
     */
    private function getPathRepository($newEntity)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return app()->getRepositoryInterface($newEntity);
    }

    /**
     * get the class metadata.
     *
     * @param associationField.fkField
     */
    private function getMetaRepository($entity)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $repository = $this->getPathRepository($entity);

        return $repository ? $repository->getClassMetaData() : [];
    }

    /**
     * Add association join and select fields.
     *
     * @param associationField.fkField
     * @param $field
     */
    public function associationQueryFields($value, $expression = 0)
    {
        $pos = strpos($value, '.');
        if ($pos > 0) {
            $fk = substr($value, 0, $pos);

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

            $field = substr($value, ($pos + 1));
            $alias = $fk;
            if (substr_count($value, '.') > 1) {
                // tem mais de um join para chegar ao campo
                $count = 0;

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

                $arr = explode('.', $value);

Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space

                $field = end($arr);

$field is not used, you could remove the assignment.

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

                $fkTemp = $fk;

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

                $arrLength = count($arr);
                foreach ($arr as $key => $entity) {
                    if ($count == 0) {
                        $campo = $this->fkAssociation($this->getClassMetaData(), $entity, $arr[$count + 1], $entity, self::DEFAULT_TABLE_ALIAS);

This line exceeds maximum limit of 80 characters; contains 144 characters

                        if ($campo && !in_array($campo, $this->queryFields)) {
                            if ($expression == 0) {
                                $this->queryFields[] = $campo;
                            }
                        }
                    } elseif (($count + 1) < $arrLength) {
                        if ($this->getPathRepository(ucfirst($fkTemp))) {
                            $meta = $this->getMetaRepository(ucfirst($fkTemp));

Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space

                            $campo = $this->fkAssociation($meta, $entity, $arr[$count + 1], $entity, $fkTemp);

This line exceeds maximum limit of 80 characters; contains 110 characters

                        } else {
                            //busca a entidade correta
                            if ($count > 1) {
                                $metaAnterior = null;
                                $fkAnterior = ucfirst($arr[$count - 2]);

Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space

                                //verifica se a entidade anterior era um oneToMany

This line exceeds maximum limit of 80 characters; contains 82 characters

                                if (count($this->getPathRepository($fkAnterior)) == 0) {

This line exceeds maximum limit of 80 characters; contains 88 characters

                                    //verifica se havia uma entidade antes
                                    if (!empty($arr[$count - 3])) {
                                        $fkAnterior = ucfirst($arr[$count - 3]);
                                    } else {
                                        // pega a entidade default
                                        $fkAnterior = self::DEFAULT_TABLE_ALIAS;

Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space

                                        $metaAnterior = $meta;

The variable $meta does not seem to be defined for all execution paths leading up to this point.

                                    }
                                }
                                $metaAlias = $this->getFkMetaAlias($fkAnterior, $fkTemp, $metaAnterior);

This line exceeds maximum limit of 80 characters; contains 104 characters

                            } else {
                                $metaAlias = $this->getFkMetaAlias(self::DEFAULT_TABLE_ALIAS, $fkTemp, $this->getClassMetaData());

This line exceeds maximum limit of 80 characters; contains 130 characters

                            }
                            $fkTemp = $metaAlias['alias'];
                            $meta = $this->getMetaRepository(ucfirst($fkTemp));

Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space

                            $campo = $this->fkAssociation($meta, $entity, $arr[$count + 1], $entity, $fkTemp);

Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space

This line exceeds maximum limit of 80 characters; contains 110 characters

                        }
                        if ($campo && ($expression == 0 || ($expression != 0 && $count == ($arrLength - 1)))) {

This line exceeds maximum limit of 80 characters; contains 111 characters

                            $this->addQueryField($campo, $expression);
                        }
                    }
                    $fkTemp = $entity;
                    ++$count;
                }
            } else {
                if (empty($this->getClassMetaData()->associationMappings[$fk]) && count($this->getClassMetaData()->subClasses) > 0) {

This line exceeds maximum limit of 80 characters; contains 133 characters

                    //ignorado não é possível criar o join, provavelmente está no pai chamando o filho.

This line exceeds maximum limit of 80 characters; contains 103 characters

                    return $this;
                }
                // realiza o join para retornar o valor do campo
                $campo = $this->fkAssociation($this->getClassMetaData(), $fk, $field, $alias, self::DEFAULT_TABLE_ALIAS);

This line exceeds maximum limit of 80 characters; contains 121 characters

                $this->addQueryField($campo, $expression);
            }
        } else {
            $valor = $this->getFullFieldName($value);
            if (!empty($this->getClassMetaData()->associationMappings[$value])) {

This line exceeds maximum limit of 80 characters; contains 81 characters

                // é uma FK, retorna o ID
                $valor = 'IDENTITY('.$valor.') '.$value;
            }
            $this->addQueryField($valor, $expression);
        }
    }

    /**
     * Add a field or expression in the select array.
     *
     * @param string field
     * @param mix expression
     */
    private function addQueryField($campo, $expression = 0)
    {
        if ($campo && !in_array($campo, $this->queryFields)) {
            if ($expression == 0) {
                $this->queryFields[] = $campo;
            } else {
                //verifica se pode adicionar a expressão
                if (strpos($campo, ')') === false) {
                    $this->getSelectExpression($expression['expression'], $campo, $expression['alias']);

This line exceeds maximum limit of 80 characters; contains 104 characters

                } else {
                    $parts = explode(')', $campo);
                    //remove o alias
                    array_pop($parts);
                    $this->getSelectExpression($expression['expression'], implode(')', $parts), $expression['alias']);

This line exceeds maximum limit of 80 characters; contains 118 characters

                }
            }
        }
    }

    /**
     * Add a join statement.
     *
     * @todo  ignorar registros com deletedAt == true

Comment refers to a TODO task

     * @todo  validar a associação a partir do aluno: processos.ordensServico.servicoOrdemServico.itensServicoOrdemServico.itemServico

Comment refers to a TODO task

This line exceeds maximum limit of 80 characters; contains 134 characters

     *
     * @param $meta - getClassMetaData
     * @param $fk
     * @param $field
     * @param $alias
     * @param $defaultAlias
     */
    public function fkAssociation($meta, $fk, $field, $alias, $defaultAlias)
    {
        if ($association = $meta->associationMappings[$fk]) {
            if (!in_array($association['targetEntity'], $this->entitys)) {
                if (!empty($association['joinColumns'])) {
                    $condition = $this->getFullFieldName($association['fieldName'], $defaultAlias).' = '.$this->getFullFieldName($association['joinColumns'][0]['referencedColumnName'], $alias);

This line exceeds maximum limit of 80 characters; contains 193 characters

                    $this->queryBuilder->leftJoin($association['targetEntity'], $alias, 'WITH', $condition);

This line exceeds maximum limit of 80 characters; contains 108 characters

                    $this->queryBuilder->andWhere($condition);
                    $this->entitys[] = $association['targetEntity'];
                } else {
                    //está buscando de um arrayCollection
                    $repository = explode('\\', $association['targetEntity']);
                    if (!$association['mappedBy']) {
                        if (!empty($association['joinTable'])) {
                            $this->manyToManyJoin($meta, $fk, $defaultAlias);

                            return $this->getFullFieldName($field, $fk);
                        }

                        return;
                    }
                    $meta = $this->getMetaRepository(end($repository));

Consider using a different name than the parameter $meta. This often makes code more readable.

                    return $this->fkArrayAssociation($meta, $association['mappedBy'], $field, lcfirst(end($repository)), $defaultAlias, $association['targetEntity']);

This line exceeds maximum limit of 80 characters; contains 166 characters

                }
            }

            //verifica se o campo existe
            if ($this->getPathRepository(ucfirst($fk))) {
                $meta = $this->getMetaRepository(ucfirst($fk));

Consider using a different name than the parameter $meta. This often makes code more readable.

            } else {
                //busca a entidade correta
                $metaAlias = $this->getFkMetaAlias($defaultAlias, $fk, $meta);
                $meta = $metaAlias['meta'];

Consider using a different name than the parameter $meta. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

                $alias = $metaAlias['alias'];

Consider using a different name than the parameter $alias. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

            }
            if (empty($meta->associationMappings[$field]) && empty($meta->fieldMappings[$field])) {

This line exceeds maximum limit of 80 characters; contains 99 characters

                return;
            } elseif (!empty($meta->associationMappings[$field]) && empty($meta->associationMappings[$field]['joinColumns'])) {

This line exceeds maximum limit of 80 characters; contains 127 characters

                return;
            }
            //retorna o campo
            return '('.$this->getFullFieldName($field, $alias).') AS '.$this->getFullFieldName($field, $alias, '_');

This line exceeds maximum limit of 80 characters; contains 116 characters

        }
    }

    /**
     * Add joins and return the new field and alias.
     *
     * @param $meta - getClassMetaData
     * @param $field
     * @param $alias
     *
     * @return array
     */
    public function fieldJoin($meta, $field, $alias)
    {
        if (strpos($field, '.') > 0) {
            $arr = explode('.', $field);

Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space

            $fieldTemp = end($arr);
            $alias = prev($arr);

Consider using a different name than the parameter $alias. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

            if (!empty($meta->associationMappings[$alias]['joinTable'])) {
                $this->manyToManyJoin($meta, $alias);
            } else {
                //monta os joins
                $this->associationQueryFields($field);
            }
            $field = $fieldTemp;

Consider using a different name than the parameter $field. This often makes code more readable.

        }

        return ['alias' => $alias, 'field' => $field];
    }

    /**
     * @TODO GROUP_CONCAT()

Comment refers to a TODO task

     * Add a join statement from array collection
     *
     * @param $meta - getClassMetaData
     * @param $fk
     * @param $field
     * @param $alias
     * @param $defaultAlias
     * @param $targetEntity
     */
    public function fkArrayAssociation($meta, $fk, $field, $alias, $defaultAlias, $targetEntity)

This line exceeds maximum limit of 80 characters; contains 96 characters

    {
        if ($association = $meta->associationMappings[$fk]) {
            if (!in_array($targetEntity, $this->entitys)) {
                $condition = $this->getFullFieldName($association['fieldName'], $alias).' = '.

This line exceeds maximum limit of 80 characters; contains 94 characters

                $this->getFullFieldName($association['joinColumns'][0]['referencedColumnName'], $defaultAlias);

This line exceeds maximum limit of 80 characters; contains 111 characters

                $this->queryBuilder->join($targetEntity, $alias, 'WITH', $condition);

This line exceeds maximum limit of 80 characters; contains 85 characters

                $this->queryBuilder->andWhere($condition);
                $this->entitys[] = $targetEntity;
            }

            return '('.$this->getFullFieldName($field, $alias).') AS '.$this->getFullFieldName($field, $alias, '_');

This line exceeds maximum limit of 80 characters; contains 116 characters

        }
    }

    /**
     * @param string $alias
     * @param string $fk
     * @param array  $meta

Should the type for parameter $meta not be array|null?

     *
     * @return array
     */
    public function getFkMetaAlias($alias, $fk, $meta = null)
    {
        if (self::DEFAULT_TABLE_ALIAS != $alias) {
            $meta = $this->getMetaRepository(ucfirst($alias));

Consider using a different name than the parameter $meta. This often makes code more readable.

        }
        $repository = explode('\\', $meta->associationMappings[$fk]['targetEntity']);

This line exceeds maximum limit of 80 characters; contains 85 characters

        $meta = $this->getMetaRepository(end($repository));

Consider using a different name than the parameter $meta. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space

        $alias = lcfirst(end($repository));

Consider using a different name than the parameter $alias. This often makes code more readable.

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

        return ['meta' => $meta, 'alias' => $alias];
    }

    /**
     * @param mixed  $field
     * @param string $expression
     * @param string $alias
     */
    private function getSelectExpression($expression, $field, $alias, $fieldAlias = self::DEFAULT_TABLE_ALIAS)

This line exceeds maximum limit of 80 characters; contains 110 characters

    {
        $validExpressions = ['SUM', 'MIN', 'MAX', 'AVG', 'COUNT'];
        if (in_array(trim(strtoupper($expression)), $validExpressions)) {
            if (strpos($field, '.') === false) {
                $field = getFullFieldName($field, $fieldAlias);

Consider using a different name than the parameter $field. This often makes code more readable.

            }
            $this->queryFields[] = sprintf('%s(%s) AS %s', $expression, $field, $alias);

This line exceeds maximum limit of 80 characters; contains 88 characters

        }
    }

    /**
     * @param $field
     * @param string $alias
     *
     * @return string
     */
    protected function getFullFieldName($field, $alias = self::DEFAULT_TABLE_ALIAS, $separator = '.')

This line exceeds maximum limit of 80 characters; contains 101 characters

    {
        return sprintf('%s%s%s', $alias, $separator, $field);
    }

    /**
     * @param $field
     * @param $operation
     * @param null   $value
     * @param string $alias
     */
    protected function makeExpression($field, $operation, $value = null, $alias = self::DEFAULT_TABLE_ALIAS)

The return type could not be reliably inferred; please add a @return annotation.

This line exceeds maximum limit of 80 characters; contains 108 characters

    {
        if (!is_array($value)) {
            $value = $this->queryBuilder->expr()->literal($value);

Consider using a different name than the parameter $value. This often makes code more readable.

        }
        if ($field) {
            $field = $this->getFullFieldName($field, $alias);

Consider using a different name than the parameter $field. This often makes code more readable.

        }
        $expression = null;
        switch (strtolower($operation)) {
            case '>':
                $expression = $this->queryBuilder->expr()->gt($field, $value);
                break;
            case '=':
                $expression = $this->queryBuilder->expr()->eq($field, $value);
                break;
            case '<':
                $expression = $this->queryBuilder->expr()->lt($field, $value);
                break;
            case '>=':
                $expression = $this->queryBuilder->expr()->gte($field, $value);
                break;
            case '<=':
                $expression = $this->queryBuilder->expr()->lte($field, $value);
                break;
            case '<>':
                $expression = $this->queryBuilder->expr()->neq($field, $value);
                break;
            case 'isnull':
                $expression = $this->queryBuilder->expr()->isNull($field);
                break;
            case 'isnotnull':
                $expression = $this->queryBuilder->expr()->isNotNull($field);
                break;
            case 'in':
                $expression = $this->queryBuilder->expr()->in($field, $value);
                break;
            case 'orx':
                $expression = $this->queryBuilder->expr()->orX()->addMultiple($this->makeExpressions($value, $alias));

This line exceeds maximum limit of 80 characters; contains 118 characters

                break;
            case 'andx':
                $expression = $this->queryBuilder->expr()->andX()->addMultiple($this->makeExpressions($value, $alias));

This line exceeds maximum limit of 80 characters; contains 119 characters

                break;
            case 'notin':
                $expression = $this->queryBuilder->expr()->notIn($field, $value);

This line exceeds maximum limit of 80 characters; contains 81 characters

                break;
            case 'contains':
                /*
                 * @todo implementar o metodo contains

Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker.

                 */
                // $expression = $this->queryBuilder->expr()->contains($field, $value);

62% of this comment could be valid code. Did you maybe forget this after debugging?

This line exceeds maximum limit of 80 characters; contains 87 characters

                break;
            case 'like':
                $expression = $this->queryBuilder->expr()->like('LOWER('.$field.')', strtolower($value));

This line exceeds maximum limit of 80 characters; contains 105 characters

                break;
            case 'notlike':
                $expression = $this->queryBuilder->expr()->notLike($field, $value);

This line exceeds maximum limit of 80 characters; contains 83 characters

                break;
            case 'isinstanceof':
                $expression = $alias.' INSTANCE OF '.$value;
                break;
            case 'between':
                $expression = $this->queryBuilder->expr()->between($field, $this->queryBuilder->expr()->literal($value[0]), $this->queryBuilder->expr()->literal($value[1]));

This line exceeds maximum limit of 80 characters; contains 173 characters

                break;
            case 'dateparteq':
                $expression = $this->queryBuilder->expr()->eq("DATEPART('".$value['format']."', ".$field.')', $value['value']);

This line exceeds maximum limit of 80 characters; contains 127 characters

        }

        return $expression;
    }

    /**
     * @return string
     */
    protected function tableAlias()
    {
        return self::DEFAULT_TABLE_ALIAS.count($this->queryBuilder->getAllAliases());

This line exceeds maximum limit of 80 characters; contains 85 characters

    }
}