OrmUtils::getKeyValues() - Code Metrics - Inspection of "Fix getAll bug (getFirstKeyValue->getKeyValues)" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a6a009...27ae86 )

by Jean-Christophe

created 2018-06-08 01:21 UTC

OrmUtils::getKeyValues() A

↳ Parent: OrmUtils

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	3
nc	1
nop	1

<?php

namespace Ubiquity\orm;

use Ubiquity\orm\parser\Reflexion;
use Ubiquity\cache\CacheManager;
use Ubiquity\utils\base\UString;
use Ubiquity\utils\base\UArray;
use Ubiquity\controllers\rest\ResponseFormatter;

/**
 * Utilitaires de mappage Objet/relationnel
 * @author jc
 * @version 1.0.0.5
 */
class OrmUtils {
	private static $modelsMetadatas;

	public static function getModelMetadata($className) {
		if (!isset(self::$modelsMetadatas[$className])) {
			self::$modelsMetadatas[$className]=CacheManager::getOrmModelCache($className);
		}
		return self::$modelsMetadatas[$className];
	}

	public static function isSerializable($class, $member) {
		$ret=self::getAnnotationInfo($class, "#notSerializable");
		if ($ret !== false)
			return \array_search($member, $ret) === false;
		else
			return true;
	}

	public static function isNullable($class, $member) {
		$ret=self::getAnnotationInfo($class, "#nullable");
		if ($ret !== false)
			return \array_search($member, $ret) !== false;
		else
			return false;
	}

	public static function getFieldName($class, $member) {
		$ret=self::getAnnotationInfo($class, "#fieldNames");
		if ($ret === false)
			$ret=$member;
		else
			$ret=$ret[$member];
		return $ret;
	}

	public static function getFieldNames($model){
		$fields=self::getAnnotationInfo($model, "#fieldNames");
		$result=[];
		$serializables=self::getSerializableFields($model);
		foreach ($fields as $member=>$field){
			if(\array_search($member, $serializables)!==false)
				$result[$field]=$member;
		}
		return $result;
	}

	public static function getTableName($class) {
		if(isset(self::getModelMetadata($class)["#tableName"]))
		return self::getModelMetadata($class)["#tableName"];
	}
	
	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 getKeyFieldsAndValues($instance) {
		$kf=self::getAnnotationInfo(get_class($instance), "#primaryKeys");
		return self::getMembersAndValues($instance, $kf);
	}

	public static function getKeyFields($instance) {
		if(!\is_string($instance)){
			$instance=\get_class($instance);
		}
		return self::getAnnotationInfo($instance, "#primaryKeys");
	}

	public static function getMembers($className) {
		$fieldNames=self::getAnnotationInfo($className, "#fieldNames");
		if ($fieldNames !== false)
			return \array_keys($fieldNames);
		return [ ];
	}

	public static function getFieldTypes($className) {
		$fieldTypes=self::getAnnotationInfo($className, "#fieldTypes");
		if ($fieldTypes !== false)
			return $fieldTypes;
		return [ ];
	}

	public static function getFieldType($className,$field){
		$types= self::getFieldTypes($className);
		if(isset($types[$field]))
			return $types[$field];
		return "int";
	}

	public static function getMembersAndValues($instance, $members=NULL) {
		$ret=array ();
		$className=get_class($instance);
		if (is_null($members))
			$members=self::getMembers($className);
		foreach ( $members as $member ) {
			if (OrmUtils::isSerializable($className, $member)) {
				$v=Reflexion::getMemberValue($instance, $member);
				if (self::isNotNullOrNullAccepted($v, $className, $member)) {
					$name=self::getFieldName($className, $member);
					$ret[$name]=$v;
				}
			}
		}
		return $ret;
	}

	public static function isNotNullOrNullAccepted($v, $className, $member) {
		$notNull=UString::isNotNull($v);
		return ($notNull) || (!$notNull && OrmUtils::isNullable($className, $member));
	}

	public static function getFirstKey($class) {
		$kf=self::getAnnotationInfo($class, "#primaryKeys");
		return \reset($kf);
	}

	public static function getFirstKeyValue($instance) {
		$fkv=self::getKeyFieldsAndValues($instance);
		return \reset($fkv);
	}
	
	public static function getKeyValues($instance) {
		$fkv=self::getKeyFieldsAndValues($instance);
		return implode("_",$fkv);
	}

	/**
	 *
	 * @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)) {
						$keyValues=self::getKeyFieldsAndValues($memberInstance);
						if (sizeof($keyValues) > 0) {
							$fkName=self::getJoinColumnName($class, $member);
							$ret[$fkName]=reset($keyValues);
						}
					}
				}
			}
		}
		return $ret;
	}

	public static function getMembersWithAnnotation($class, $annotation) {
		if (isset(self::getModelMetadata($class)[$annotation]))
			return self::getModelMetadata($class)[$annotation];
		return [ ];
	}

	/**
	 *
	 * @param object $instance
	 * @param string $memberKey
	 * @param array $array
	 * @return boolean
	 */
	public static function exists($instance, $memberKey, $array) {
		$accessor="get" . ucfirst($memberKey);
		if (method_exists($instance, $accessor)) {
			if ($array !== null) {
				foreach ( $array as $value ) {
					if ($value->$accessor() == $instance->$accessor())
						return true;
				}
			}
		}
		return false;
	}

	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;
	}

	public static function getAnnotationInfo($class, $keyAnnotation) {
		if (isset(self::getModelMetadata($class)[$keyAnnotation]))
			return self::getModelMetadata($class)[$keyAnnotation];
		return false;
	}

	public static function getAnnotationInfoMember($class, $keyAnnotation, $member) {
		$info=self::getAnnotationInfo($class, $keyAnnotation);
		if ($info !== false) {
			if(UArray::isAssociative($info)){
				if (isset($info[$member])) {
					return $info[$member];
				}
			}else{
				if(\array_search($member, $info)!==false){
					return $member;
				}
			}
		}
		return false;
	}

	public static function getSerializableFields($class) {
		$notSerializable=self::getAnnotationInfo($class, "#notSerializable");
		$fieldNames=\array_keys(self::getAnnotationInfo($class, "#fieldNames"));
		return \array_diff($fieldNames, $notSerializable);
	}

	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 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;
	}
	
	public static function objectAsJSON($instance){
		$formatter=new ResponseFormatter();
		$datas=$formatter->cleanRestObject($instance);
		return $formatter->format(["pk"=>self::getFirstKeyValue($instance),"object"=>$datas]);
	}
}


1		<?php
2
3		namespace Ubiquity\orm;
4
5		use Ubiquity\orm\parser\Reflexion;
6		use Ubiquity\cache\CacheManager;
7		use Ubiquity\utils\base\UString;
8		use Ubiquity\utils\base\UArray;
9		use Ubiquity\controllers\rest\ResponseFormatter;
10
11		/**
12		* Utilitaires de mappage Objet/relationnel
13		* @author jc
14		* @version 1.0.0.5
15		*/
16		class OrmUtils {
17		private static $modelsMetadatas;
18
19		public static function getModelMetadata($className) {
20		if (!isset(self::$modelsMetadatas[$className])) {
21		self::$modelsMetadatas[$className]=CacheManager::getOrmModelCache($className);
22		}
23		return self::$modelsMetadatas[$className];
24		}
25
26	View Code Duplication	public static function isSerializable($class, $member) {
27		$ret=self::getAnnotationInfo($class, "#notSerializable");
28		if ($ret !== false)
29		return \array_search($member, $ret) === false;
30		else
31		return true;
32		}
33
34	View Code Duplication	public static function isNullable($class, $member) {
35		$ret=self::getAnnotationInfo($class, "#nullable");
36		if ($ret !== false)
37		return \array_search($member, $ret) !== false;
38		else
39		return false;
40		}
41
42		public static function getFieldName($class, $member) {
43		$ret=self::getAnnotationInfo($class, "#fieldNames");
44		if ($ret === false)
45		$ret=$member;
46		else
47		$ret=$ret[$member];
48		return $ret;
49		}
50
51		public static function getFieldNames($model){
52		$fields=self::getAnnotationInfo($model, "#fieldNames");
53		$result=[];
54		$serializables=self::getSerializableFields($model);
55		foreach ($fields as $member=>$field){
56		if(\array_search($member, $serializables)!==false)
57		$result[$field]=$member;
58		}
59		return $result;
60		}
61
62		public static function getTableName($class) {
63		if(isset(self::getModelMetadata($class)["#tableName"]))
64		return self::getModelMetadata($class)["#tableName"];
65		}
66
67		public static function getJoinTables($class){
68		$result=[];
69
70		if(isset(self::getModelMetadata($class)["#joinTable"])){
71		$jts=self::getModelMetadata($class)["#joinTable"];
72		foreach ($jts as $jt){
73		$result[]=$jt["name"];
74		}
75		}
76		return $result;
77		}
78
79	View Code Duplication	public static function getAllJoinTables($models){
		1 ignored issue – show Duplication introduced 2018-06-04 00:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
80		$result=[];
81		foreach ($models as $model){
82		$result=array_merge($result,self::getJoinTables($model));
83		}
84		return $result;
85		}
86
87		public static function getKeyFieldsAndValues($instance) {
88		$kf=self::getAnnotationInfo(get_class($instance), "#primaryKeys");
89		return self::getMembersAndValues($instance, $kf);
90		}
91
92		public static function getKeyFields($instance) {
93		if(!\is_string($instance)){
94		$instance=\get_class($instance);
95		}
96		return self::getAnnotationInfo($instance, "#primaryKeys");
97		}
98
99		public static function getMembers($className) {
100		$fieldNames=self::getAnnotationInfo($className, "#fieldNames");
101		if ($fieldNames !== false)
102		return \array_keys($fieldNames);
103		return [ ];
104		}
105
106		public static function getFieldTypes($className) {
107		$fieldTypes=self::getAnnotationInfo($className, "#fieldTypes");
108		if ($fieldTypes !== false)
109		return $fieldTypes;
110		return [ ];
111		}
112
113		public static function getFieldType($className,$field){
114		$types= self::getFieldTypes($className);
115		if(isset($types[$field]))
116		return $types[$field];
117		return "int";
118		}
119
120		public static function getMembersAndValues($instance, $members=NULL) {
121		$ret=array ();
122		$className=get_class($instance);
123		if (is_null($members))
124		$members=self::getMembers($className);
125		foreach ( $members as $member ) {
126		if (OrmUtils::isSerializable($className, $member)) {
127		$v=Reflexion::getMemberValue($instance, $member);
128	View Code Duplication	if (self::isNotNullOrNullAccepted($v, $className, $member)) {
129		$name=self::getFieldName($className, $member);
130		$ret[$name]=$v;
131		}
132		}
133		}
134		return $ret;
135		}
136
137		public static function isNotNullOrNullAccepted($v, $className, $member) {
138		$notNull=UString::isNotNull($v);
139		return ($notNull) \|\| (!$notNull && OrmUtils::isNullable($className, $member));
140		}
141
142		public static function getFirstKey($class) {
143		$kf=self::getAnnotationInfo($class, "#primaryKeys");
144		return \reset($kf);
145		}
146
147		public static function getFirstKeyValue($instance) {
148		$fkv=self::getKeyFieldsAndValues($instance);
149		return \reset($fkv);
150		}
151
152		public static function getKeyValues($instance) {
153		$fkv=self::getKeyFieldsAndValues($instance);
154		return implode("_",$fkv);
155		}
156
157		/**
158		*
159		* @param object $instance
160		* @return mixed[]
161		*/
162		public static function getManyToOneMembersAndValues($instance) {
163		$ret=array ();
164		$class=get_class($instance);
165		$members=self::getAnnotationInfo($class, "#manyToOne");
166		if ($members !== false) {
167		foreach ( $members as $member ) {
168		$memberAccessor="get" . ucfirst($member);
169		if (method_exists($instance, $memberAccessor)) {
170		$memberInstance=$instance->$memberAccessor();
171		if (isset($memberInstance)) {
172		$keyValues=self::getKeyFieldsAndValues($memberInstance);
173		if (sizeof($keyValues) > 0) {
174		$fkName=self::getJoinColumnName($class, $member);
175		$ret[$fkName]=reset($keyValues);
176		}
177		}
178		}
179		}
180		}
181		return $ret;
182		}
183
184		public static function getMembersWithAnnotation($class, $annotation) {
185		if (isset(self::getModelMetadata($class)[$annotation]))
186		return self::getModelMetadata($class)[$annotation];
187		return [ ];
188		}
189
190		/**
191		*
192		* @param object $instance
193		* @param string $memberKey
194		* @param array $array
195		* @return boolean
196		*/
197		public static function exists($instance, $memberKey, $array) {
198		$accessor="get" . ucfirst($memberKey);
199		if (method_exists($instance, $accessor)) {
200		if ($array !== null) {
201		foreach ( $array as $value ) {
202		if ($value->$accessor() == $instance->$accessor())
203		return true;
204		}
205		}
206		}
207		return false;
208		}
209
210		public static function getJoinColumnName($class, $member) {
211		$annot=self::getAnnotationInfoMember($class, "#joinColumn", $member);
212		if ($annot !== false) {
213		$fkName=$annot["name"];
214		} else {
215		$fkName="id" . ucfirst(self::getTableName(ucfirst($member)));
216		}
217		return $fkName;
218		}
219
220		public static function getAnnotationInfo($class, $keyAnnotation) {
221		if (isset(self::getModelMetadata($class)[$keyAnnotation]))
222		return self::getModelMetadata($class)[$keyAnnotation];
223		return false;
224		}
225
226		public static function getAnnotationInfoMember($class, $keyAnnotation, $member) {
227		$info=self::getAnnotationInfo($class, $keyAnnotation);
228		if ($info !== false) {
229		if(UArray::isAssociative($info)){
230		if (isset($info[$member])) {
231		return $info[$member];
232		}
233		}else{
234		if(\array_search($member, $info)!==false){
235		return $member;
236		}
237		}
238		}
239		return false;
240		}
241
242		public static function getSerializableFields($class) {
243		$notSerializable=self::getAnnotationInfo($class, "#notSerializable");
244		$fieldNames=\array_keys(self::getAnnotationInfo($class, "#fieldNames"));
245		return \array_diff($fieldNames, $notSerializable);
246		}
247
248		public static function getFieldsInRelations($class) {
249		$result=[ ];
250		if ($manyToOne=self::getAnnotationInfo($class, "#manyToOne")) {
251		$result=\array_merge($result, $manyToOne);
252		}
253		if ($oneToMany=self::getAnnotationInfo($class, "#oneToMany")) {
254		$result=\array_merge($result, \array_keys($oneToMany));
255		}
256		if ($manyToMany=self::getAnnotationInfo($class, "#manyToMany")) {
257		$result=\array_merge($result, \array_keys($manyToMany));
258		}
259		return $result;
260		}
261
262		public static function getManyToOneFields($class) {
263		return self::getAnnotationInfo($class, "#manyToOne");
264		}
265
266		public static function getManyToManyFields($class) {
267		$result=self::getAnnotationInfo($class, "#manyToMany");
268		if($result!==false)
269		return \array_keys($result);
270		return [];
271		}
272
273		public static function getDefaultFk($classname) {
274		return "id" . \ucfirst(self::getTableName($classname));
275		}
276
277		public static function getMemberJoinColumns($instance,$member,$metaDatas=NULL){
278		if(!isset($metaDatas)){
279		$class=get_class($instance);
280		$metaDatas=self::getModelMetadata($class);
281		}
282		$invertedJoinColumns=$metaDatas["#invertedJoinColumn"];
283		foreach ($invertedJoinColumns as $field=>$invertedJoinColumn){
284		if($invertedJoinColumn["member"]===$member){
285		return [$field,$invertedJoinColumn];
286		}
287		}
288		return null;
289		}
290
291		public static function objectAsJSON($instance){
292		$formatter=new ResponseFormatter();
293		$datas=$formatter->cleanRestObject($instance);
294		return $formatter->format(["pk"=>self::getFirstKeyValue($instance),"object"=>$datas]);
295		}
296		}
297

phpMv / ubiquity

Push — master ( a6a009...27ae86 )

OrmUtils::getKeyValues() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like