Cdf\BiCoreBundle\Utils\Tabella\TabellaQueryTrait

Complexity

Total Complexity

24

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Test Coverage

Coverage

95.92%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	orderByBuilder()	0	7	2
B	recursiveJoin()	0	32	9
B	buildWhere()	0	48	7
A	biQueryBuilder()	0	12	1
A	getRecordstabella()	0	36	5

<?php

namespace Cdf\BiCoreBundle\Utils\Tabella;

use Doctrine\ORM\Tools\Pagination\Paginator;
use function count;

trait TabellaQueryTrait
{
    protected function biQueryBuilder()
    {
        $nometabellaalias = $this->generaAlias($this->tablename);

It seems like generaAlias() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $qb = $this->em->createQueryBuilder()
                ->select(array($nometabellaalias))
                ->from($this->entityname, $nometabellaalias);
        $campi = array_keys($this->em->getMetadataFactory()->getMetadataFor($this->entityname)->reflFields);
        $this->recursiveJoin($qb, $campi, $this->tablename, $nometabellaalias);
        $this->buildWhere($qb);
        $this->orderByBuilder($qb);

        return $qb;
    }

    protected function recursiveJoin(&$qb, $campi, $nometabella, $alias, $ancestors = array())
    {
        foreach ($campi as $campo) {
            if (false !== strpos(strtolower($campo), 'relatedby')) {
                continue;
            }
            if (!in_array($nometabella, $ancestors)) {
                $ancestors[] = $nometabella;
            }

            $configurazionecampo = isset($this->configurazionecolonnetabella[ucfirst(implode('.', $ancestors)).'.'.$campo]) ?
                    $this->configurazionecolonnetabella[ucfirst(implode('.', $ancestors)).'.'.$campo] : false;
            if ($configurazionecampo && true === $configurazionecampo['association']) {
                // crea la relazione con $padre = $nometabella in corso e figlio = $nomecampo con $alias generato
                if ((isset($configurazionecampo['sourceentityclass'])) && (null !== $configurazionecampo['sourceentityclass'])) {
                    $entitysrc = $configurazionecampo['sourceentityclass'];
                    $nometabellasrc = $this->em->getClassMetadata($entitysrc)->getTableName();
                } else {
                    $nometabellasrc = $nometabella;
                }

                $entitytarget = $configurazionecampo['associationtable']['targetEntity'];
                $nometabellatarget = $this->em->getClassMetadata($entitytarget)->getTableName();
                $aliastarget = $this->generaAlias($nometabellatarget, $nometabellasrc, $ancestors);
                //$qb->leftJoin($alias . "." . $configurazionecampo["nomecampo"], $aliastarget);
                //$camporelazionejoin = strtolower(substr($configurazionecampo["nomecampo"], strpos($configurazionecampo["nomecampo"], ".") + 1));
                $parti = explode('.', $configurazionecampo['nomecampo']);

                $camporelazionejoin = strtolower($parti[count($parti) - 1]);
                $qb->leftJoin($alias.'.'.$camporelazionejoin, $aliastarget);
                $campitarget = array_keys($this->em->getMetadataFactory()->getMetadataFor($entitytarget)->reflFields);
                $this->recursiveJoin($qb, $campitarget, $nometabellatarget, $aliastarget, $ancestors);

                // lancia rescursiveJoin su questo campo con padre = $aliasgenerato
                // --- figlio = $nomecampo
                // --- alias = alias generato nuovo
            }
        }
    }

    protected function buildWhere(&$qb)
    {
        $filtro = '';

The assignment to $filtro is dead and can be removed.

        $prefiltro = '';

The assignment to $prefiltro is dead and can be removed.

        foreach ($this->prefiltri as $key => $prefiltro) {
            $this->prefiltri[$key]['prefiltro'] = true;

The property prefiltri does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }
        foreach ($this->filtri as $key => $filtro) {
            $this->filtri[$key]['prefiltro'] = false;

The property filtri does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }
        $tuttifiltri = array_merge($this->filtri, $this->prefiltri);
        $parametribag = array();
        if (count($tuttifiltri)) {
            $descrizionefiltri = '';
            foreach ($tuttifiltri as $num => $filtrocorrente) {
                $tablename = substr($filtrocorrente['nomecampo'], 0, strripos($filtrocorrente['nomecampo'], '.'));
                $alias = $this->findAliasByTablename($tablename);

It seems like findAliasByTablename() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                $fieldname = $alias.'.'.(substr($filtrocorrente['nomecampo'], strripos($filtrocorrente['nomecampo'], '.') + 1));
                $fieldvalue = $this->getFieldValue($filtrocorrente['valore']);

It seems like getFieldValue() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                $fieldoperator = $this->getOperator($filtrocorrente['operatore']);

It seems like getOperator() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                $fitrocorrenteqp = 'fitrocorrente'.$num;
                $filtronomecampocorrente = $this->findFieldnameByAlias($filtrocorrente['nomecampo']);

It seems like findFieldnameByAlias() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                $criteria = new ParametriQueryTabellaDecoder(
                    $fieldname,
                    $fieldoperator,
                    $fieldvalue,
                    $fitrocorrenteqp,
                    $filtronomecampocorrente
                );

                $querycriteria = $criteria->getQueryCriteria();
                $queryparameter = $criteria->getQueryParameters();

                if ($querycriteria) {
                    $qb->andWhere($querycriteria);
                    $parametribag = array_merge($queryparameter, $parametribag);
                } else {
                    $qb->andWhere($fieldname.' '.$fieldoperator.' '.":$fitrocorrenteqp");
                    $parametribag = array_merge(array($fitrocorrenteqp => $fieldvalue), $parametribag);
                }
                $this->getDescrizioneFiltro($descrizionefiltri, $filtrocorrente, $criteria);

It seems like getDescrizioneFiltro() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            }
            $this->traduzionefiltri = substr($descrizionefiltri, 2);

The property traduzionefiltri does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }
        $qb->setParameters($parametribag);

        if (isset($this->wheremanuale)) {
            $qb->andWhere($this->wheremanuale);
        }
    }

    protected function orderByBuilder(&$qb)
    {
        foreach ($this->colonneordinamento as $nomecampo => $tipoordinamento) {
            $tablename = substr($nomecampo, 0, strripos($nomecampo, '.'));
            $alias = $this->getAliasGenerato($tablename);

It seems like getAliasGenerato() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $fieldname = $alias.'.'.(substr($nomecampo, strripos($nomecampo, '.') + 1));
            $qb->addOrderBy($fieldname, $tipoordinamento);
        }
    }

    public function getRecordstabella()
    {
        $qb = $this->biQueryBuilder();

        if (false === $this->estraituttirecords) {

The property estraituttirecords does not exist on Cdf\BiCoreBundle\Utils\Tabella\TabellaQueryTrait. Did you mean records?

            $paginator = new Paginator($qb, true);
            $this->righetotali = count($paginator);

The property righetotali does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            $this->paginetotali = (int) $this->calcolaPagineTotali($this->getRigheperpagina());

The property paginetotali does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

It seems like getRigheperpagina() must be provided by classes using this trait. How about adding it as abstract method to this trait?

It seems like calcolaPagineTotali() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            /* imposta l'offset, ovvero il record dal quale iniziare a visualizzare i dati */
            $offsetrecords = ($this->getRigheperpagina() * ($this->getPaginacorrente() - 1));

It seems like getPaginacorrente() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            /* Imposta il limite ai record da estrarre */
            if ($this->getRigheperpagina()) {
                $qb = $qb->setMaxResults($this->getRigheperpagina());
            }
            /* E imposta il primo record da visualizzare (per la paginazione) */
            if ($offsetrecords) {
                $qb = $qb->setFirstResult($offsetrecords);
            }
            /* Dall'oggetto querybuilder si ottiene la query da eseguire */
            $recordsets = $qb->getQuery()->getResult();
        } else {
            /* Dall'oggetto querybuilder si ottiene la query da eseguire */
            $recordsets = $qb->getQuery()->getResult();
            $this->righetotali = count($recordsets);
            $this->paginetotali = 1;
        }

        $this->records = array();

The property records does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $rigatabellahtml = array();
        foreach ($recordsets as $record) {
            $this->records[$record->getId()] = $record;
            unset($rigatabellahtml);
        }

        return $this->records;
    }
}