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

Passed

Push — master ( 4162a6...5bc725 )

by Jean-Christophe

created 2019-02-07 03:40 UTC

getFieldsInRelationsForUpdate_() B

↳ Parent: OrmUtilsRelationsTrait

Complexity

Conditions	7
Paths	8

Size

Total Lines	21
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	7.392

Importance

Changes

Metric	Value
eloc	14
dl	0
loc	21
ccs	12
cts	15
cp	0.8
rs	8.8333
c	0
b	0
f	0
cc	7
nc	8
nop	1
crap	7.392

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

phpMv / ubiquity

Push — master ( 4162a6...5bc725 )

getFieldsInRelationsForUpdate_() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like