OrmUtilsRelationsTrait::getManyToOneFields() - Code Metrics - Inspection of "Transactions feature" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#46)

by Jean-Christophe

created 2019-05-13 01:49 UTC

OrmUtilsRelationsTrait::getManyToOneFields() A

↳ Parent: OrmUtilsRelationsTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	2
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php

namespace Ubiquity\orm\traits;

use Ubiquity\orm\parser\ManyToManyParser;

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

phpMv / ubiquity

Pull Request — master (#46)

OrmUtilsRelationsTrait::getManyToOneFields() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like