JoinFactory::join() - Code Metrics - Inspection of "Feature/refactor and or filter" - studiomado/query-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — 2.4 (#144)

by Alessandro

created 2018-05-29 18:49 UTC

JoinFactory::join() B

↳ Parent: JoinFactory

Complexity

Conditions	7
Paths	12

Size

Total Lines	58
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	58
rs	7.6045
c	0
b	0
f	0
cc	7
eloc	35
nc	12
nop	2

How to fix Long Method

<?php

namespace Mado\QueryBundle\Queries;

use Doctrine\ORM\EntityManager;
use Mado\QueryBundle\Services\StringParser;

class JoinFactory
{
    private const AND_OPERATOR_LOGIC = 'AND';

    private const OR_OPERATOR_LOGIC = 'OR';

    private $parser;

    private $entityName;

    private $entityAlias;

    private $manager;

    private $innerJoin;

    private $leftJoin;

    private $joins;

    private $relationEntityAlias;

    public function __construct(string $entityName, string $entityAlias, EntityManager $manager)
    {
        $this->parser  = new StringParser();
        $this->entityName = $entityName;
        $this->entityAlias = $entityAlias;
        $this->manager = $manager;
        $this->innerJoin = [];
        $this->leftJoin = [];
        $joins = [];

    }

    /**
     * @param String $relation Nome della relazione semplice (groups.name) o con embedded (_embedded.groups.name)
     * @return $this
     */
    public function join(String $relation, $logicOperator = self::AND_OPERATOR_LOGIC)
    {
        $relation = explode('|', $relation)[0];
        $relations = [$relation];

        if (strstr($relation, '_embedded.')) {
            $embeddedFields = explode('.', $relation);
            $this->parser->camelize($embeddedFields[1]);

            // elimino l'ultimo elemento che dovrebbe essere il nome del campo
            unset($embeddedFields[count($embeddedFields) - 1]);

            // elimino il primo elemento _embedded
            unset($embeddedFields[0]);

            $relations = $embeddedFields;
        }

        $entityName = $this->entityName;
        $entityAlias = $this->entityAlias;

        foreach ($relations as $relation) {
            $relation = $this->parser->camelize($relation);
            $relationEntityAlias = 'table_' . $relation;

            $metadata = $this->manager->getClassMetadata($entityName);

            if ($metadata->hasAssociation($relation)) {
                $association = $metadata->getAssociationMapping($relation);

                $fieldName = $this->parser->camelize($association['fieldName']);

                if ($this->noExistsJoin($relationEntityAlias, $relation)) {
                    if ($logicOperator === self::AND_OPERATOR_LOGIC) {
                        $param = [];
                        $param['field'] = $entityAlias . "." . $fieldName;
                        $param['relation'] = $relationEntityAlias;
                        $this->innerJoin[] = $param;
                    } elseif ($logicOperator === self::OR_OPERATOR_LOGIC) {
                        $param = [];
                        $param['field'] = $entityAlias . "." . $fieldName;
                        $param['relation'] = $relationEntityAlias;
                        $this->leftJoin[] = $param;
                    } else {
                        throw new \Exception('Missing Logic operator');
                    }

                    $this->storeJoin($relationEntityAlias, $relation);
                }

                $entityName = $association['targetEntity'];
                $entityAlias = $relationEntityAlias;
            }

            $this->setRelationEntityAlias($relationEntityAlias);
        }

        return $this;
    }

    private function storeJoin($prevEntityAlias, $currentEntityAlias)
    {
        $needle = $prevEntityAlias . '_' . $currentEntityAlias;
        $this->joins[$needle] = $needle;
    }

    private function noExistsJoin($prevEntityAlias, $currentEntityAlias)
    {
        if (null === $this->joins) {
            $this->joins = [];
        }

        $needle = $prevEntityAlias . '_' . $currentEntityAlias;

        return !in_array($needle, $this->joins);
    }

    public function getInnerJoin() :array
    {
        return $this->innerJoin;
    }

    public function getLeftJoin() :array
    {
        return $this->leftJoin;
    }

    private function setRelationEntityAlias(string $relationEntityAlias)
    {
        $this->relationEntityAlias = $relationEntityAlias;
    }

    public function getRelationEntityAlias()
    {
        return $this->relationEntityAlias;
    }
}

1			<?php
2
3			namespace Mado\QueryBundle\Queries;
4
5			use Doctrine\ORM\EntityManager;
6			use Mado\QueryBundle\Services\StringParser;
7
8			class JoinFactory
9			{
10			private const AND_OPERATOR_LOGIC = 'AND';
11
12			private const OR_OPERATOR_LOGIC = 'OR';
13
14			private $parser;
15
16			private $entityName;
17
18			private $entityAlias;
19
20			private $manager;
21
22			private $innerJoin;
23
24			private $leftJoin;
25
26			private $joins;
27
28			private $relationEntityAlias;
29
30			public function __construct(string $entityName, string $entityAlias, EntityManager $manager)
31			{
32			$this->parser = new StringParser();
33			$this->entityName = $entityName;
34			$this->entityAlias = $entityAlias;
35			$this->manager = $manager;
36			$this->innerJoin = [];
37			$this->leftJoin = [];
38			$joins = [];
			0 ignored issues – show Unused Code introduced 2018-05-29 13:19 UTC by Report Bug Copy Issue Report The assignment to `$joins` is dead and can be removed. Loading history...
39			}
40
41			/**
42			* @param String $relation Nome della relazione semplice (groups.name) o con embedded (_embedded.groups.name)
43			* @return $this
44			*/
45			public function join(String $relation, $logicOperator = self::AND_OPERATOR_LOGIC)
46			{
47			$relation = explode('\|', $relation)[0];
48			$relations = [$relation];
49
50			if (strstr($relation, '_embedded.')) {
51			$embeddedFields = explode('.', $relation);
52			$this->parser->camelize($embeddedFields[1]);
53
54			// elimino l'ultimo elemento che dovrebbe essere il nome del campo
55			unset($embeddedFields[count($embeddedFields) - 1]);
56
57			// elimino il primo elemento _embedded
58			unset($embeddedFields[0]);
59
60			$relations = $embeddedFields;
61			}
62
63			$entityName = $this->entityName;
64			$entityAlias = $this->entityAlias;
65
66			foreach ($relations as $relation) {
67			$relation = $this->parser->camelize($relation);
68			$relationEntityAlias = 'table_' . $relation;
69
70			$metadata = $this->manager->getClassMetadata($entityName);
71
72			if ($metadata->hasAssociation($relation)) {
73			$association = $metadata->getAssociationMapping($relation);
74
75			$fieldName = $this->parser->camelize($association['fieldName']);
76
77			if ($this->noExistsJoin($relationEntityAlias, $relation)) {
78			if ($logicOperator === self::AND_OPERATOR_LOGIC) {
79			$param = [];
80			$param['field'] = $entityAlias . "." . $fieldName;
81			$param['relation'] = $relationEntityAlias;
82			$this->innerJoin[] = $param;
83			} elseif ($logicOperator === self::OR_OPERATOR_LOGIC) {
84			$param = [];
85			$param['field'] = $entityAlias . "." . $fieldName;
86			$param['relation'] = $relationEntityAlias;
87			$this->leftJoin[] = $param;
88			} else {
89			throw new \Exception('Missing Logic operator');
90			}
91
92			$this->storeJoin($relationEntityAlias, $relation);
93			}
94
95			$entityName = $association['targetEntity'];
96			$entityAlias = $relationEntityAlias;
97			}
98
99			$this->setRelationEntityAlias($relationEntityAlias);
100			}
101
102			return $this;
103			}
104
105			private function storeJoin($prevEntityAlias, $currentEntityAlias)
106			{
107			$needle = $prevEntityAlias . '_' . $currentEntityAlias;
108			$this->joins[$needle] = $needle;
109			}
110
111			private function noExistsJoin($prevEntityAlias, $currentEntityAlias)
112			{
113			if (null === $this->joins) {
114			$this->joins = [];
115			}
116
117			$needle = $prevEntityAlias . '_' . $currentEntityAlias;
118
119			return !in_array($needle, $this->joins);
120			}
121
122			public function getInnerJoin() :array
123			{
124			return $this->innerJoin;
125			}
126
127			public function getLeftJoin() :array
128			{
129			return $this->leftJoin;
130			}
131
132			private function setRelationEntityAlias(string $relationEntityAlias)
133			{
134			$this->relationEntityAlias = $relationEntityAlias;
135			}
136
137			public function getRelationEntityAlias()
138			{
139			return $this->relationEntityAlias;
140			}
141			}

studiomado / query-bundle

GitHub Access Token became invalid

Pull Request — 2.4 (#144)

JoinFactory::join() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like