Ubiquity\orm\traits\OrmUtilsRelationsTrait

Complexity

Total Complexity

49

Size/Duplication

Total Lines	201
Duplicated Lines	0 %

Test Coverage

Coverage

30.65%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
B	getAnnotFieldsInRelations()	0	21	8
A	getJoinAlias()	0	2	1
A	getAllJoinTables()	0	6	2
A	getJoinColumnName()	0	8	2
A	getDefaultFk()	0	2	1
A	getFieldsInRelations_()	0	2	1
A	getOneToManyFields()	0	2	1
A	getJoinTables()	0	10	3
A	getUJoinSQL()	0	33	5
A	getMemberJoinColumns()	0	12	4
A	getManyToManyFields()	0	5	2
A	getManyToOneFields()	0	2	1
B	getFieldsInRelationsForUpdate_()	0	21	7
B	getManyToOneMembersAndValues()	0	20	7
A	getFieldsInRelations()	0	13	4

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