PolymorphicForeignKey

Complexity

Total Complexity

33

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	clear_classname_spec_cache()	0	3	1
A	scaffoldFormField()	0	6	1
A	requireField()	0	6	3
A	writeToManipulation()	0	11	2
A	addToQuery()	0	11	1
A	getClassValue()	0	3	1
A	setClassValue()	0	4	2
A	getIDValue()	0	3	1
A	setIDValue()	0	4	2
B	setValue()	0	33	9
A	getValue()	0	5	2
A	compositeDatabaseFields()	0	29	4
A	isChanged()	0	3	1
A	exists()	0	3	2
A	scalarValueOnly()	0	4	1

<?php

/**
 * A special ForeignKey class that handles relations with arbitrary class types
 *
 * @package framework
 * @subpackage model
 */
class PolymorphicForeignKey extends ForeignKey implements CompositeDBField {

	/**
	 * @var boolean $isChanged
	 */
	protected $isChanged = false;

	/**
	 * Value of relation class
	 *
	 * @var string
	 */
	protected $classValue = null;

	/**
	 * Field definition cache for compositeDatabaseFields
	 *
	 * @var string
	 */
	protected static $classname_spec_cache = array();

	/**
	 * Clear all cached classname specs. It's necessary to clear all cached subclassed names
	 * for any classes if a new class manifest is generated.
	 */
	public static function clear_classname_spec_cache() {
		self::$classname_spec_cache = array();

It seems like array() of type array is incompatible with the declared type string of property $classname_spec_cache.

	}

	public function scaffoldFormField($title = null, $params = null) {
		// Opt-out of form field generation - Scaffolding should be performed on
		// the has_many end, or set programatically.
		// @todo - Investigate suitable FormField
		return null;
	}

	public function requireField() {
		$fields = $this->compositeDatabaseFields();
		if($fields) foreach($fields as $name => $type){

The expression $fields of type array<string,string> 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.

			DB::requireField($this->tableName, $this->name.$name, $type);

The method DB::requireField() has been deprecated with message: since version 4.0 Use DB::require_field instead

		}
	}

	public function writeToManipulation(&$manipulation) {

		// Write ID, checking that the value is valid
		$manipulation['fields'][$this->name . 'ID'] = $this->exists()
			? $this->prepValueForDB($this->getIDValue())
			: $this->nullValue();

		// Write class
		$classObject = DBField::create_field('Enum', $this->getClassValue(), $this->name . 'Class');
		$classObject->writeToManipulation($manipulation);
	}

	public function addToQuery(&$query) {
		parent::addToQuery($query);
		$query->selectField(
			"\"{$this->tableName}\".\"{$this->name}ID\"",
			"{$this->name}ID"
		);
		$query->selectField(
			"\"{$this->tableName}\".\"{$this->name}Class\"",
			"{$this->name}Class"
		);
	}

	/**
	 * Get the value of the "Class" this key points to
	 *
	 * @return string Name of a subclass of DataObject
	 */
	public function getClassValue() {
		return $this->classValue;
	}

	/**
	 * Set the value of the "Class" this key points to
	 *
	 * @param string $class Name of a subclass of DataObject
	 * @param boolean $markChanged Mark this field as changed?
	 */
	public function setClassValue($class, $markChanged = true) {
		$this->classValue = $class;
		if($markChanged) $this->isChanged = true;
	}

	/**
	 * Gets the value of the "ID" this key points to
	 *
	 * @return integer
	 */
	public function getIDValue() {
		return parent::getValue();

It seems like you call parent on a different method (getValue() instead of getIDValue()). Are you sure this is correct? If so, you might want to change this to $this->getValue().

	}

	/**
	 * Sets the value of the "ID" this key points to
	 *
	 * @param integer $id
	 * @param boolean $markChanged Mark this field as changed?
	 */
	public function setIDValue($id, $markChanged = true) {
		parent::setValue($id);

It seems like you call parent on a different method (setValue() instead of setIDValue()). Are you sure this is correct? If so, you might want to change this to $this->setValue().

		if($markChanged) $this->isChanged = true;
	}

	public function setValue($value, $record = null, $markChanged = true) {
		$idField = "{$this->name}ID";
		$classField = "{$this->name}Class";

		// Check if an object is assigned directly
		if($value instanceof DataObject) {
			$record = array(
				$idField => $value->ID,
				$classField => $value->class
			);
		}

		// Convert an object to an array
		if($record instanceof DataObject) {
			$record = $record->getQueriedDatabaseFields();
		}

		// Use $value array if record is missing
		if(empty($record) && is_array($value)) {
			$record = $value;
		}

		// Inspect presented values
		if(isset($record[$idField]) && isset($record[$classField])) {
			if(empty($record[$idField]) || empty($record[$classField])) {
				$this->setIDValue($this->nullValue(), $markChanged);
				$this->setClassValue('', $markChanged);
			} else {
				$this->setClassValue($record[$classField], $markChanged);
				$this->setIDValue($record[$idField], $markChanged);
			}
		}
	}

	public function getValue() {
		if($this->exists()) {
			return DataObject::get_by_id($this->getClassValue(), $this->getIDValue());
		}
	}

	public function compositeDatabaseFields() {

		// Ensure the table level cache exists
		if(empty(self::$classname_spec_cache[$this->tableName])) {
			self::$classname_spec_cache[$this->tableName] = array();
		}

		// Ensure the field level cache exists
		if(empty(self::$classname_spec_cache[$this->tableName][$this->name])) {

			// Get all class names
			$classNames = ClassInfo::subclassesFor('DataObject');
			unset($classNames['DataObject']);

			$schema = DB::get_schema();
			if($schema->hasField($this->tableName, "{$this->name}Class")) {
				$existing = DB::query("SELECT DISTINCT \"{$this->name}Class\" FROM \"{$this->tableName}\"")->column();
				$classNames = array_unique(array_merge($classNames, $existing));
			}

			self::$classname_spec_cache[$this->tableName][$this->name]
				= "Enum(array('" . implode("', '", array_filter($classNames)) . "'))";
		}

		return array(
			'ID' => 'Int',
			'Class' => self::$classname_spec_cache[$this->tableName][$this->name]
		);
	}

	public function isChanged() {
		return $this->isChanged;
	}

	public function exists() {
		return $this->getClassValue() && $this->getIDValue();
	}

    public function scalarValueOnly()
    {
        return false;
    }
}