+global\Model::saveAssociated()

Complexity

Conditions	48
Paths	17158

Size

Total Lines	157
Code Lines	102

Duplication

Lines	26
Ratio	16.56 %

Importance

Changes

0

<?php
	public function saveAssociated($data = null, $options = array()) {
		if (empty($data)) {
			$data = $this->data;
		}

		$options = array_merge(array('validate' => 'first', 'atomic' => true, 'deep' => false), $options);
		$this->validationErrors = $validationErrors = array();

		if (empty($data) && $options['validate'] !== false) {
			$result = $this->save($data, $options);
			if (!$options['atomic']) {
				return array(!empty($result));
			}

			return !empty($result);
		}

		if ($options['validate'] === 'first') {
			$validates = $this->validateAssociated($data, $options);
			if ((!$validates && $options['atomic']) || (!$options['atomic'] && in_array(false, Hash::flatten($validates), true))) {

It seems like $validates defined by $this->validateAssociated($data, $options) on line 2342 can also be of type boolean; however, Hash::flatten() does only seem to accept array, maybe add an additional type check?

				return $validates;
			}

			$options['validate'] = false;
		}

		if ($options['atomic']) {
			$db = $this->getDataSource();
			$transactionBegun = $db->begin();
		}

		$associations = $this->getAssociated();
		$return = array();
		$validates = true;
		foreach ($data as $association => $values) {
			$isEmpty = empty($values) || (isset($values[$association]) && empty($values[$association]));
			if ($isEmpty || !isset($associations[$association]) || $associations[$association] !== 'belongsTo') {
				continue;
			}

			$Model = $this->{$association};

			$validates = $Model->create(null) !== null;
			$saved = false;
			if ($validates) {
				if ($options['deep']) {
					$saved = $Model->saveAssociated($values, array_merge($options, array('atomic' => false)));
				} else {
					$saved = $Model->save($values, array_merge($options, array('atomic' => false)));
				}
				$validates = ($saved === true || (is_array($saved) && !in_array(false, $saved, true)));
			}

			if ($validates) {
				$key = $this->belongsTo[$association]['foreignKey'];
				if (isset($data[$this->alias])) {
					$data[$this->alias][$key] = $Model->id;
				} else {
					$data = array_merge(array($key => $Model->id), $data, array($key => $Model->id));
				}
				$options = $this->_addToWhiteList($key, $options);
			} else {
				$validationErrors[$association] = $Model->validationErrors;
			}

			$return[$association] = $validates;
		}

		if ($validates && !($this->create(null) !== null && $this->save($data, $options))) {
			$validationErrors[$this->alias] = $this->validationErrors;
			$validates = false;
		}
		$return[$this->alias] = $validates;

		foreach ($data as $association => $values) {
			if (!$validates) {
				break;
			}

			$isEmpty = empty($values) || (isset($values[$association]) && empty($values[$association]));
			if ($isEmpty || !isset($associations[$association])) {
				continue;
			}

			$Model = $this->{$association};

			$type = $associations[$association];
			$key = $this->{$type}[$association]['foreignKey'];
			switch ($type) {
				case 'hasOne':
					if (isset($values[$association])) {
						$values[$association][$key] = $this->id;
					} else {
						$values = array_merge(array($key => $this->id), $values, array($key => $this->id));
					}

					$validates = $Model->create(null) !== null;
					$saved = false;

					if ($validates) {
						$options = $Model->_addToWhiteList($key, $options);
						if ($options['deep']) {
							$saved = $Model->saveAssociated($values, array_merge($options, array('atomic' => false)));
						} else {
							$saved = $Model->save($values, $options);
						}
					}

					$validates = ($validates && ($saved === true || (is_array($saved) && !in_array(false, $saved, true))));
					if (!$validates) {
						$validationErrors[$association] = $Model->validationErrors;
					}

					$return[$association] = $validates;
					break;
				case 'hasMany':
					foreach ($values as $i => $value) {
						if (isset($values[$i][$association])) {
							$values[$i][$association][$key] = $this->id;
						} else {
							$values[$i] = array_merge(array($key => $this->id), $value, array($key => $this->id));
						}
					}

					$options = $Model->_addToWhiteList($key, $options);
					$_return = $Model->saveMany($values, array_merge($options, array('atomic' => false)));
					if (in_array(false, $_return, true)) {
						$validationErrors[$association] = $Model->validationErrors;
						$validates = false;
					}

					$return[$association] = $_return;
					break;
			}
		}
		$this->validationErrors = $validationErrors;

		if (isset($validationErrors[$this->alias])) {
			$this->validationErrors = $validationErrors[$this->alias];
			unset($validationErrors[$this->alias]);
			$this->validationErrors = array_merge($this->validationErrors, $validationErrors);
		}

		if (!$options['atomic']) {
			return $return;
		}
		if ($validates) {
			if ($transactionBegun) {

The variable $transactionBegun does not seem to be defined for all execution paths leading up to this point.

				return $db->commit() !== false;

The variable $db does not seem to be defined for all execution paths leading up to this point.

			}

			return true;
		}

		$db->rollback();
		return false;
	}