DAORelationsTrait::generateManyToManyParser() - Code Metrics - Inspection of "Fix DAO size" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 6bed03...9b7ff5 )

by Jean-Christophe
created 2019-09-24 18:11 UTC
DAORelationsTrait::generateManyToManyParser() A

↳ Parent: DAORelationsTrait
Complexity

Conditions	2
Paths	2
Size

Total Lines	12
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	11
CRAP Score	2
Importance

Changes
Metric	Value
cc	2
eloc	10
nc	2
nop	2
dl	0
loc	12
ccs	11
cts	11
cp	1
crap	2
rs	9.9332
c	0
b	0
f	0
<?php

namespace Ubiquity\orm\traits;

use Ubiquity\orm\OrmUtils;
use Ubiquity\orm\parser\ManyToManyParser;
use Ubiquity\orm\parser\ConditionParser;
use Ubiquity\orm\parser\Reflexion;
use Ubiquity\db\Database;
use Ubiquity\log\Logger;
use Ubiquity\db\SqlUtils;

/**
 *
 * @author jc
 * @property \Ubiquity\db\Database $db
 */
trait DAORelationsTrait {

	abstract protected static function _getAll(Database $db, $className, ConditionParser $conditionParser, $included = true, $useCache = NULL);

	private static function generateManyToManyParser(ManyToManyParser $parser, &$myPkValues) {
		$sql = $parser->generateConcatSQL ();
		$result = self::getDb ( $parser->getTargetEntityClass () )->prepareAndFetchAll ( $sql, $parser->getWhereValues () );
		$condition = $parser->getParserWhereMask ( " ?" );
		$cParser = new ConditionParser ();
		foreach ( $result as $row ) {
			$values = explode ( ",", $row ["_concat"] );
			$myPkValues [$row ["_field"]] = $values;
			$cParser->addParts ( $condition, $values );
		}
		$cParser->compileParts ();
		return $cParser;
	}

	private static function _getIncludedNext($included, $member) {
		return (isset ( $included [$member] )) ? (\is_bool ( $included [$member] ) ? $included [$member] : [ $included [$member] ]) : false;
	}

	private static function getManyToManyFromArrayIds($objectClass, $relationObjects, $ids) {
		$ret = [ ];
		$prop = OrmUtils::getFirstPropKey ( $objectClass );
		foreach ( $relationObjects as $targetEntityInstance ) {
			$id = Reflexion::getPropValue ( $targetEntityInstance, $prop );
			if (\array_search ( $id, $ids ) !== false) {
				\array_push ( $ret, $targetEntityInstance );
			}
		}
		return $ret;
	}

	protected static function getIncludedForStep($included) {
		if (\is_bool ( $included )) {
			return $included;
		}
		$ret = [ ];
		if (\is_array ( $included )) {
			foreach ( $included as &$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) {
		foreach ( $invertedJoinColumns as $column => &$annot ) {
			$member = $annot ["member"];
			if (isset ( $included [$member] ) === false) {
				unset ( $invertedJoinColumns [$column] );
			}
		}
	}

	private static function getToManyFields($included, &$toManyFields) {
		foreach ( $toManyFields as $member => $annotNotUsed ) {
			if (isset ( $included [$member] ) === false) {
				unset ( $toManyFields [$member] );
			}
		}
	}

	protected static function _initRelationFields($included, $metaDatas, &$invertedJoinColumns, &$oneToManyFields, &$manyToManyFields) {
		if (isset ( $metaDatas ["#invertedJoinColumn"] )) {
			$invertedJoinColumns = $metaDatas ["#invertedJoinColumn"];
		}
		if (isset ( $metaDatas ["#oneToMany"] )) {
			$oneToManyFields = $metaDatas ["#oneToMany"];
		}
		if (isset ( $metaDatas ["#manyToMany"] )) {
			$manyToManyFields = $metaDatas ["#manyToMany"];
		}
		if (\is_array ( $included )) {
			if (isset ( $invertedJoinColumns )) {
				self::getInvertedJoinColumns ( $included, $invertedJoinColumns );
			}
			if (isset ( $oneToManyFields )) {
				self::getToManyFields ( $included, $oneToManyFields );
			}
			if (isset ( $manyToManyFields )) {
				self::getToManyFields ( $included, $manyToManyFields );
			}
		}
	}

	/**
	 * Loads member associated with $instance by a ManyToOne relationship
	 *
	 * @param object|array $instance The instance object or an array with [classname,id]
	 * @param string $member The member to load
	 * @param boolean|array $included if true, loads associate members with associations, if array, example : ["client.*","commands"]
	 * @param boolean|null $useCache
	 */
	public static function getManyToOne($instance, $member, $included = false, $useCache = NULL) {
		$classname = self::getClass_ ( $instance );
		if (is_array ( $instance )) {
			$instance = self::getById ( $classname, $instance [1], false, $useCache );
		}
		$fieldAnnot = OrmUtils::getMemberJoinColumns ( $classname, $member );
		if ($fieldAnnot !== null) {
			$annotationArray = $fieldAnnot [1];
			$member = $annotationArray ["member"];
			$value = Reflexion::getMemberValue ( $instance, $member );
			$key = OrmUtils::getFirstKey ( $annotationArray ["className"] );
			$kv = array ($key => $value );
			$obj = self::getById ( $annotationArray ["className"], $kv, $included, $useCache );
			if ($obj !== null) {
				Logger::info ( "DAO", "Loading the member " . $member . " for the object " . $classname, "getManyToOne" );
				$accesseur = "set" . ucfirst ( $member );
				if (\is_object ( $instance ) && \method_exists ( $instance, $accesseur )) {
					$instance->$accesseur ( $obj );
					$instance->_rest [$member] = $obj->_rest;
				}
				return $obj;
			}
		}
	}

	/**
	 * Assign / load the child records in the $member member of $instance.
	 *
	 * @param object|array $instance The instance object or an array with [classname,id]
	 * @param string $member Member on which a oneToMany annotation must be present
	 * @param boolean|array $included if true, loads associate members with associations, if array, example : ["client.*","commands"]
	 * @param boolean $useCache
	 * @param array $annot used internally
	 */
	public static function getOneToMany($instance, $member, $included = true, $useCache = NULL, $annot = null) {
		$ret = array ();
		$class = self::getClass_ ( $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 = self::getFirstKeyValue_ ( $instance );
				$db = self::getDb ( $annot ["className"] );
				$ret = self::_getAll ( $db, $annot ["className"], ConditionParser::simple ( $db->quote . $fkAnnot ["name"] . $db->quote . "= ?", $fkv ), $included, $useCache );
				if (is_object ( $instance ) && $modifier = self::getAccessor ( $member, $instance, 'getOneToMany' )) {
					self::setToMember ( $member, $instance, $ret, $modifier );
				}
			}
		}
		return $ret;
	}

	/**
	 * Assigns / loads the child records in the $member member of $instance.
	 * If $array is null, the records are loaded from the database
	 *
	 * @param object|array $instance The instance object or an array with [classname,id]
	 * @param string $member Member on which a ManyToMany annotation must be present
	 * @param boolean|array $included if true, loads associate members with associations, if array, example : ["client.*","commands"]
	 * @param array $array optional parameter containing the list of possible child records
	 * @param boolean $useCache
	 */
	public static function getManyToMany($instance, $member, $included = false, $array = null, $useCache = NULL) {
		$ret = [ ];
		$class = self::getClass_ ( $instance );
		$parser = new ManyToManyParser ( $class, $member );
		if ($parser->init ()) {
			if (\is_null ( $array )) {
				$pk = self::getFirstKeyValue_ ( $instance );
				$quote = SqlUtils::$quote;
				$condition = " INNER JOIN " . $quote . $parser->getJoinTable () . $quote . " on " . $quote . $parser->getJoinTable () . $quote . "." . $quote . $parser->getFkField () . $quote . "=" . $quote . $parser->getTargetEntityTable () . $quote . "." . $quote . $parser->getPk () . $quote . " WHERE " . $quote . $parser->getJoinTable () . $quote . "." . $quote . $parser->getMyFkField () . $quote . "= ?";
				$targetEntityClass = $parser->getTargetEntityClass ();
				$ret = self::_getAll ( self::getDb ( $targetEntityClass ), $targetEntityClass, ConditionParser::simple ( $condition, $pk ), $included, $useCache );
			} else {
				$ret = self::getManyToManyFromArray ( $instance, $array, $class, $parser );
    $ret = self::getManyToManyFromArray ( $instance, $array, $class, $parser );
			}
			if (\is_object ( $instance ) && $modifier = self::getAccessor ( $member, $instance, 'getManyToMany' )) {
				self::setToMember ( $member, $instance, $ret, $modifier );
			}
		}
		return $ret;
	}

	/**
	 *
	 * @param object $instance
	 * @param array $array
	 * @param boolean $useCache
	 */
	public static function affectsManyToManys($instance, $array = NULL, $useCache = NULL) {
		$metaDatas = OrmUtils::getModelMetadata ( \get_class ( $instance ) );
		$manyToManyFields = $metaDatas ["#manyToMany"];
		if (\sizeof ( $manyToManyFields ) > 0) {
			foreach ( $manyToManyFields as $member ) {
				self::getManyToMany ( $instance, $member, false, $array, $useCache );
			}
		}
	}
}

phpMv / ubiquity

Push — master ( 6bed03...9b7ff5 )

DAORelationsTrait::generateManyToManyParser() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
