Ubiquity\orm\traits\DAORelationsTrait

Complexity

Total Complexity

52

Size/Duplication

Total Lines	211
Duplicated Lines	2.84 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	_affectsRelationObjects()	0	17	4
A	affectsManyToOneFromArray()	0	7	2
B	_affectsObjectsFromArray()	3	14	6
B	_affectsManyToManyObjectsFromArray()	3	15	6
A	getManyToManyFromArrayIds()	0	13	3
B	prepareManyToMany()	0	21	5
B	prepareOneToMany()	0	16	5
A	prepareManyToOne()	0	9	2
B	getIncludedForStep()	0	19	6
C	parseEncludeMember()	0	24	7
A	getInvertedJoinColumns()	0	10	3
A	getToManyFields()	0	9	3

<?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)){

This code seems to be duplicated across your project.

				$includedNext=(isset($included[$member]))?(is_bool($included[$member])?$included[$member]:[$included[$member]]):false;
			}
			$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);

The assignment to $inversedBy is unused. Consider omitting it like so list($first,,$third).

			if(is_array($included)){

This code seems to be duplicated across your project.

				$includedNext=(isset($included[$member]))?(is_bool($included[$member])?$included[$member]:[$included[$member]]):false;
			}
			$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 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){
		$ret=[];
		foreach ($invertedJoinColumns as $column=>$annot){
			$member=$annot["member"];
			if(isset($included[$member])){
				$ret[$column]=$annot;
			}
		}
		return $ret;
	}
	
	private static function getToManyFields($included,$toManyFields){
		$ret=[];
		foreach ($toManyFields as $member=>$annot){
			if(isset($included[$member])){
				$ret[$member]=$annot;
			}
		}
		return $ret;
	}
}