SilverStripe\UserForms\Extension\UserFormFieldEditorExtension

Complexity

Total Complexity

28

Size/Duplication

Total Lines	251
Duplicated Lines	2.39 %

Coupling/Cohesion

Components	1
Dependencies	21

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	updateCMSFields()	0	9	1
A	getFieldEditorGrid()	0	51	3
B	createInitialFormStep()	0	34	6
A	onAfterWrite()	0	4	1
B	onAfterPublish()	0	29	4
A	onAfterUnpublish()	0	6	2
B	onAfterDuplicate()	6	31	6
A	isModifiedOnDraft()	0	8	3
A	onAfterRevertToLive()	0	7	2

<?php

namespace SilverStripe\UserForms\Extension;

use SilverStripe\Core\Manifest\ModuleLoader;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\Tab;
use SilverStripe\Forms\GridField\GridField;
use SilverStripe\Forms\GridField\GridFieldButtonRow;
use SilverStripe\Forms\GridField\GridFieldConfig;
use SilverStripe\Forms\GridField\GridFieldEditButton;
use SilverStripe\Forms\GridField\GridFieldDeleteAction;
use SilverStripe\Forms\GridField\GridFieldDetailForm;
use SilverStripe\Forms\GridField\GridFieldToolbarHeader;
use SilverStripe\ORM\DataExtension;
use SilverStripe\UserForms\Form\GridFieldAddClassesButton;
use SilverStripe\UserForms\Model\EditableFormField;
use SilverStripe\UserForms\Model\EditableFormField\EditableFieldGroup;
use SilverStripe\UserForms\Model\EditableFormField\EditableFieldGroupEnd;
use SilverStripe\UserForms\Model\EditableFormField\EditableFormStep;
use SilverStripe\UserForms\Model\EditableFormField\EditableTextField;
use SilverStripe\Versioned\Versioned;
use SilverStripe\View\Requirements;
use Symbiote\GridFieldExtensions\GridFieldEditableColumns;
use Symbiote\GridFieldExtensions\GridFieldOrderableRows;

/**
 * @package userforms
 */
class UserFormFieldEditorExtension extends DataExtension
{
    /**
     * @var array
     */
    private static $has_many = array(

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

        'Fields' => EditableFormField::class
    );

    private static $owns = [

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

        'Fields'
    ];

    private static $cascade_deletes = [

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

        'Fields'
    ];

    /**
     * Adds the field editor to the page.
     *
     * @return FieldList
     */
    public function updateCMSFields(FieldList $fields)
    {
        $fieldEditor = $this->getFieldEditorGrid();

        $fields->insertAfter(new Tab('FormFields', _t(__CLASS__.'.FORMFIELDS', 'Form Fields')), 'Main');

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

        $fields->addFieldToTab('Root.FormFields', $fieldEditor);

        return $fields;
    }

    /**
     * Gets the field editor, for adding and removing EditableFormFields.
     *
     * @return GridField
     */
    public function getFieldEditorGrid()
    {
        $module = ModuleLoader::getModule('silverstripe/userforms');
        Requirements::javascript($module->getRelativeResourcePath('javascript/FieldEditor.js'));

        $fields = $this->owner->Fields();

The method Fields() does not exist on SilverStripe\ORM\DataObject. Did you maybe mean beforeUpdateCMSFields()?

        $this->createInitialFormStep(true);

        $editableColumns = new GridFieldEditableColumns();
        $fieldClasses = singleton(EditableFormField::class)->getEditableFieldClasses();
        $editableColumns->setDisplayFields([
            'ClassName' => function ($record, $column, $grid) use ($fieldClasses) {

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

                if ($record instanceof EditableFormField) {
                    return $record->getInlineClassnameField($column, $fieldClasses);
                }
            },
            'Title' => function ($record, $column, $grid) {

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

                if ($record instanceof EditableFormField) {
                    return $record->getInlineTitleField($column);
                }
            }
        ]);

        $config = GridFieldConfig::create()
            ->addComponents(
                $editableColumns,
                new GridFieldButtonRow(),
                (new GridFieldAddClassesButton(EditableTextField::class))
                    ->setButtonName(_t(__CLASS__.'.ADD_FIELD', 'Add Field'))
                    ->setButtonClass('ss-ui-action-constructive'),
                (new GridFieldAddClassesButton(EditableFormStep::class))
                    ->setButtonName(_t(__CLASS__.'.ADD_PAGE_BREAK', 'Add Page Break')),
                (new GridFieldAddClassesButton([EditableFieldGroup::class, EditableFieldGroupEnd::class]))
                    ->setButtonName(_t(__CLASS__.'.ADD_FIELD_GROUP', 'Add Field Group')),
                new GridFieldEditButton(),
                new GridFieldDeleteAction(),
                new GridFieldToolbarHeader(),
                new GridFieldOrderableRows('Sort'),
                new GridFieldDetailForm()
            );

        $fieldEditor = GridField::create(
            'Fields',
            _t('SilverStripe\\UserForms\\Model\\UserDefinedForm.FIELDS', 'Fields'),
            $fields,
            $config
        )->addExtraClass('uf-field-editor');

        return $fieldEditor;
    }

    /**
     * A UserForm must have at least one step.
     * If no steps exist, create an initial step, and put all fields inside it.
     *
     * @param bool $force
     * @return void
     */
    public function createInitialFormStep($force = false)
    {
        // Only invoke once saved
        if (!$this->owner->exists()) {
            return;
        }

        // Check if first field is a step
        $fields = $this->owner->Fields();

The method Fields() does not exist on SilverStripe\ORM\DataObject. Did you maybe mean beforeUpdateCMSFields()?

        $firstField = $fields->first();
        if ($firstField instanceof EditableFormStep) {
            return;
        }

        // Don't create steps on write if there are no formfields, as this
        // can create duplicate first steps during publish of new records
        if (!$force && !$firstField) {
            return;
        }

        // Re-apply sort to each field starting at 2
        $next = 2;
        foreach ($fields as $field) {
            $field->Sort = $next++;
            $field->write();
        }

        // Add step
        $step = EditableFormStep::create();
        $step->Title = _t('SilverStripe\\UserForms\\Model\\EditableFormField\\EditableFormStep.TITLE_FIRST', 'First Page');
        $step->Sort = 1;
        $step->write();
        $fields->add($step);
    }

    /**
     * Ensure that at least one page exists at the start
     */
    public function onAfterWrite()
    {
        $this->createInitialFormStep();
    }

    /**
     * Remove any orphaned child records on publish
     */
    public function onAfterPublish()
    {
        // store IDs of fields we've published
        $seenIDs = [];
        foreach ($this->owner->Fields() as $field) {

The method Fields() does not exist on SilverStripe\ORM\DataObject. Did you maybe mean beforeUpdateCMSFields()?

            // store any IDs of fields we publish so we don't unpublish them
            $seenIDs[] = $field->ID;
            $field->doPublish(Versioned::DRAFT, Versioned::LIVE);
            $field->destroy();
        }

        // fetch any orphaned live records
        $live = Versioned::get_by_stage(EditableFormField::class, Versioned::LIVE)
            ->filter([
                'ParentID' => $this->owner->ID,
            ]);

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

        // delete orphaned records
        foreach ($live as $field) {
            $field->deleteFromStage(Versioned::LIVE);
            $field->destroy();
        }
    }

    /**
     * Remove all fields from the live stage when unpublishing the page
     */
    public function onAfterUnpublish()
    {
        foreach ($this->owner->Fields() as $field) {

The method Fields() does not exist on SilverStripe\ORM\DataObject. Did you maybe mean beforeUpdateCMSFields()?

            $field->deleteFromStage(Versioned::LIVE);
        }
    }

    /**
     * When duplicating a UserDefinedForm, duplicate all of its fields and display rules
     *
     * @see DataObject::duplicate
     * @param DataObject $oldPage
     * @param bool $doWrite
     * @param string $manyMany
     * @return DataObject
     */
    public function onAfterDuplicate($oldPage, $doWrite, $manyMany)

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

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

    {
        // List of EditableFieldGroups, where the key of the array is the ID of the old end group
        $fieldGroups = [];
        foreach ($oldPage->Fields() as $field) {
            $newField = $field->duplicate(false);
            $newField->ParentID = $this->owner->ID;
            $newField->ParentClass = $this->owner->ClassName;
            $newField->Version = 0;
            $newField->write();

            // If we encounter a group start, record it for later use
            if ($field instanceof EditableFieldGroup) {
                $fieldGroups[$field->EndID] = $newField;

The property EndID does not exist on object<SilverStripe\UserForms\Model\EditableFormField\EditableFieldGroup>. Since you implemented __get, maybe consider adding a @property annotation.

            }

            // If we encounter an end group, link it back to the group start
            if ($field instanceof EditableFieldGroupEnd && isset($fieldGroups[$field->ID])) {
                $groupStart = $fieldGroups[$field->ID];
                $groupStart->EndID = $newField->ID;
                $groupStart->write();
            }

            foreach ($field->DisplayRules() as $customRule) {

This code seems to be duplicated across your project.

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

    /**
     * Checks child fields to see if any are modified in draft as well. The owner of this extension will still
     * use the Versioned method to determine its own status.
     *
     * @see Versioned::isModifiedOnDraft
     *
     * @return boolean|null
     */
    public function isModifiedOnDraft()
    {
        foreach ($this->owner->Fields() as $field) {

The method Fields() does not exist on SilverStripe\ORM\DataObject. Did you maybe mean beforeUpdateCMSFields()?

            if ($field->isModifiedOnDraft()) {
                return true;
            }
        }
    }

    /**
     * @see Versioned::doRevertToLive
     */
    public function onAfterRevertToLive()
    {
        foreach ($this->owner->Fields() as $field) {

The method Fields() does not exist on SilverStripe\ORM\DataObject. Did you maybe mean beforeUpdateCMSFields()?

            $field->copyVersionToStage(Versioned::LIVE, Versioned::DRAFT, false);
            $field->writeWithoutVersion();
        }
    }
}