micro\orm\OrmUtils

Complexity

Total Complexity

48

Size/Duplication

Total Lines	185
Duplicated Lines	11.89 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	getModelMetadata()	0	6	2
A	isSerializable()	7	7	2
A	isNullable()	7	7	2
A	getFieldName()	8	8	2
A	getTableName()	0	3	1
A	getKeyFieldsAndValues()	0	4	1
A	getKeyFields()	0	3	1
A	getMembers()	0	6	2
B	getMembersAndValues()	0	16	5
A	isNotNullOrNullAccepted()	0	4	3
A	getFirstKey()	0	4	1
A	getFirstKeyValue()	0	4	1
B	getManyToOneMembersAndValues()	0	21	6
A	getMembersWithAnnotation()	0	5	2
B	exists()	0	12	5
A	getJoinColumnName()	0	9	2
A	getAnnotationInfo()	0	5	2
A	getAnnotationInfoMember()	0	9	3
A	getSerializableFields()	0	5	1
A	getFieldsInRelations()	0	10	3
A	getDefaultFk()	0	3	1

<?php
namespace micro\orm;

use micro\orm\parser\Reflexion;
use micro\cache\CacheManager;
use micro\utils\StrUtils;

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

	public static function getModelMetadata($className){
		if(!isset(self::$modelsMetadatas[$className])){
			self::$modelsMetadatas[$className]=CacheManager::createOrmModelCache($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 getTableName($class){
		return self::getModelMetadata($class)["#tableName"];
	}

	public static function getKeyFieldsAndValues($instance){
		$kf=self::getAnnotationInfo(get_class($instance), "#primaryKeys");
		return self::getMembersAndValues($instance,$kf);
	}

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

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

	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=StrUtils::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);
	}

	/**
	 * @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(isset($info[$member])){
				return $info[$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));
		}
		return $result;
	}

	public static function getDefaultFk($classname){
		return "id".\ucfirst(self::getTableName($classname));
	}
}