EditableMultipleOptionField

Complexity

Total Complexity

17

Size/Duplication

Total Lines	180
Duplicated Lines	3.33 %

Coupling/Cohesion

Components	1
Dependencies	18

Importance

Changes	5
Bugs	2	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getCMSFields()	0	48	1
A	getOptionsMap()	0	8	2
B	doPublish()	0	17	5
A	doDeleteFromStage()	0	10	2
A	delete()	0	11	3
A	duplicate()	6	12	2
A	getHasAddableOptions()	0	3	1
A	getDefaultOptions()	0	3	1

<?php

/**
 * Base class for multiple option fields such as {@link EditableDropdownField}
 * and radio sets.
 *
 * Implemented as a class but should be viewed as abstract, you should
 * instantiate a subclass such as {@link EditableDropdownField}
 *
 * @see EditableCheckboxGroupField
 * @see EditableDropdownField
 *
 * @package userforms
 */

class EditableMultipleOptionField extends EditableFormField {

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

	/**
	 * Define this field as abstract (not inherited)
	 *
	 * @config
	 * @var bool
	 */
	private static $abstract = true;

Consider using a different property name as you override a private property of the parent class.

The property $abstract is not used and could be removed.

	private static $has_many = array(

Consider using a different property name as you override a private property of the parent class.

The property $has_many is not used and could be removed.

		"Options" => "EditableOption"
	);

	/**
	 * @return FieldList
	 */
	public function getCMSFields() {
		$fields = parent::getCMSFields();

		$editableColumns = new GridFieldEditableColumns();
		$editableColumns->setDisplayFields(array(
			'Title' => array(
				'title' => _t('EditableMultipleOptionField.TITLE', 'Title'),
				'callback' => function($record, $column, $grid) {

The parameter $grid is not used and could be removed.

					return TextField::create($column);
				}
            ),
            'Value' => array(
                'title' => _t('EditableMultipleOptionField.VALUE', 'Value'),
                'callback' => function($record, $column, $grid) {

The parameter $grid is not used and could be removed.

                    return TextField::create($column);
                }
            ),
			'Default' => array(
				'title' => _t('EditableMultipleOptionField.DEFAULT', 'Selected by default?'),
				'callback' => function($record, $column, $grid) {

The parameter $grid is not used and could be removed.

					return CheckboxField::create($column);
				}
			)
		));

		$optionsConfig = GridFieldConfig::create()
			->addComponents(
				new GridFieldToolbarHeader(),
				new GridFieldTitleHeader(),
				new GridFieldOrderableRows('Sort'),
				$editableColumns,
				new GridFieldButtonRow(),
				new GridFieldAddNewInlineButton(),
				new GridFieldDeleteAction()
			);

		$optionsGrid = GridField::create(
			'Options',
			_t('EditableFormField.CUSTOMOPTIONS', 'Options'),
			$this->Options(),

The method Options() does not exist on EditableMultipleOptionField. Did you maybe mean getHasAddableOptions()?

			$optionsConfig
		);

		$fields->insertAfter(new Tab('Options', _t('EditableMultipleOptionField.OPTIONSTAB','Options')), 'Main');

'Main' is of type string, but the function expects a object<FormField>.

		$fields->addFieldToTab('Root.Options', $optionsGrid);

		return $fields;
	}

	/**
	 * Publishing Versioning support.
	 *
	 * When publishing it needs to handle copying across / publishing
	 * each of the individual field options
	 *
	 * @return void
	 */
	public function doPublish($fromStage, $toStage, $createNewVersion = false) {
		$live = Versioned::get_by_stage("EditableOption", "Live", "\"EditableOption\".\"ParentID\" = $this->ID");

		if($live) {
			foreach($live as $option) {
				$option->delete();
			}
		}

		if($this->Options()) {

The method Options() does not exist on EditableMultipleOptionField. Did you maybe mean getHasAddableOptions()?

			foreach($this->Options() as $option) {

The method Options() does not exist on EditableMultipleOptionField. Did you maybe mean getHasAddableOptions()?

				$option->publish($fromStage, $toStage, $createNewVersion);
			}
		}

		parent::doPublish($fromStage, $toStage, $createNewVersion);
	}

	/**
	 * Unpublishing Versioning support
	 *
	 * When unpublishing the field it has to remove all options attached
	 *
	 * @return void
	 */
	public function doDeleteFromStage($stage) {
		// Remove options
		$options = Versioned::get_by_stage('EditableOption', $stage)
			->filter('ParentID', $this->ID);
		foreach($options as $option) {
			$option->deleteFromStage($stage);
		}

		parent::doDeleteFromStage($stage);
	}

	/**
	 * Deletes all the options attached to this field before deleting the
	 * field. Keeps stray options from floating around
	 *
	 * @return void
	 */
	public function delete() {
		$options = $this->Options();

The method Options() does not exist on EditableMultipleOptionField. Did you maybe mean getHasAddableOptions()?

		if($options) {
			foreach($options as $option) {
				$option->delete();
			}
		}

		parent::delete();
	}

	/**
	 * Duplicate a pages content. We need to make sure all the fields attached
	 * to that page go with it
	 *
	 * @return DataObject
	 */
	public function duplicate($doWrite = true) {
		$clonedNode = parent::duplicate();

		foreach($this->Options() as $field) {

The method Options() does not exist on EditableMultipleOptionField. Did you maybe mean getHasAddableOptions()?

This code seems to be duplicated across your project.

			$newField = $field->duplicate(false);
			$newField->ParentID = $clonedNode->ID;
			$newField->Version = 0;
			$newField->write();
		}

		return $clonedNode;
	}

	/**
	 * Return whether or not this field has addable options such as a
	 * {@link EditableDropdownField} or {@link EditableRadioField}
	 *
	 * @return bool
	 */
	public function getHasAddableOptions() {
		return true;
	}

	/**
	 * Gets map of field options suitable for use in a form
	 *
	 * @return array
	 */
	protected function getOptionsMap() {
		$optionSet = $this->Options();

The method Options() does not exist on EditableMultipleOptionField. Did you maybe mean getHasAddableOptions()?

		$optionMap = $optionSet->map('Value', 'Title');
		if($optionMap instanceof SS_Map) {
			return $optionMap->toArray();
		}
		return $optionMap;
	}

	/**
	 * Returns all default options
	 *
	 * @return SS_List
	 */
	protected function getDefaultOptions() {
		return $this->Options()->filter('Default', 1);

The method Options() does not exist on EditableMultipleOptionField. Did you maybe mean getHasAddableOptions()?

	}
}