EditableMultipleOptionField

Complexity

Total Complexity

17

Size/Duplication

Total Lines	211
Duplicated Lines	13.27 %

Coupling/Cohesion

Components	1
Dependencies	17

Test Coverage

Coverage

39.13%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getCMSFields()	0	51	1
A	doPublish()	0	5	1
A	doDeleteFromStage()	0	11	2
B	publishOptions()	22	22	4
A	delete()	0	12	3
A	duplicate()	6	13	2
A	getHasAddableOptions()	0	4	1
A	getOptionsMap()	0	9	2
A	getDefaultOptions()	0	4	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()
    {
        $this->beforeUpdateCMSFields(function($fields) {
            $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 publishOptions()?

                $optionsConfig
            );

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

        $fields = parent::getCMSFields();

        return $fields;
    }

    /**
     * Publishing Versioning support.
     *
     * When publishing it needs to handle copying across / publishing
     * each of the individual field options
     *
     * @param string $fromStage
     * @param string $toStage
     * @param bool $createNewVersion
     */
    public function doPublish($fromStage, $toStage, $createNewVersion = false)
    {
        parent::doPublish($fromStage, $toStage, $createNewVersion);
        $this->publishOptions($fromStage, $toStage, $createNewVersion);
    }


    /**
     * Publish list options
     *
     * @param string $fromStage
     * @param string $toStage
     * @param bool $createNewVersion
     */
    protected function publishOptions($fromStage, $toStage, $createNewVersion)

This method seems to be duplicated in your project.

    {
        $seenIDs = array();

        // Publish all options
        foreach ($this->Options() as $option) {

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

            $seenIDs[] = $option->ID;
            $option->publish($fromStage, $toStage, $createNewVersion);
        }

        // remove any orphans from the "fromStage"
        $options = Versioned::get_by_stage('EditableOption', $toStage)
            ->filter('ParentID', $this->ID);

        if (!empty($seenIDs)) {
            $options = $options->exclude('ID', $seenIDs);
        }

        foreach ($options as $rule) {
            $rule->deleteFromStage($toStage);
        }
    }

    /**
     * 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 publishOptions()?

        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 publishOptions()?

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 publishOptions()?

        $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 publishOptions()?

    }
}