neon\daedalus\services\ddsManager\DdsObjectMapManager::getObjectMap()

Complexity

Conditions	29
Paths	538

Size

Total Lines	125
Code Lines	100

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	81
CRAP Score	31.6933

Importance

Changes	1
Bugs	0	Features	0

<?php
	public function getObjectMap($classType, $filters=[], $fields=[], $start=0, $length=1000, $includeDeleted=false)
	{
		if (!$classType)
			throw new \InvalidArgumentException("Invalid classType '$classType' in getObjectMap. Correct calling code");

		$cacheKey = md5(serialize(func_get_args()));
		if (empty(self::$_mapResultsCache[$cacheKey])) {
			try {
				$limit = ['start' => max(0, (integer)$start), 'length' => min(1000, (integer)$length)];
				$classType = $this->canonicaliseRef($classType);
				$fieldsClause = '';
				$linkJoins = [];
				if ($fields) {
					$getFields = [];
					$field2link = [];
					$linkedMemberRows = DdsMember::find()
						->select(['member_ref', 'link_class', 'data_type_ref'])
						->where(['class_type'=>$classType, 'data_type_ref' => ['link_uni', 'link_multi'], 'member_ref'=>$fields, 'deleted' => 0])
						->asArray()->all();
					$linkedMembers = Arr::index($linkedMemberRows, 'member_ref');
					if ($linkedMemberRows) {

The expression $linkedMemberRows of type yii\db\ActiveRecordInterface[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

						$linkedMemberClasses = DdsMember::find()
							->select(['class_type', 'member_ref'])
							->where(['class_type'=>Arr::pluck($linkedMemberRows, 'link_class'), 'map_field'=>1, 'deleted' => 0])
							->asArray()->all();
						$class2Member = Arr::index($linkedMemberClasses, 'class_type');
						foreach ($linkedMembers as $lm) {
							// only try to link through to tables that are within daedalus
							if (isset($class2Member[$lm['link_class']]))
								$field2link[$lm['member_ref']] = $class2Member[$lm['link_class']];
						}
					}
					foreach ($fields as $field) {
						if (array_key_exists($field, $field2link)) {
							$fl = $field2link[$field];
							$table = $this->getTableFromClassType($fl['class_type']);
							$getFields[] = "`$table`.`$fl[member_ref]`";
							if ($linkedMembers[$field]['data_type_ref'] == 'link_uni')
								$linkJoins[$table] = "LEFT JOIN `$table` ON `t`.`$field`=`$table`.`_uuid`";
							else {
								$linkName = 'link'.$field;
								$linkJoins[$linkName] = "LEFT JOIN `dds_link` `$linkName` ON (`o`.`_uuid`=`$linkName`.`from_id` AND `$linkName`.`from_member`='$field')";
								$linkJoins[$table] = "LEFT JOIN `$table` ON `$linkName`.`to_id` =`$table`.`_uuid`";
							}
						} else {
							$getFields[] = "`t`.`$field`";
						}
					}
					$fieldsClause = implode(', ', $getFields);
				} else {
					$member = $this->getMapMemberForClass($classType);
					if (!$member)
						throw new \RuntimeException("There is no mappable member field set on class $classType");
					// set this as an array for later
					$fields = [$member['member_ref']];
					$fieldsClause = "`t`.`$member[member_ref]`";
				}
				$map = [];
				$notDeleted = $includeDeleted ? '' : 'AND `o`.`_deleted`=0';
				$table = $this->getTableFromClassType($classType);
				// set up any additional filtering
				$filterClause = '';
				$filterValues = [];
				if ($filters) {
					$ddsObjectFields = ['_uuid','_created','_deleted','_updated'];
					// whitelist filter keys to prevent sql injection
					$members = $this->getClassMembers($classType);
					$filterSubClause = [];
					foreach ($filters as $field=>$value) {
						if ($field == '_map_field_') {
							$mapMember = $this->getMapMemberForClass($classType);
							if ($mapMember && $value)
								$filterSubClause[] = "AND `t`.`$mapMember[member_ref]` LIKE '%$value%'";
							continue;
						}
						if (!(isset($members[$field]) || in_array($field, $ddsObjectFields)))
							continue;
						$keyClause = (in_array($field, $ddsObjectFields)) ? "`o`.`$field`" : "`t`.`$field`";
						$value = is_array($value) ? $value : [$value];
						$vcount = 1;
						$inClause = [];
						foreach ($value as $v) {
							$inClause[] = ":$field$vcount";
							$filterValues[":$field$vcount"] = $v;
							$vcount++;
						}
						$inClause = implode(',',$inClause);
						if (!empty($members[$field]) && $members[$field]['data_type_ref'] == 'link_multi') {
							$linkName = "link$field";
							if (!isset($linkJoins[$linkName]))
								$linkJoins[$linkName] = "LEFT JOIN `dds_link` `$linkName` ON (`o`.`_uuid`=`$linkName`.`from_id` AND `$linkName`.`from_member`='$field')";
							$filterSubClause[] = "AND `$linkName`.`to_id` IN ($inClause)";
						} else {
							$filterSubClause[] = "AND $keyClause IN ($inClause)";
						}
					}
					$filterClause = implode (' ', $filterSubClause);
				}
				$linkJoinsClause = implode(' ', $linkJoins);

				$query = "SELECT DISTINCT `o`.`_uuid`, $fieldsClause FROM `dds_object` `o` LEFT JOIN  `$table` `t` ON `o`.`_uuid`=`t`.`_uuid` " .
					"$linkJoinsClause WHERE `o`.`_class_type` = '$classType' $filterClause $notDeleted ORDER BY $fieldsClause " .
					"LIMIT $limit[start], $limit[length]";
				$command = neon()->db->createCommand($query);
				if ($filters)
					$command->bindValues($filterValues);
				$rows = $command->queryAll();
				foreach ($rows as $r) {
					// extract out the uuid result
					$uuid = $r['_uuid'];
					unset($r['_uuid']);

					// set the map
					$map[$uuid] = (count($fields)==1) ? current($r) : $r;
				}
				self::$_mapResultsCache[$cacheKey] = $map;
			} catch (\Exception $e) {
				$errorMessage = "Exception during getting a map. This may be caused by empty filters - you cannot filter on null. ".
					"Your filters were: ".print_r($filters,true).". The error message is ".$e->getMessage();

Are you sure print_r($filters, true) of type string|true can be used in concatenation?

				\Neon::error($errorMessage, 'DDS');
				debug_message($errorMessage);
				return [];
			}
		}
		return self::$_mapResultsCache[$cacheKey];
	}