ManyToManyParser - Code Metrics - Inspection of "Add UQL Queries" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2d1963...3845e2 )

by Jean-Christophe

created 2018-06-23 01:58 UTC

ManyToManyParser B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	222
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

Metric	Value
wmc	45
lcom	1
cbo	1
dl	0
loc	222
rs	8.3673
c	0
b	0
f	0

32 Methods

Rating	Name	Size	Complexity
A	__construct()	5	1
A	init()	15	4
B	_init()	31	6
A	getMember()	3	1
A	setMember()	4	1
A	getJoinTable()	3	1
A	setJoinTable()	4	1
A	getMyFkField()	3	1
A	setMyFkField()	4	1
A	getFkField()	3	1
A	setFkField()	4	1
A	getTargetEntity()	3	1
A	setTargetEntity()	4	1
A	getTargetEntityClass()	3	1
A	setTargetEntityClass()	4	1
A	getTargetEntityTable()	3	1
A	setTargetEntityTable()	4	1
A	getMyPk()	3	1
A	setMyPk()	4	1
A	getPk()	3	1
A	setPk()	4	1
A	getInversedBy()	3	1
A	setInversedBy()	4	1
A	getInstance()	3	1
A	setInstance()	4	1
A	getSQL()	16	4
A	getConcatSQL()	3	1
A	getParserWhereMask()	3	1
A	getParserConcatWhereMask()	3	1
A	generateConcatSQL()	10	2
A	addValue()	3	1
A	getWhereValues()	5	2

How to fix Complexity

<?php

namespace Ubiquity\orm\parser;

use Ubiquity\orm\OrmUtils;

/**
 * ManyToManyParser
 * @author jc
 * @version 1.1.0.0
 */
class ManyToManyParser {
	private $table;
	private $member;
	private $joinTable;
	private $myFkField;
	private $fkField;
	private $targetEntity;
	private $targetEntityClass;
	private $targetEntityTable;
	private $myPk;
	private $inversedBy;
	private $pk;
	private $instance;
	private $whereValues;

	public function __construct($instance, $member=null) {
		$this->instance=$instance;
		$this->member=$member;
		$this->whereValues=[];
	}

	public function init($annot=false) {
		$member=$this->member;
		$class=$this->instance;
		if(\is_string($class)===false){
			$class=get_class($class);
		}
		if($annot===false){
			$annot=OrmUtils::getAnnotationInfoMember($class, "#manyToMany", $member);
		}
		if ($annot !== false) {
			$this->_init($class,$annot);
			return true;
		}
		return false;
	}
	
	private function _init($class,$annot){
		$this->table=OrmUtils::getTableName($class);
		$this->targetEntity=$annot["targetEntity"];
		$this->inversedBy=strtolower($this->targetEntity) . "s";
		if (!is_null($annot["inversedBy"]))
			$this->inversedBy=$annot["inversedBy"];
		$this->targetEntityClass=get_class(new $this->targetEntity());
		
		$annotJoinTable=OrmUtils::getAnnotationInfoMember($class, "#joinTable", $this->member);
		$this->joinTable=$annotJoinTable["name"];
		
		$this->myFkField=OrmUtils::getDefaultFk($class);
		$this->myPk=OrmUtils::getFirstKey($class);
		if(isset($annotJoinTable["joinColumns"])){
			$joinColumnsAnnot=$annotJoinTable["joinColumns"];
			if (!is_null($joinColumnsAnnot)) {
				$this->myFkField=$joinColumnsAnnot["name"];
				$this->myPk=$joinColumnsAnnot["referencedColumnName"];
			}
		}
		$this->targetEntityTable=OrmUtils::getTableName($this->targetEntity);
		$this->fkField=OrmUtils::getDefaultFk($this->targetEntityClass);
		$this->pk=OrmUtils::getFirstKey($this->targetEntityClass);
		if(isset($annotJoinTable["inverseJoinColumns"])){
			$inverseJoinColumnsAnnot=$annotJoinTable["inverseJoinColumns"];
			if (!is_null($inverseJoinColumnsAnnot)) {
				$this->fkField=$inverseJoinColumnsAnnot["name"];
				$this->pk=$inverseJoinColumnsAnnot["referencedColumnName"];
			}
		}
	}

	public function getMember() {
		return $this->member;
	}

	public function setMember($member) {
		$this->member=$member;
		return $this;
	}

	public function getJoinTable() {
		return $this->joinTable;
	}

	public function setJoinTable($joinTable) {
		$this->joinTable=$joinTable;
		return $this;
	}

	public function getMyFkField() {
		return $this->myFkField;
	}

	public function setMyFkField($myFkField) {
		$this->myFkField=$myFkField;
		return $this;
	}

	public function getFkField() {
		return $this->fkField;
	}

	public function setFkField($fkField) {
		$this->fkField=$fkField;
		return $this;
	}

	public function getTargetEntity() {
		return $this->targetEntity;
	}

	public function setTargetEntity($targetEntity) {
		$this->targetEntity=$targetEntity;
		return $this;
	}

	public function getTargetEntityClass() {
		return $this->targetEntityClass;
	}

	public function setTargetEntityClass($targetEntityClass) {
		$this->targetEntityClass=$targetEntityClass;
		return $this;
	}

	public function getTargetEntityTable() {
		return $this->targetEntityTable;
	}

	public function setTargetEntityTable($targetEntityTable) {
		$this->targetEntityTable=$targetEntityTable;
		return $this;
	}

	public function getMyPk() {
		return $this->myPk;
	}

	public function setMyPk($myPk) {
		$this->myPk=$myPk;
		return $this;
	}

	public function getPk() {
		return $this->pk;
	}

	public function setPk($pk) {
		$this->pk=$pk;
		return $this;
	}

	public function getInversedBy() {
		return $this->inversedBy;
	}

	public function setInversedBy($inversedBy) {
		$this->inversedBy=$inversedBy;
		return $this;
	}

	public function getInstance() {
		return $this->instance;
	}

	public function setInstance($instance) {
		$this->instance=$instance;
		return $this;
	}
	
	public function getSQL($alias="",$aliases=null){
		if($alias!==""){
			$targetEntityTable=$alias;
			$alias="`".$alias."`";
		}else{
			$targetEntityTable=$this->targetEntityTable;
		}
		$jtAlias=uniqid($this->joinTable);
		$table=$this->table;
		if(is_array($aliases)){
			if(isset($aliases[$this->table]))
				$table=$aliases[$this->table];
		}
		return " INNER JOIN `" . $this->joinTable . "` `{$jtAlias}` on `".$jtAlias."`.`".$this->myFkField."`=`".$table."`.`".$this->myPk."`".
				" INNER JOIN `" . $this->targetEntityTable . "` {$alias} on `".$jtAlias."`.`".$this->fkField."`=`".$targetEntityTable."`.`".$this->pk."`";
	}
	
	public function getConcatSQL(){
		return "SELECT `".$this->myFkField."` as '_field' ,GROUP_CONCAT(`".$this->fkField."` SEPARATOR ',') as '_concat' FROM `".$this->joinTable."` {condition} GROUP BY 1";
	}
	
	public function getParserWhereMask($mask="'{value}'"){
		return "`".$this->getTargetEntityTable()."`.`". $this->getPk() . "`=".$mask;
	}
	
	private function getParserConcatWhereMask($mask="'{value}'"){
		return "`".$this->myFkField. "`=".$mask;
	}
	
	
	public function generateConcatSQL(){
		$sql=$this->getConcatSQL();
		$where="";
		if(($size=sizeof($this->whereValues))>0){
			$mask=$this->getParserConcatWhereMask(" ?");
			$res=array_fill(0, $size, $mask);
			$where="WHERE ".implode(" OR ", $res);
		}
		return str_replace("{condition}", $where, $sql);
	}
	
	public function addValue($value){
		$this->whereValues[$value]=true;
	}
	/**
	 * @return array|null
	 */
	public function getWhereValues() {
		if(is_array($this->whereValues))
			return array_keys($this->whereValues);
		return null;
	}

}


1			<?php
2
3			namespace Ubiquity\orm\parser;
4
5			use Ubiquity\orm\OrmUtils;
6
7			/**
8			* ManyToManyParser
9			* @author jc
10			* @version 1.1.0.0
11			*/
12			class ManyToManyParser {
13			private $table;
14			private $member;
15			private $joinTable;
16			private $myFkField;
17			private $fkField;
18			private $targetEntity;
19			private $targetEntityClass;
20			private $targetEntityTable;
21			private $myPk;
22			private $inversedBy;
23			private $pk;
24			private $instance;
25			private $whereValues;
26
27			public function __construct($instance, $member=null) {
28			$this->instance=$instance;
29			$this->member=$member;
30			$this->whereValues=[];
31			}
32
33			public function init($annot=false) {
34			$member=$this->member;
35			$class=$this->instance;
36			if(\is_string($class)===false){
37			$class=get_class($class);
38			}
39			if($annot===false){
40			$annot=OrmUtils::getAnnotationInfoMember($class, "#manyToMany", $member);
41			}
42			if ($annot !== false) {
43			$this->_init($class,$annot);
44			return true;
45			}
46			return false;
47			}
48
49			private function _init($class,$annot){
50			$this->table=OrmUtils::getTableName($class);
51			$this->targetEntity=$annot["targetEntity"];
52			$this->inversedBy=strtolower($this->targetEntity) . "s";
53			if (!is_null($annot["inversedBy"]))
54			$this->inversedBy=$annot["inversedBy"];
55			$this->targetEntityClass=get_class(new $this->targetEntity());
56
57			$annotJoinTable=OrmUtils::getAnnotationInfoMember($class, "#joinTable", $this->member);
58			$this->joinTable=$annotJoinTable["name"];
59
60			$this->myFkField=OrmUtils::getDefaultFk($class);
61			$this->myPk=OrmUtils::getFirstKey($class);
62			if(isset($annotJoinTable["joinColumns"])){
63			$joinColumnsAnnot=$annotJoinTable["joinColumns"];
64			if (!is_null($joinColumnsAnnot)) {
65			$this->myFkField=$joinColumnsAnnot["name"];
66			$this->myPk=$joinColumnsAnnot["referencedColumnName"];
67			}
68			}
69			$this->targetEntityTable=OrmUtils::getTableName($this->targetEntity);
70			$this->fkField=OrmUtils::getDefaultFk($this->targetEntityClass);
71			$this->pk=OrmUtils::getFirstKey($this->targetEntityClass);
72			if(isset($annotJoinTable["inverseJoinColumns"])){
73			$inverseJoinColumnsAnnot=$annotJoinTable["inverseJoinColumns"];
74			if (!is_null($inverseJoinColumnsAnnot)) {
75			$this->fkField=$inverseJoinColumnsAnnot["name"];
76			$this->pk=$inverseJoinColumnsAnnot["referencedColumnName"];
77			}
78			}
79			}
80
81			public function getMember() {
82			return $this->member;
83			}
84
85			public function setMember($member) {
86			$this->member=$member;
87			return $this;
88			}
89
90			public function getJoinTable() {
91			return $this->joinTable;
92			}
93
94			public function setJoinTable($joinTable) {
95			$this->joinTable=$joinTable;
96			return $this;
97			}
98
99			public function getMyFkField() {
100			return $this->myFkField;
101			}
102
103			public function setMyFkField($myFkField) {
104			$this->myFkField=$myFkField;
105			return $this;
106			}
107
108			public function getFkField() {
109			return $this->fkField;
110			}
111
112			public function setFkField($fkField) {
113			$this->fkField=$fkField;
114			return $this;
115			}
116
117			public function getTargetEntity() {
118			return $this->targetEntity;
119			}
120
121			public function setTargetEntity($targetEntity) {
122			$this->targetEntity=$targetEntity;
123			return $this;
124			}
125
126			public function getTargetEntityClass() {
127			return $this->targetEntityClass;
128			}
129
130			public function setTargetEntityClass($targetEntityClass) {
131			$this->targetEntityClass=$targetEntityClass;
132			return $this;
133			}
134
135			public function getTargetEntityTable() {
136			return $this->targetEntityTable;
137			}
138
139			public function setTargetEntityTable($targetEntityTable) {
140			$this->targetEntityTable=$targetEntityTable;
141			return $this;
142			}
143
144			public function getMyPk() {
145			return $this->myPk;
146			}
147
148			public function setMyPk($myPk) {
149			$this->myPk=$myPk;
150			return $this;
151			}
152
153			public function getPk() {
154			return $this->pk;
155			}
156
157			public function setPk($pk) {
158			$this->pk=$pk;
159			return $this;
160			}
161
162			public function getInversedBy() {
163			return $this->inversedBy;
164			}
165
166			public function setInversedBy($inversedBy) {
167			$this->inversedBy=$inversedBy;
168			return $this;
169			}
170
171			public function getInstance() {
172			return $this->instance;
173			}
174
175			public function setInstance($instance) {
176			$this->instance=$instance;
177			return $this;
178			}
179
180			public function getSQL($alias="",$aliases=null){
181			if($alias!==""){
182			$targetEntityTable=$alias;
183			$alias="`".$alias."`";
184			}else{
185			$targetEntityTable=$this->targetEntityTable;
186			}
187			$jtAlias=uniqid($this->joinTable);
188			$table=$this->table;
189			if(is_array($aliases)){
190			if(isset($aliases[$this->table]))
191			$table=$aliases[$this->table];
192			}
193			return " INNER JOIN `" . $this->joinTable . "` `{$jtAlias}` on `".$jtAlias."`.`".$this->myFkField."`=`".$table."`.`".$this->myPk."`".
194			" INNER JOIN `" . $this->targetEntityTable . "` {$alias} on `".$jtAlias."`.`".$this->fkField."`=`".$targetEntityTable."`.`".$this->pk."`";
195			}
196
197			public function getConcatSQL(){
198			return "SELECT `".$this->myFkField."` as '_field' ,GROUP_CONCAT(`".$this->fkField."` SEPARATOR ',') as '_concat' FROM `".$this->joinTable."` {condition} GROUP BY 1";
199			}
200
201			public function getParserWhereMask($mask="'{value}'"){
202			return "`".$this->getTargetEntityTable()."`.`". $this->getPk() . "`=".$mask;
203			}
204
205			private function getParserConcatWhereMask($mask="'{value}'"){
206			return "`".$this->myFkField. "`=".$mask;
207			}
208
209
210			public function generateConcatSQL(){
211			$sql=$this->getConcatSQL();
212			$where="";
213			if(($size=sizeof($this->whereValues))>0){
214			$mask=$this->getParserConcatWhereMask(" ?");
215			$res=array_fill(0, $size, $mask);
216			$where="WHERE ".implode(" OR ", $res);
217			}
218			return str_replace("{condition}", $where, $sql);
219			}
220
221			public function addValue($value){
222			$this->whereValues[$value]=true;
223			}
224			/**
225			* @return array\|null
226			*/
227			public function getWhereValues() {
228			if(is_array($this->whereValues))
229			return array_keys($this->whereValues);
230			return null;
231			}
232
233			}
234

phpMv / ubiquity

Push — master ( 2d1963...3845e2 )

ManyToManyParser B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

32 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like