SilverStripe\AssetAdmin\Forms\AssetFormFactory

Complexity

Total Complexity

31

Size/Duplication

Total Lines	229
Duplicated Lines	7.86 %

Coupling/Cohesion

Components	1
Dependencies	14

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getFormFieldTabs()	0	6	1
A	getSaveAction()	8	8	4
A	getDeleteAction()	10	10	4
B	getForm()	0	24	4
A	getValidator()	0	5	1
A	getFormType()	0	4	2
B	getFormActions()	0	16	5
B	getFormFields()	0	24	4
A	getPopoverMenu()	0	14	2
A	getPopoverActions()	0	6	1
A	getFormFieldDetailsTab()	0	7	1
A	getRequiredContext()	0	4	1

<?php

namespace SilverStripe\AssetAdmin\Forms;

use InvalidArgumentException;
use SilverStripe\Assets\File;
use SilverStripe\Control\Controller;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Extensible;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\Form;
use SilverStripe\Forms\FormAction;
use SilverStripe\Forms\FormFactory;
use SilverStripe\Forms\HeaderField;
use SilverStripe\Forms\HiddenField;
use SilverStripe\Forms\PopoverField;
use SilverStripe\Forms\RequiredFields;
use SilverStripe\Forms\Tab;
use SilverStripe\Forms\TabSet;
use SilverStripe\Forms\TextField;

abstract class AssetFormFactory implements FormFactory
{
    use Extensible;
    use Injectable;
    use Configurable;

    /**
     * Insert into HTML content area
     */
    const TYPE_INSERT = 'insert';

    /**
     * Select file by ID only
     */
    const TYPE_SELECT = 'select';

    /**
     * Edit form: Default
     */
    const TYPE_ADMIN = 'admin';

    public function __construct()
    {
        $this->constructExtensions();
    }

    public function getForm(Controller $controller, $name = FormFactory::DEFAULT_NAME, $context = [])
    {
        // Validate context
        foreach ($this->getRequiredContext() as $required) {
            if (!isset($context[$required])) {
                throw new InvalidArgumentException("Missing required context $required");
            }
        }

        $fields = $this->getFormFields($controller, $name, $context);
        $actions = $this->getFormActions($controller, $name, $context);
        $validator = $this->getValidator($controller, $name, $context);
        $form = Form::create($controller, $name, $fields, $actions, $validator);

        // Extend form
        $this->invokeWithExtensions('updateForm', $form, $controller, $name, $context);

        // Populate form from record
        if (isset($context['Record'])) {
            $form->loadDataFrom($context['Record']);
        }

        return $form;
    }
    
    /**
     * Get the validator for the form to be built
     *
     * @param $controller
     * @param $formName
     * @param $context
     * @return RequiredFields
     */
    protected function getValidator(Controller $controller, $formName, $context = []) {

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

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

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

        $validator = new RequiredFields('Name');
        
        return $validator;
    }

    /**
     * Get form type from 'type' context
     *
     * @param array $context
     * @return string
     */
    protected function getFormType($context)
    {
        return empty($context['Type']) ? static::TYPE_ADMIN : $context['Type'];
    }

    /**
     * Gets the main tabs for the file edit form
     *
     * @param File $record
     * @return TabSet
     */
    protected function getFormFieldTabs($record, $context = [])
    {
        $tabs = TabSet::create('Editor', $this->getFormFieldDetailsTab($record));

        return $tabs;
    }

    /**
     * @param File $record
     * @return FormAction
     */
    protected function getSaveAction($record)

This method seems to be duplicated in your project.

    {
        if ($record && $record->isInDB() && $record->canEdit()) {
            return FormAction::create('save', _t('CMSMain.SAVE', 'Save'))
                ->setIcon('save');
        }
        return null;
    }

    /**
     * Get delete action, if this record is deletable
     *
     * @param File $record
     * @return FormAction
     */
    protected function getDeleteAction($record)

This method seems to be duplicated in your project.

    {
        // Delete action
        if ($record && $record->isInDB() && $record->canDelete()) {
            $deleteText = _t('SilverStripe\\AssetAdmin\\Controller\\AssetAdmin.DELETE_BUTTON', 'Delete');
            return FormAction::create('delete', $deleteText)
                ->setIcon('trash-bin');
        }
        return null;
    }
    
    /**
     * @param Controller $controller
     * @param $formName
     * @param array $context
     * @return FieldList
     */
    protected function getFormActions(Controller $controller, $formName, $context = [])
    {
        $record = isset($context['Record']) ? $context['Record'] : null;

        $actions = new FieldList();
        if ($saveAction = $this->getSaveAction($record)) {
            $actions->push($saveAction);
        }
        $menu = $this->getPopoverMenu($record);
        if ($menu && $menu->FieldList()->count()) {
            $actions->push($menu);
        }

        $this->invokeWithExtensions('updateFormActions', $actions, $controller, $formName, $context);
        return $actions;
    }

    /**
     * Get fields for this form
     *
     * @param Controller $controller
     * @param string $formName
     * @param array $context
     * @return FieldList
     */
    protected function getFormFields(Controller $controller, $formName, $context = [])
    {
        $record = isset($context['Record']) ? $context['Record'] : null;

        // Build standard fields for all folders / files
        /** @var File $record */
        $fields = new FieldList(
            HeaderField::create('TitleHeader', $record ? $record->Title : null, 1)
                ->addExtraClass('editor__heading'),
            $this->getFormFieldTabs($record, $context)
        );
        if ($record) {
            $fields->push(HiddenField::create('ID', $record->ID));
            $fields->insertAfter(
                'TitleHeader',
                PreviewImageField::create('PreviewImage')
                    ->setRecordID($record->ID)
                    ->addExtraClass('editor__file-preview')
            );
        }

        $this->invokeWithExtensions('updateFormFields', $fields, $controller, $formName, $context);
        return $fields;
    }
    
    /**
     * Build popup menu
     *
     * @param File $record
     * @return PopoverField
     */
    protected function getPopoverMenu($record)
    {
        // Build popover actions
        $popoverActions = $this->getPopoverActions($record);
        if ($popoverActions) {

The expression $popoverActions of type array 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.

            return PopoverField::create($popoverActions)
                ->setPlacement('top')
                ->setButtonTooltip(_t(
                    'SilverStripe\\AssetAdmin\\Forms\\FileFormFactory.OTHER_ACTIONS',
                    'Other actions'
                ));
        }
        return null;
    }
    
    /**
     * Get actions that go into the Popover menu
     *
     * @param $record
     * @return array
     */
    protected function getPopoverActions($record)
    {
        return array_filter([
            $this->getDeleteAction($record)
        ]);
    }
    
    /**
     * Build "details" formfield tab
     *
     * @param File $record
     * @param array $context
     * @return Tab
     */
    protected function getFormFieldDetailsTab($record, $context = [])
    {
        return Tab::create(
            'Details',
            TextField::create('Name', File::singleton()->fieldLabel('Filename'))
        );
    }

    public function getRequiredContext()
    {
        return ['Record'];
    }
}