EditableFileField

Complexity

Total Complexity

13

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

64.71%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
B	getCMSFields()	0	27	1
A	validate()	0	11	2
A	getValueFromData()	0	4	1
A	getSubmittedFormField()	0	4	1
A	migrateSettings()	0	10	2
A	get_php_max_file_size()	0	6	1
A	getPHPMaxFileSizeMB()	0	4	1
B	getFormField()	0	34	4

<?php

/**
 * Allows a user to add a field that can be used to upload a file.
 *
 * @package userforms
 */
class EditableFileField extends EditableFormField

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

{

    private static $singular_name = 'File Upload Field';

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

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

    private static $plural_names = 'File Fields';

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

    private static $db = array(

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

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

        'MaxFileSizeMB' => 'Float',
    );

    private static $has_one = array(

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

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

        'Folder' => 'Folder' // From CustomFields
    );

    /**
     * Further limit uploadable file extensions in addition to the restrictions
     * imposed by the File.allowed_extensions global configuration.
     * @config
     */
    private static $allowed_extensions_blacklist = array(

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

        'htm', 'html', 'xhtml', 'swf', 'xml'
    );

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

        $fields->addFieldToTab(
            'Root.Main',
            TreeDropdownField::create(
                'FolderID',
                _t('EditableUploadField.SELECTUPLOADFOLDER', 'Select upload folder'),
                'Folder'
            )
        );

        $fields->addFieldToTab("Root.Main", new LiteralField("FileUploadWarning",
            "<p class=\"message notice\">" . _t("UserDefinedForm.FileUploadWarning",
                "Files uploaded through this field could be publicly accessible if the exact URL is known")
            . "</p>"), "Type");

        $fields->addFieldToTab(
            'Root.Main',
            NumericField::create('MaxFileSizeMB')
                ->setTitle('Max File Size MB')
                ->setDescription("Note: Maximum php allowed size is {$this->getPHPMaxFileSizeMB()} MB")
        );

        return $fields;
    }

    /**
     * @return ValidationResult
     */
    public function validate()
    {
        $result = parent::validate();

        $max = static::get_php_max_file_size();
        if ($this->MaxFileSizeMB * 1024 > $max) {

The property MaxFileSizeMB does not exist on object<EditableFileField>. Since you implemented __get, maybe consider adding a @property annotation.

            $result->error("Your max file size limit can't be larger than the server's limit of {$this->getPHPMaxFileSizeMB()}.");
        }

        return $result;
    }

    public function getFormField()
    {
        $field = FileField::create($this->Name, $this->EscapedTitle)

The property EscapedTitle does not exist on object<EditableFileField>. Since you implemented __get, maybe consider adding a @property annotation.

            ->setFieldHolderTemplate('UserFormsField_holder')
            ->setTemplate('UserFormsFileField');

        $field->setFieldHolderTemplate('UserFormsField_holder')
            ->setTemplate('UserFormsFileField');

        $field->getValidator()->setAllowedExtensions(
            array_diff(
            // filter out '' since this would be a regex problem on JS end
                array_filter(Config::inst()->get('File', 'allowed_extensions')),
                $this->config()->allowed_extensions_blacklist
            )
        );

        if ($this->MaxFileSizeMB > 0) {

The property MaxFileSizeMB does not exist on object<EditableFileField>. Since you implemented __get, maybe consider adding a @property annotation.

            $field->getValidator()->setAllowedMaxFileSize($this->MaxFileSizeMB * 1024);

The property MaxFileSizeMB does not exist on object<EditableFileField>. Since you implemented __get, maybe consider adding a @property annotation.

        } else {
            $field->getValidator()->setAllowedMaxFileSize(static::get_php_max_file_size());
        }

        $folder = $this->Folder();

The method Folder does not exist on object<EditableFileField>? Since you implemented __call, maybe consider adding a @method annotation.

        if ($folder && $folder->exists()) {
            $field->setFolderName(
                preg_replace("/^assets\//", "", $folder->Filename)
            );
        }

        $this->doUpdateFormField($field);

        return $field;
    }


    /**
     * Return the value for the database, link to the file is stored as a
     * relation so value for the field can be null.
     *
     * @return string
     */
    public function getValueFromData()
    {
        return null;
    }

    public function getSubmittedFormField()
    {
        return new SubmittedFileField();
    }


    public function migrateSettings($data)
    {
        // Migrate 'Folder' setting to 'FolderID'
        if (isset($data['Folder'])) {
            $this->FolderID = $data['Folder'];

The property FolderID does not exist on object<EditableFileField>. Since you implemented __set, maybe consider adding a @property annotation.

            unset($data['Folder']);
        }

        parent::migrateSettings($data);
    }

    /**
     * @return float
     */
    public static function get_php_max_file_size()
    {
        $maxUpload = File::ini2bytes(ini_get('upload_max_filesize'));
        $maxPost = File::ini2bytes(ini_get('post_max_size'));
        return min($maxUpload, $maxPost);
    }

    public function getPHPMaxFileSizeMB()
    {
        return round(static::get_php_max_file_size() / 1024.0, 1);
    }

}