OrmUtilsRelationsTrait::getFieldsInRelations() - Code Metrics - Inspection of "Update AdminCest.php" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 9c1274...95a447 )

by Jean-Christophe

created 2019-03-04 03:09 UTC

OrmUtilsRelationsTrait::getFieldsInRelations() A

↳ Parent: OrmUtilsRelationsTrait

Complexity

Conditions	4
Paths	8

Size

Total Lines	13
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	4.1755

Importance

Changes

Metric	Value
eloc	8
dl	0
loc	13
ccs	7
cts	9
cp	0.7778
rs	10
c	0
b	0
f	0
cc	4
nc	8
nop	1
crap	4.1755

<?php

namespace Ubiquity\orm\traits;

use Ubiquity\orm\parser\ManyToManyParser;

trait OrmUtilsRelationsTrait {
	
	abstract public static function getAnnotationInfoMember($class, $keyAnnotation, $member);
	abstract public static function getAnnotationInfo($class, $keyAnnotation);
	abstract public static function getTableName($class);
	abstract public static function getFirstKey($class);
	abstract public static function getModelMetadata($className);
	abstract public static function getKeyFieldsAndValues($instance);
	
	public static function getJoinTables($class){
		$result=[];
		
		if(isset(self::getModelMetadata($class)["#joinTable"])){
			$jts=self::getModelMetadata($class)["#joinTable"];
			foreach ($jts as $jt){
				$result[]=$jt["name"];
			}
		}
		return $result;
	}
	
	public static function getAllJoinTables($models){
		$result=[];
		foreach ($models as $model){
			$result=array_merge($result,self::getJoinTables($model));
		}
		return $result;
	}
	
	public static function getFieldsInRelations($class) {
		$result=[ ];
		
		if ($manyToOne=self::getAnnotationInfo($class, "#manyToOne")) {
			$result=\array_merge($result, $manyToOne);
		}
		if ($oneToMany=self::getAnnotationInfo($class, "#oneToMany")) {
			$result=\array_merge($result, \array_keys($oneToMany));
		}
		if ($manyToMany=self::getAnnotationInfo($class, "#manyToMany")) {
			$result=\array_merge($result, \array_keys($manyToMany));
		}
		return $result;
	}
	
	public static function getRelationInfos($class){
		$result=[ ];
		$joinColumns=self::getAnnotationInfo($class, "#joinColumn");
		$invertedJoinColumns=self::getAnnotationInfo($class, "#invertedJoinColumn");
		if ($manyToOne=self::getAnnotationInfo($class, "#manyToOne")) {
			foreach ($manyToOne as $oneField){
				$field=$joinColumns[$oneField]['name'];
				$result[$field]=$invertedJoinColumns[$field];
				$result[$oneField]=$invertedJoinColumns[$field];
			}
		}
		if ($oneToMany=self::getAnnotationInfo($class, "#oneToMany")) {
			$result=\array_merge($result, $oneToMany);
		}
		if ($manyToMany=self::getAnnotationInfo($class, "#manyToMany")) {
			$result=\array_merge($result, $manyToMany);
		}
		return $result;
	}
	
	public static function getFieldsInRelations_($class) {
		return self::getFieldsInRelationsForUpdate_($class)["relations"];
	}
	
	public static function getFieldsInRelationsForUpdate_($class) {
		$result=[ ];
		if ($manyToOne=self::getAnnotationInfo($class, "#manyToOne")) {
			foreach ($manyToOne as $member){
				$joinColumn = self::getAnnotationInfoMember ( $class, "#joinColumn", $member );
				$result[$joinColumn["name"]]=$member;
			}
		}
		if ($manyToMany=self::getAnnotationInfo($class, "#manyToMany")) {
			$manyToMany=array_keys($manyToMany);
			foreach ($manyToMany as $member){
				$result[$member . "Ids"]=$member;
			}
		}
		if ($oneToMany=self::getAnnotationInfo($class, "#oneToMany")) {
			$oneToMany=array_keys($oneToMany);
			foreach ($oneToMany as $member){
				$result[$member . "Ids"]=$member;
			}
		}
		return ["relations"=>$result,"manyToOne"=>$manyToOne,"manyToMany"=>$manyToMany,"oneToMany"=>$oneToMany];
	}
	
	public static function getAnnotFieldsInRelations($class) {
		$result=[ ];
		if ($manyToOnes=self::getAnnotationInfo($class, "#manyToOne")) {
			$joinColumns=self::getAnnotationInfo($class, "#joinColumn");
			foreach ($manyToOnes as $manyToOne ){
				if(isset($joinColumns[$manyToOne])){
					$result[$manyToOne]=["type"=>"manyToOne","value"=>$joinColumns[$manyToOne]];
				}
			}
		}
		if ($oneToManys=self::getAnnotationInfo($class, "#oneToMany")) {
			foreach ($oneToManys as $field=>$oneToMany){
				$result[$field]=["type"=>"oneToMany","value"=>$oneToMany];
			}
		}
		if ($manyToManys=self::getAnnotationInfo($class, "#manyToMany")) {
			foreach ($manyToManys as $field=>$manyToMany){
				$result[$field]=["type"=>"manyToMany","value"=>$manyToMany];
			}
		}
		return $result;
	}
	
	public static function getUJoinSQL($model,$arrayAnnot,$field,&$aliases){
		$type=$arrayAnnot["type"];$annot=$arrayAnnot["value"];
		$table=self::getTableName($model);
		$tableAlias=(isset($aliases[$table]))?$aliases[$table]:$table;
		if($type==="manyToOne"){
			$fkClass=$annot["className"];
			$fkTable=self::getTableName($fkClass);
			$fkField=$annot["name"];
			$pkField=self::getFirstKey($fkClass);
			$alias=self::getJoinAlias($table, $fkTable);
			$result="INNER JOIN `{$fkTable}` `{$alias}` ON `{$tableAlias}`.`{$fkField}`=`{$alias}`.`{$pkField}`";
		}elseif($type==="oneToMany"){
			$fkClass=$annot["className"];
			$fkAnnot=self::getAnnotationInfoMember($fkClass, "#joinColumn", $annot["mappedBy"]);
			$fkTable=self::getTableName($fkClass);
			$fkField=$fkAnnot["name"];
			$pkField=self::getFirstKey($model);
			$alias=self::getJoinAlias($table, $fkTable);
			$result="INNER JOIN `{$fkTable}` `{$alias}` ON `{$tableAlias}`.`{$pkField}`=`{$alias}`.`{$fkField}`";
		}else{
			$parser=new ManyToManyParser($model,$field);
			$parser->init($annot);
			$fkTable=$parser->getTargetEntityTable();
			$fkClass=$parser->getTargetEntityClass();
			$alias=self::getJoinAlias($table, $fkTable);
			$result=$parser->getSQL($alias,$aliases);
		}
		
		if(array_search($alias, $aliases)!==false){
			$result="";
		}
		$aliases[$fkTable]=$alias;
		return ["class"=>$fkClass,"table"=>$fkTable,"sql"=>$result,"alias"=>$alias];
	}
	
	private static function getJoinAlias($table,$fkTable){
		return uniqid($fkTable.'_'.$table[0]);
	}
	
	public static function getOneToManyFields($class) {
		return self::getAnnotationInfo($class, "#oneToMany");
	}
	
	public static function getManyToOneFields($class) {
		return self::getAnnotationInfo($class, "#manyToOne");
	}
	
	public static function getManyToManyFields($class) {
		$result=self::getAnnotationInfo($class, "#manyToMany");
		if($result!==false)
			return \array_keys($result);
			return [];
	}
	
	public static function getDefaultFk($classname) {
		return "id" . \ucfirst(self::getTableName($classname));
	}
	
	public static function getMemberJoinColumns($instance,$member,$metaDatas=NULL){
		if(!isset($metaDatas)){
			$class=get_class($instance);
			$metaDatas=self::getModelMetadata($class);
		}
		$invertedJoinColumns=$metaDatas["#invertedJoinColumn"];
		foreach ($invertedJoinColumns as $field=>$invertedJoinColumn){
			if($invertedJoinColumn["member"]===$member){
				return [$field,$invertedJoinColumn];
			}
		}
		return null;
	}
	
	/**
	 *
	 * @param object $instance
	 * @return mixed[]
	 */
	public static function getManyToOneMembersAndValues($instance) {
		$ret=array ();
		$class=get_class($instance);
		$members=self::getAnnotationInfo($class, "#manyToOne");
		if ($members !== false) {
			foreach ( $members as $member ) {
				$memberAccessor="get" . ucfirst($member);
				if (method_exists($instance, $memberAccessor)) {
					$memberInstance=$instance->$memberAccessor();
					if (isset($memberInstance) && is_object($memberInstance)) {
						$keyValues=self::getKeyFieldsAndValues($memberInstance);
						if (sizeof($keyValues) > 0) {
							$fkName=self::getJoinColumnName($class, $member);
							$ret[$fkName]=current($keyValues);
						}
					}
				}
			}
		}
		return $ret;
	}
	
	public static function getJoinColumnName($class, $member) {
		$annot=self::getAnnotationInfoMember($class, "#joinColumn", $member);
		if ($annot !== false) {
			$fkName=$annot["name"];
		} else {
			$fkName="id" . ucfirst(self::getTableName(ucfirst($member)));
		}
		return $fkName;
	}
}



1		<?php
2
3		namespace Ubiquity\orm\traits;
4
5		use Ubiquity\orm\parser\ManyToManyParser;
6
7		trait OrmUtilsRelationsTrait {
8
9		abstract public static function getAnnotationInfoMember($class, $keyAnnotation, $member);
10		abstract public static function getAnnotationInfo($class, $keyAnnotation);
11		abstract public static function getTableName($class);
12		abstract public static function getFirstKey($class);
13		abstract public static function getModelMetadata($className);
14		abstract public static function getKeyFieldsAndValues($instance);
15
16		public static function getJoinTables($class){
17		$result=[];
18
19		if(isset(self::getModelMetadata($class)["#joinTable"])){
20		$jts=self::getModelMetadata($class)["#joinTable"];
21		foreach ($jts as $jt){
22		$result[]=$jt["name"];
23		}
24		}
25		return $result;
26		}
27
28		public static function getAllJoinTables($models){
29		$result=[];
30		foreach ($models as $model){
31		$result=array_merge($result,self::getJoinTables($model));
32		}
33		return $result;
34		}
35
36	3	public static function getFieldsInRelations($class) {
37	3	$result=[ ];
38
39	3	if ($manyToOne=self::getAnnotationInfo($class, "#manyToOne")) {
40		$result=\array_merge($result, $manyToOne);
41		}
42	3	if ($oneToMany=self::getAnnotationInfo($class, "#oneToMany")) {
43	3	$result=\array_merge($result, \array_keys($oneToMany));
44		}
45	3	if ($manyToMany=self::getAnnotationInfo($class, "#manyToMany")) {
46		$result=\array_merge($result, \array_keys($manyToMany));
47		}
48	3	return $result;
49		}
50
51	1	public static function getRelationInfos($class){
52	1	$result=[ ];
53	1	$joinColumns=self::getAnnotationInfo($class, "#joinColumn");
54	1	$invertedJoinColumns=self::getAnnotationInfo($class, "#invertedJoinColumn");
55	1	if ($manyToOne=self::getAnnotationInfo($class, "#manyToOne")) {
56	1	foreach ($manyToOne as $oneField){
57	1	$field=$joinColumns[$oneField]['name'];
58	1	$result[$field]=$invertedJoinColumns[$field];
59	1	$result[$oneField]=$invertedJoinColumns[$field];
60		}
61		}
62	1	if ($oneToMany=self::getAnnotationInfo($class, "#oneToMany")) {
63	1	$result=\array_merge($result, $oneToMany);
64		}
65	1	if ($manyToMany=self::getAnnotationInfo($class, "#manyToMany")) {
66	1	$result=\array_merge($result, $manyToMany);
67		}
68	1	return $result;
69		}
70
71	4	public static function getFieldsInRelations_($class) {
72	4	return self::getFieldsInRelationsForUpdate_($class)["relations"];
73		}
74
75	4	public static function getFieldsInRelationsForUpdate_($class) {
76	4	$result=[ ];
77	4	if ($manyToOne=self::getAnnotationInfo($class, "#manyToOne")) {
78	1	foreach ($manyToOne as $member){
79	1	$joinColumn = self::getAnnotationInfoMember ( $class, "#joinColumn", $member );
80	1	$result[$joinColumn["name"]]=$member;
81		}
82		}
83	4	if ($manyToMany=self::getAnnotationInfo($class, "#manyToMany")) {
84		$manyToMany=array_keys($manyToMany);
85		foreach ($manyToMany as $member){
86		$result[$member . "Ids"]=$member;
87		}
88		}
89	4	if ($oneToMany=self::getAnnotationInfo($class, "#oneToMany")) {
90	3	$oneToMany=array_keys($oneToMany);
91	3	foreach ($oneToMany as $member){
92	3	$result[$member . "Ids"]=$member;
93		}
94		}
95	4	return ["relations"=>$result,"manyToOne"=>$manyToOne,"manyToMany"=>$manyToMany,"oneToMany"=>$oneToMany];
96		}
97
98	1	public static function getAnnotFieldsInRelations($class) {
99	1	$result=[ ];
100	1	if ($manyToOnes=self::getAnnotationInfo($class, "#manyToOne")) {
101	1	$joinColumns=self::getAnnotationInfo($class, "#joinColumn");
102	1	foreach ($manyToOnes as $manyToOne ){
103	1	if(isset($joinColumns[$manyToOne])){
104	1	$result[$manyToOne]=["type"=>"manyToOne","value"=>$joinColumns[$manyToOne]];
105		}
106		}
107		}
108	1	if ($oneToManys=self::getAnnotationInfo($class, "#oneToMany")) {
109	1	foreach ($oneToManys as $field=>$oneToMany){
110	1	$result[$field]=["type"=>"oneToMany","value"=>$oneToMany];
111		}
112		}
113	1	if ($manyToManys=self::getAnnotationInfo($class, "#manyToMany")) {
114	1	foreach ($manyToManys as $field=>$manyToMany){
115	1	$result[$field]=["type"=>"manyToMany","value"=>$manyToMany];
116		}
117		}
118	1	return $result;
119		}
120
121	3	public static function getUJoinSQL($model,$arrayAnnot,$field,&$aliases){
122	3	$type=$arrayAnnot["type"];$annot=$arrayAnnot["value"];
123	3	$table=self::getTableName($model);
124	3	$tableAlias=(isset($aliases[$table]))?$aliases[$table]:$table;
125	3	if($type==="manyToOne"){
126		$fkClass=$annot["className"];
127		$fkTable=self::getTableName($fkClass);
128		$fkField=$annot["name"];
129		$pkField=self::getFirstKey($fkClass);
130		$alias=self::getJoinAlias($table, $fkTable);
131		$result="INNER JOIN `{$fkTable}` `{$alias}` ON `{$tableAlias}`.`{$fkField}`=`{$alias}`.`{$pkField}`";
132	3	}elseif($type==="oneToMany"){
133		$fkClass=$annot["className"];
134		$fkAnnot=self::getAnnotationInfoMember($fkClass, "#joinColumn", $annot["mappedBy"]);
135		$fkTable=self::getTableName($fkClass);
136		$fkField=$fkAnnot["name"];
137		$pkField=self::getFirstKey($model);
138		$alias=self::getJoinAlias($table, $fkTable);
139		$result="INNER JOIN `{$fkTable}` `{$alias}` ON `{$tableAlias}`.`{$pkField}`=`{$alias}`.`{$fkField}`";
140		}else{
141	3	$parser=new ManyToManyParser($model,$field);
142	3	$parser->init($annot);
143	3	$fkTable=$parser->getTargetEntityTable();
144	3	$fkClass=$parser->getTargetEntityClass();
145	3	$alias=self::getJoinAlias($table, $fkTable);
146	3	$result=$parser->getSQL($alias,$aliases);
147		}
148
149	3	if(array_search($alias, $aliases)!==false){
150		$result="";
151		}
152	3	$aliases[$fkTable]=$alias;
153	3	return ["class"=>$fkClass,"table"=>$fkTable,"sql"=>$result,"alias"=>$alias];
154		}
155
156	3	private static function getJoinAlias($table,$fkTable){
157	3	return uniqid($fkTable.'_'.$table[0]);
158		}
159
160		public static function getOneToManyFields($class) {
161		return self::getAnnotationInfo($class, "#oneToMany");
162		}
163
164		public static function getManyToOneFields($class) {
165		return self::getAnnotationInfo($class, "#manyToOne");
166		}
167
168		public static function getManyToManyFields($class) {
169		$result=self::getAnnotationInfo($class, "#manyToMany");
170		if($result!==false)
171		return \array_keys($result);
172		return [];
173		}
174
175	19	public static function getDefaultFk($classname) {
176	19	return "id" . \ucfirst(self::getTableName($classname));
177		}
178
179	4	public static function getMemberJoinColumns($instance,$member,$metaDatas=NULL){
180	4	if(!isset($metaDatas)){
181	3	$class=get_class($instance);
182	3	$metaDatas=self::getModelMetadata($class);
183		}
184	4	$invertedJoinColumns=$metaDatas["#invertedJoinColumn"];
185	4	foreach ($invertedJoinColumns as $field=>$invertedJoinColumn){
186	4	if($invertedJoinColumn["member"]===$member){
187	4	return [$field,$invertedJoinColumn];
188		}
189		}
190		return null;
191		}
192
193		/**
194		*
195		* @param object $instance
196		* @return mixed[]
197		*/
198	4	public static function getManyToOneMembersAndValues($instance) {
199	4	$ret=array ();
200	4	$class=get_class($instance);
201	4	$members=self::getAnnotationInfo($class, "#manyToOne");
202	4	if ($members !== false) {
203	4	foreach ( $members as $member ) {
204		$memberAccessor="get" . ucfirst($member);
205		if (method_exists($instance, $memberAccessor)) {
206		$memberInstance=$instance->$memberAccessor();
207		if (isset($memberInstance) && is_object($memberInstance)) {
208		$keyValues=self::getKeyFieldsAndValues($memberInstance);
209		if (sizeof($keyValues) > 0) {
210		$fkName=self::getJoinColumnName($class, $member);
211		$ret[$fkName]=current($keyValues);
212		}
213		}
214		}
215		}
216		}
217	4	return $ret;
218		}
219
220		public static function getJoinColumnName($class, $member) {
221		$annot=self::getAnnotationInfoMember($class, "#joinColumn", $member);
222		if ($annot !== false) {
223		$fkName=$annot["name"];
224		} else {
225		$fkName="id" . ucfirst(self::getTableName(ucfirst($member)));
226		}
227		return $fkName;
228		}
229		}
230
231

phpMv / ubiquity

Push — master ( 9c1274...95a447 )

OrmUtilsRelationsTrait::getFieldsInRelations() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like