DAORelationsTrait::_initRelationFields() - Code Metrics - Inspection of "Add Logger interface" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 61f3b2...32110c )

by Jean-Christophe

created 2018-06-14 00:08 UTC

DAORelationsTrait::_initRelationFields() C

↳ Parent: DAORelationsTrait

Complexity

Conditions	8
Paths	72

Size

Total Lines	22
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	22
rs	6.6037
cc	8
eloc	14
nc	72
nop	5

<?php

namespace Ubiquity\orm\traits;

use Ubiquity\orm\OrmUtils;
use Ubiquity\orm\parser\ManyToManyParser;

trait DAORelationsTrait {
	
	private static function _affectsRelationObjects($manyToOneQueries,$oneToManyQueries,$manyToManyParsers,$objects,$included,$useCache){
		if(\sizeof($manyToOneQueries)>0){
			self::_affectsObjectsFromArray($manyToOneQueries, $objects,$included, function($object,$member,$manyToOneObjects,$fkField){
				self::affectsManyToOneFromArray($object,$member,$manyToOneObjects,$fkField);
			});
		}
		
		if(\sizeof($oneToManyQueries)>0){
			self::_affectsObjectsFromArray($oneToManyQueries, $objects,$included, function($object,$member,$relationObjects,$fkField){
				self::affectsOneToManyFromArray($object,$member,$relationObjects,$fkField);
			});
		}
		
		if(\sizeof($manyToManyParsers)>0){
			self::_affectsManyToManyObjectsFromArray($manyToManyParsers, $objects,$included,$useCache);
		}
	}
	
	private static function affectsManyToOneFromArray($object,$member,$manyToOneObjects,$fkField){
		$class=\get_class($object);
		if(isset($object->$fkField)){
			$value=$manyToOneObjects[$object->$fkField];
			self::setToMember($member, $object, $value, $class, "getManyToOne");
		}
	}
	
	private static function _affectsObjectsFromArray($queries,$objects,$included,$affectsCallback,$useCache=NULL){
		$includedNext=false;
		foreach ($queries as $key=>$conditions){
			list($class,$member,$fkField)=\explode("|", $key);
			if(is_array($included)){
				$includedNext=self::_getIncludedNext($included, $member);
			}
			$condition=\implode(" OR ", $conditions);
			$relationObjects=self::getAll($class,$condition,$includedNext,$useCache);
			foreach ($objects as $object){
				$affectsCallback($object, $member,$relationObjects,$fkField);
			}
		}
	}
	
	private static function _affectsManyToManyObjectsFromArray($parsers,$objects,$included,$useCache=NULL){
		$includedNext=false;
		foreach ($parsers as $key=>$parser){
			list($class,$member,$inversedBy)=\explode("|", $key);
<?php

function returnThreeValues() {
    return array('a', 'b', 'c');
}

list($a, $b, $c) = returnThreeValues();

print $a . " - " . $c;
			if(is_array($included)){
				$includedNext=self::_getIncludedNext($included, $member);
			}
			$condition=$parser->generate();
			$relationObjects=self::getAll($class,$condition,$includedNext,$useCache);
			foreach ($objects as $object){
				$ret=self::getManyToManyFromArrayIds($object, $relationObjects, $member);
				self::setToMember($member, $object, $ret, $class, "getManyToMany");
			}
		}
	}
	
	private static function _getIncludedNext($included,$member){
		return (isset($included[$member]))?(is_bool($included[$member])?$included[$member]:[$included[$member]]):false;
	}
	
	
	
	private static function getManyToManyFromArrayIds($object, $relationObjects, $member){
		$iMember="_".$member;
		$ids=$object->$iMember;
		$ret=[];
		foreach ( $relationObjects as $targetEntityInstance ) {
			$id=OrmUtils::getFirstKeyValue($targetEntityInstance);
			if (array_search($id, $ids)!==false) {
				array_push($ret, $targetEntityInstance);
			}
		}
		unset($object->$iMember);
		return $ret;
	}
	
	/**
	 * Prepares members associated with $instance with a ManyToMany type relationship
	 * @param $ret array of sql conditions
	 * @param object $instance
	 * @param string $member Member on which a ManyToMany annotation must be present
	 * @param array $annot used internally
	 */
	private static function prepareManyToMany(&$ret,$instance, $member, $annot=null) {
		$class=get_class($instance);
		$iMember="_".$member;
		if (!isset($annot))
			$annot=OrmUtils::getAnnotationInfoMember($class, "#ManyToMany", $member);
			if ($annot !== false) {
				$key=$annot["targetEntity"]."|".$member."|".$annot["inversedBy"];
				if(!isset($ret[$key])){
					$parser=new ManyToManyParser($instance, $member);
					$parser->init($annot);
					$ret[$key]=$parser;
				}
				$accessor="get" . ucfirst($ret[$key]->getMyPk());
				if(method_exists($instance, $accessor)){
					$fkv=$instance->$accessor();
					$ret[$key]->addValue($fkv);
					$result=self::$db->fetchAll($ret[$key]->getJoinSQL($fkv));
					$instance->$iMember=$result;
				}
			}
	}
	
	/**
	 * Prepares members associated with $instance with a oneToMany type relationship
	 * @param $ret array of sql conditions
	 * @param object $instance
	 * @param string $member Member on which a OneToMany annotation must be present
	 * @param array $annot used internally
	 */
	private static function prepareOneToMany(&$ret,$instance, $member, $annot=null) {
		$class=get_class($instance);
		if (!isset($annot))
			$annot=OrmUtils::getAnnotationInfoMember($class, "#oneToMany", $member);
			if ($annot !== false) {
				$fkAnnot=OrmUtils::getAnnotationInfoMember($annot["className"], "#joinColumn", $annot["mappedBy"]);
				if ($fkAnnot !== false) {
					$fkv=OrmUtils::getFirstKeyValue($instance);
					$key=$annot["className"]."|".$member."|".$annot["mappedBy"];
					if(!isset($ret[$key])){
						$ret[$key]=[];
					}
					$ret[$key][$fkv]=$fkAnnot["name"] . "='" . $fkv . "'";
				}
			}
	}
	
	/**
	 * Prepares members associated with $instance with a manyToOne type relationship
	 * @param $ret array of sql conditions
	 * @param mixed $value
	 * @param string $fkField
	 * @param array $annotationArray
	 */
	private static function prepareManyToOne(&$ret, $value, $fkField,$annotationArray) {
		$member=$annotationArray["member"];
		$fk=OrmUtils::getFirstKey($annotationArray["className"]);
		$key=$annotationArray["className"]."|".$member."|".$fkField;
		if(!isset($ret[$key])){
			$ret[$key]=[];
		}
		$ret[$key][$value]=$fk . "='" . $value . "'";
	}
	
	private static function getIncludedForStep($included){
		if(is_bool($included)){
			return $included;
		}
		$ret=[];
		if(is_array($included)){
			foreach ($included as $index=>&$includedMember){
				if(is_array($includedMember)){
					foreach ($includedMember as $iMember){
						self::parseEncludeMember($ret, $iMember);
					}
				}else{
					self::parseEncludeMember($ret, $includedMember);
				}
			}
		}
		
		return $ret;
	}
	
	private static function parseEncludeMember(&$ret,$includedMember){
		$array=explode(".", $includedMember);
		$member=array_shift($array);
		if(sizeof($array)>0){
			$newValue=implode(".", $array);
			if($newValue==='*'){
				$newValue=true;
			}
			if(isset($ret[$member])){
				if(!is_array($ret[$member])){
					$ret[$member]=[$ret[$member]];
				}
				$ret[$member][]=$newValue;
			}else{
				$ret[$member]=$newValue;
			}
		}else{
			if(isset($member) && ""!=$member){
				$ret[$member]=false;
			}else{
				return;
			}
		}
	}
	
	private static function getInvertedJoinColumns($included,&$invertedJoinColumns){
		foreach ($invertedJoinColumns as $column=>&$annot){
			$member=$annot["member"];
			if(isset($included[$member])===false){
				unset($invertedJoinColumns[$column]);
			}
		}
	}
	
	private static function getToManyFields($included,&$toManyFields){
		foreach ($toManyFields as $member=>&$annot){
			if(isset($included[$member])===false){
				unset($toManyFields[$member]);
			}
		}
	}
	
	private static function _initRelationFields($included,$metaDatas,&$invertedJoinColumns,&$oneToManyFields,&$manyToManyFields){
		if (isset($metaDatas["#invertedJoinColumn"])){
			$invertedJoinColumns=$metaDatas["#invertedJoinColumn"];
		}
		if (isset($metaDatas["#oneToMany"])) {
			$oneToManyFields=$metaDatas["#oneToMany"];
		}
		if (isset($metaDatas["#manyToMany"])) {
			$manyToManyFields=$metaDatas["#manyToMany"];
		}
		if(is_array($included)){
			if(isset($invertedJoinColumns)){
				self::getInvertedJoinColumns($included, $invertedJoinColumns);
			}
			if(isset($oneToManyFields)){
				self::getToManyFields($included, $oneToManyFields);
			}
			if(isset($manyToManyFields)){
				self::getToManyFields($included, $manyToManyFields);
			}
		}
	}
}


1			<?php
2
3			namespace Ubiquity\orm\traits;
4
5			use Ubiquity\orm\OrmUtils;
6			use Ubiquity\orm\parser\ManyToManyParser;
7
8			trait DAORelationsTrait {
9
10			private static function _affectsRelationObjects($manyToOneQueries,$oneToManyQueries,$manyToManyParsers,$objects,$included,$useCache){
11			if(\sizeof($manyToOneQueries)>0){
12			self::_affectsObjectsFromArray($manyToOneQueries, $objects,$included, function($object,$member,$manyToOneObjects,$fkField){
13			self::affectsManyToOneFromArray($object,$member,$manyToOneObjects,$fkField);
14			});
15			}
16
17			if(\sizeof($oneToManyQueries)>0){
18			self::_affectsObjectsFromArray($oneToManyQueries, $objects,$included, function($object,$member,$relationObjects,$fkField){
19			self::affectsOneToManyFromArray($object,$member,$relationObjects,$fkField);
20			});
21			}
22
23			if(\sizeof($manyToManyParsers)>0){
24			self::_affectsManyToManyObjectsFromArray($manyToManyParsers, $objects,$included,$useCache);
25			}
26			}
27
28			private static function affectsManyToOneFromArray($object,$member,$manyToOneObjects,$fkField){
29			$class=\get_class($object);
30			if(isset($object->$fkField)){
31			$value=$manyToOneObjects[$object->$fkField];
32			self::setToMember($member, $object, $value, $class, "getManyToOne");
33			}
34			}
35
36			private static function _affectsObjectsFromArray($queries,$objects,$included,$affectsCallback,$useCache=NULL){
37			$includedNext=false;
38			foreach ($queries as $key=>$conditions){
39			list($class,$member,$fkField)=\explode("\|", $key);
40			if(is_array($included)){
41			$includedNext=self::_getIncludedNext($included, $member);
42			}
43			$condition=\implode(" OR ", $conditions);
44			$relationObjects=self::getAll($class,$condition,$includedNext,$useCache);
45			foreach ($objects as $object){
46			$affectsCallback($object, $member,$relationObjects,$fkField);
47			}
48			}
49			}
50
51			private static function _affectsManyToManyObjectsFromArray($parsers,$objects,$included,$useCache=NULL){
52			$includedNext=false;
53			foreach ($parsers as $key=>$parser){
54			list($class,$member,$inversedBy)=\explode("\|", $key);
			0 ignored issues – show Unused Code introduced 2018-06-10 13:55 UTC by Report Bug Copy Issue Report The assignment to `$inversedBy` is unused. Consider omitting it like so `list($first,,$third)`. This checks looks for assignemnts to variables using the `list(...)` function, where not all assigned variables are subsequently used. Consider the following code example. <?php function returnThreeValues() { return array('a', 'b', 'c'); } list($a, $b, $c) = returnThreeValues(); print $a . " - " . $c; Only the variables `$a` and `$c` are used. There was no need to assign `$b`. Instead, the list call could have been. list($a,, $c) = returnThreeValues(); Loading history...
55			if(is_array($included)){
56			$includedNext=self::_getIncludedNext($included, $member);
57			}
58			$condition=$parser->generate();
59			$relationObjects=self::getAll($class,$condition,$includedNext,$useCache);
60			foreach ($objects as $object){
61			$ret=self::getManyToManyFromArrayIds($object, $relationObjects, $member);
62			self::setToMember($member, $object, $ret, $class, "getManyToMany");
63			}
64			}
65			}
66
67			private static function _getIncludedNext($included,$member){
68			return (isset($included[$member]))?(is_bool($included[$member])?$included[$member]:[$included[$member]]):false;
69			}
70
71
72
73			private static function getManyToManyFromArrayIds($object, $relationObjects, $member){
74			$iMember="_".$member;
75			$ids=$object->$iMember;
76			$ret=[];
77			foreach ( $relationObjects as $targetEntityInstance ) {
78			$id=OrmUtils::getFirstKeyValue($targetEntityInstance);
79			if (array_search($id, $ids)!==false) {
80			array_push($ret, $targetEntityInstance);
81			}
82			}
83			unset($object->$iMember);
84			return $ret;
85			}
86
87			/**
88			* Prepares members associated with $instance with a ManyToMany type relationship
89			* @param $ret array of sql conditions
90			* @param object $instance
91			* @param string $member Member on which a ManyToMany annotation must be present
92			* @param array $annot used internally
93			*/
94			private static function prepareManyToMany(&$ret,$instance, $member, $annot=null) {
95			$class=get_class($instance);
96			$iMember="_".$member;
97			if (!isset($annot))
98			$annot=OrmUtils::getAnnotationInfoMember($class, "#ManyToMany", $member);
99			if ($annot !== false) {
100			$key=$annot["targetEntity"]."\|".$member."\|".$annot["inversedBy"];
101			if(!isset($ret[$key])){
102			$parser=new ManyToManyParser($instance, $member);
103			$parser->init($annot);
104			$ret[$key]=$parser;
105			}
106			$accessor="get" . ucfirst($ret[$key]->getMyPk());
107			if(method_exists($instance, $accessor)){
108			$fkv=$instance->$accessor();
109			$ret[$key]->addValue($fkv);
110			$result=self::$db->fetchAll($ret[$key]->getJoinSQL($fkv));
111			$instance->$iMember=$result;
112			}
113			}
114			}
115
116			/**
117			* Prepares members associated with $instance with a oneToMany type relationship
118			* @param $ret array of sql conditions
119			* @param object $instance
120			* @param string $member Member on which a OneToMany annotation must be present
121			* @param array $annot used internally
122			*/
123			private static function prepareOneToMany(&$ret,$instance, $member, $annot=null) {
124			$class=get_class($instance);
125			if (!isset($annot))
126			$annot=OrmUtils::getAnnotationInfoMember($class, "#oneToMany", $member);
127			if ($annot !== false) {
128			$fkAnnot=OrmUtils::getAnnotationInfoMember($annot["className"], "#joinColumn", $annot["mappedBy"]);
129			if ($fkAnnot !== false) {
130			$fkv=OrmUtils::getFirstKeyValue($instance);
131			$key=$annot["className"]."\|".$member."\|".$annot["mappedBy"];
132			if(!isset($ret[$key])){
133			$ret[$key]=[];
134			}
135			$ret[$key][$fkv]=$fkAnnot["name"] . "='" . $fkv . "'";
136			}
137			}
138			}
139
140			/**
141			* Prepares members associated with $instance with a manyToOne type relationship
142			* @param $ret array of sql conditions
143			* @param mixed $value
144			* @param string $fkField
145			* @param array $annotationArray
146			*/
147			private static function prepareManyToOne(&$ret, $value, $fkField,$annotationArray) {
148			$member=$annotationArray["member"];
149			$fk=OrmUtils::getFirstKey($annotationArray["className"]);
150			$key=$annotationArray["className"]."\|".$member."\|".$fkField;
151			if(!isset($ret[$key])){
152			$ret[$key]=[];
153			}
154			$ret[$key][$value]=$fk . "='" . $value . "'";
155			}
156
157			private static function getIncludedForStep($included){
158			if(is_bool($included)){
159			return $included;
160			}
161			$ret=[];
162			if(is_array($included)){
163			foreach ($included as $index=>&$includedMember){
164			if(is_array($includedMember)){
165			foreach ($includedMember as $iMember){
166			self::parseEncludeMember($ret, $iMember);
167			}
168			}else{
169			self::parseEncludeMember($ret, $includedMember);
170			}
171			}
172			}
173
174			return $ret;
175			}
176
177			private static function parseEncludeMember(&$ret,$includedMember){
178			$array=explode(".", $includedMember);
179			$member=array_shift($array);
180			if(sizeof($array)>0){
181			$newValue=implode(".", $array);
182			if($newValue==='*'){
183			$newValue=true;
184			}
185			if(isset($ret[$member])){
186			if(!is_array($ret[$member])){
187			$ret[$member]=[$ret[$member]];
188			}
189			$ret[$member][]=$newValue;
190			}else{
191			$ret[$member]=$newValue;
192			}
193			}else{
194			if(isset($member) && ""!=$member){
195			$ret[$member]=false;
196			}else{
197			return;
198			}
199			}
200			}
201
202			private static function getInvertedJoinColumns($included,&$invertedJoinColumns){
203			foreach ($invertedJoinColumns as $column=>&$annot){
204			$member=$annot["member"];
205			if(isset($included[$member])===false){
206			unset($invertedJoinColumns[$column]);
207			}
208			}
209			}
210
211			private static function getToManyFields($included,&$toManyFields){
212			foreach ($toManyFields as $member=>&$annot){
213			if(isset($included[$member])===false){
214			unset($toManyFields[$member]);
215			}
216			}
217			}
218
219			private static function _initRelationFields($included,$metaDatas,&$invertedJoinColumns,&$oneToManyFields,&$manyToManyFields){
220			if (isset($metaDatas["#invertedJoinColumn"])){
221			$invertedJoinColumns=$metaDatas["#invertedJoinColumn"];
222			}
223			if (isset($metaDatas["#oneToMany"])) {
224			$oneToManyFields=$metaDatas["#oneToMany"];
225			}
226			if (isset($metaDatas["#manyToMany"])) {
227			$manyToManyFields=$metaDatas["#manyToMany"];
228			}
229			if(is_array($included)){
230			if(isset($invertedJoinColumns)){
231			self::getInvertedJoinColumns($included, $invertedJoinColumns);
232			}
233			if(isset($oneToManyFields)){
234			self::getToManyFields($included, $oneToManyFields);
235			}
236			if(isset($manyToManyFields)){
237			self::getToManyFields($included, $manyToManyFields);
238			}
239			}
240			}
241			}
242

phpMv / ubiquity

Push — master ( 61f3b2...32110c )

DAORelationsTrait::_initRelationFields() C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like