LeKoala\FilePond\AbstractUploadField

Complexity

Total Complexity

41

Size/Duplication

Total Lines	358
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	Type()	0	3	1
A	validate()	0	18	3
A	getFolderName()	0	5	2
A	performReadonlyTransformation()	0	5	1
A	setUploadEnabled()	0	4	1
A	getFolderID()	0	8	3
A	setAllowedMaxFileNumber()	0	5	1
A	getSchemaStateDefaults()	0	6	2
A	getIsMultiUpload()	0	14	4
A	Link()	0	11	2
A	setAttachEnabled()	0	4	1
A	getSchemaDataDefaults()	0	22	2
A	setIsMultiUpload()	0	4	1
A	Field()	0	21	6
A	performDisabledTransformation()	0	5	1
A	getUploadEnabled()	0	3	1
A	getAllowedMaxFileSize()	0	3	1
A	getAttributes()	0	16	1
A	getAttachEnabled()	0	3	1
A	isDefaultMaxFileSize()	0	5	2
A	getAllowedMaxFileNumber()	0	3	1
A	__construct()	0	18	3

<?php

namespace LeKoala\FilePond;

use LogicException;
use SilverStripe\ORM\SS_List;
use SilverStripe\Assets\Image;
use SilverStripe\Core\Convert;
use SilverStripe\Assets\Folder;
use SilverStripe\ORM\DataObject;
use SilverStripe\Forms\FormField;
use SilverStripe\Control\Controller;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Forms\FileHandleField;
use SilverStripe\Control\NullHTTPRequest;
use SilverStripe\Forms\FileUploadReceiver;

/**
 * An abstract class that serve as a base to implement dedicated uploaders
 *
 * This follows roughly the same pattern as the UploadField class
 * but does not depends on asset admin
 *
 * Copy pasted functions that were adapted are using NEW: comments on top of
 * the lines that are changed/added
 */
abstract class AbstractUploadField extends FormField implements FileHandleField
{
    use FileUploadReceiver;

The trait SilverStripe\Forms\FileUploadReceiver requires some properties which are not provided by LeKoala\FilePond\AbstractUploadField: $ID, $allowed_extensions, $uploads_folder

    use ImprovedUploader;

The trait LeKoala\FilePond\ImprovedUploader requires some properties which are not provided by LeKoala\FilePond\AbstractUploadField: $uploads_folder, $image_sizes

    // Schema needs to be something else than custom otherwise it fails on ajax load because
    // we don't have a proper react component
    protected $schemaDataType = FormField::SCHEMA_DATA_TYPE_HIDDEN;
    protected $schemaComponent = null;

    /**
     * Set if uploading new files is enabled.
     * If false, only existing files can be selected
     *
     * @var bool
     */
    protected $uploadEnabled = true;

    /**
     * Set if selecting existing files is enabled.
     * If false, only new files can be selected.
     *
     * @var bool
     */
    protected $attachEnabled = true;

    /**
     * The number of files allowed for this field
     *
     * @var null|int
     */
    protected $allowedMaxFileNumber = null;

    /**
     * @var string
     */
    protected $inputType = 'file';

    /**
     * @var bool|null
     */
    protected $multiUpload = null;

    /**
     * Create a new file field.
     *
     * @param string $name The internal field name, passed to forms.
     * @param string $title The field label.
     * @param SS_List $items Items assigned to this field
     */
    public function __construct($name, $title = null, SS_List $items = null)
    {
        $this->constructFileUploadReceiver();

        // NEW : Reset default size to allow our default config to work properly
        $this->getUpload()->getValidator()->allowedMaxFileSize = [];

        // When creating new files, rename on conflict
        $this->getUpload()->setReplaceFile(false);

        parent::__construct($name, $title);
        if ($items) {
            $this->setItems($items);
        }

        // NEW : Fix null request
        if ($this->request instanceof NullHTTPRequest) {
            $this->request = Controller::curr()->getRequest();
        }
    }

    public function getSchemaDataDefaults()
    {
        $defaults = parent::getSchemaDataDefaults();

        // NEW : wrap conditionnaly to avoid errors if not linked to a form
        if ($this->form) {
            $uploadLink = $this->Link('upload');
            $defaults['data']['createFileEndpoint'] = [
                'url' => $uploadLink,
                'method' => 'post',
                'payloadFormat' => 'urlencoded',
            ];
        }

        $defaults['data']['maxFilesize'] = $this->getAllowedMaxFileSize() / 1024 / 1024;
        $defaults['data']['maxFiles'] = $this->getAllowedMaxFileNumber();
        $defaults['data']['multi'] = $this->getIsMultiUpload();
        $defaults['data']['parentid'] = $this->getFolderID();
        $defaults['data']['canUpload'] = $this->getUploadEnabled();
        $defaults['data']['canAttach'] = $this->getAttachEnabled();

        return $defaults;
    }


    /**
     * Handles file uploading
     *
     * @param HTTPRequest $request
     * @return HTTPResponse

The type LeKoala\FilePond\HTTPResponse was not found. Did you mean HTTPResponse? If so, make sure to prefix the type with \.

     */
    abstract public function upload(HTTPRequest $request);

    /**
     * Get ID of target parent folder
     *
     * @return int
     */
    protected function getFolderID()
    {
        $folderName = $this->getFolderName();
        if (!$folderName) {
            return 0;
        }
        $folder = Folder::find_or_make($folderName);
        return $folder ? $folder->ID : 0;

$folder is of type SilverStripe\Assets\Folder, thus it always evaluated to true.

    }

    public function getSchemaStateDefaults()
    {
        $state = parent::getSchemaStateDefaults();
        $state['data']['files'] = $this->getItemIDs();
        $state['value'] = $this->Value() ?: ['Files' => []];
        return $state;
    }

    /**
     * Check if allowed to upload more than one file
     *
     * @return bool
     */
    public function getIsMultiUpload()
    {
        if (isset($this->multiUpload)) {
            return $this->multiUpload;
        }
        // Guess from record
        $record = $this->getRecord();
        $name = $this->getName();

        // Disabled for has_one components
        if ($record && DataObject::getSchema()->hasOneComponent(get_class($record), $name)) {
            return false;
        }
        return true;
    }

    /**
     * Set upload type to multiple or single
     *
     * @param bool $bool True for multiple, false for single
     * @return $this
     */
    public function setIsMultiUpload($bool)
    {
        $this->multiUpload = $bool;
        return $this;
    }

    /**
     * Gets the number of files allowed for this field
     *
     * @return null|int
     */
    public function getAllowedMaxFileNumber()
    {
        return $this->allowedMaxFileNumber;
    }

    /**
     * Returns the max allowed filesize
     *
     * @return null|int
     */
    public function getAllowedMaxFileSize()
    {
        return $this->getValidator()->getLargestAllowedMaxFileSize();
    }

    /**
     * @return boolean
     */
    public function isDefaultMaxFileSize()
    {
        // This returns null until getAllowedMaxFileSize is called
        $current = $this->getValidator()->getLargestAllowedMaxFileSize();
        return $current ? false : true;
    }

    /**
     * Sets the number of files allowed for this field
     * @param $count
     * @return $this
     */
    public function setAllowedMaxFileNumber($count)
    {
        $this->allowedMaxFileNumber = $count;

        return $this;
    }

    public function getAttributes()
    {
        $attributes = array(
            'class' => $this->extraClass(),
            'type' => 'file',
            'multiple' => $this->getIsMultiUpload(),
            'id' => $this->ID(),
            'data-schema' => json_encode($this->getSchemaData()),
            'data-state' => json_encode($this->getSchemaState()),
        );

        $attributes = array_merge($attributes, $this->attributes);

        $this->extend('updateAttributes', $attributes);

        return $attributes;
    }

    public function Type()
    {
        return 'file';
    }

    public function performReadonlyTransformation()
    {
        $clone = clone $this;
        $clone->setReadonly(true);
        return $clone;
    }

    public function performDisabledTransformation()
    {
        $clone = clone $this;
        $clone->setDisabled(true);
        return $clone;
    }

    /**
     * Checks if the number of files attached adheres to the $allowedMaxFileNumber defined
     *
     * @param Validator $validator

The type LeKoala\FilePond\Validator was not found. Maybe you did not declare it correctly or list all dependencies?

     * @return bool
     */
    public function validate($validator)
    {
        $maxFiles = $this->getAllowedMaxFileNumber();
        $count = count($this->getItems());

        if ($maxFiles < 1 || $count <= $maxFiles) {
            return true;
        }

        $validator->validationError($this->getName(), _t(
            'FilePondField.ErrorMaxFilesReached',
            'You can only upload {count} file.|You can only upload {count} files.',
            [
                'count' => $maxFiles,
            ]
        ));

        return false;
    }

    /**
     * Check if uploading files is enabled
     *
     * @return bool
     */
    public function getUploadEnabled()
    {
        return $this->uploadEnabled;
    }

    /**
     * Set if uploading files is enabled
     *
     * @param bool $uploadEnabled
     * @return $this
     */
    public function setUploadEnabled($uploadEnabled)
    {
        $this->uploadEnabled = $uploadEnabled;
        return $this;
    }

    /**
     * Check if attaching files is enabled
     *
     * @return bool
     */
    public function getAttachEnabled()
    {
        return $this->attachEnabled;
    }

    /**
     * Set if attaching files is enabled
     *
     * @param bool $attachEnabled
     * @return UploadField

The type LeKoala\FilePond\UploadField was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public function setAttachEnabled($attachEnabled)
    {
        $this->attachEnabled = $attachEnabled;
        return $this;

The expression return $this returns the type LeKoala\FilePond\AbstractUploadField which is incompatible with the documented return type LeKoala\FilePond\UploadField.

    }

    public function Field($properties = array())
    {
        $record = $this->getRecord();
        if ($record) {

$record is of type SilverStripe\ORM\DataObject, thus it always evaluated to true.

            $relation = $record->getRelationClass($this->name);

            // Make sure images do not accept default stuff
            if ($relation == Image::class) {
                $allowedExtensions = $this->getAllowedExtensions();
                if (in_array('zip', $allowedExtensions)) {
                    // Only allow processable file types for images by default
                    $this->setAllowedExtensions(['jpg', 'jpeg', 'png']);
                }
            }

            // Set a default description if none set
            if (!$this->description && static::config()->enable_default_description) {
                $this->setDefaultDescription($relation, $record, $this->name);
            }
        }
        return parent::Field($properties);
    }

    /**
     * Gets the upload folder name
     *
     * @return string
     */
    public function getFolderName()
    {
        return ($this->folderName !== false)

The condition $this->folderName !== false is always true.

            ? $this->folderName
            : $this->getDefaultFolderName();
    }

    /**
     * @inheritDoc
     */
    public function Link($action = null)
    {
        if (!$this->form) {
            throw new LogicException(
                'Field must be associated with a form to call Link(). Please use $field->setForm($form);'
            );
        }
        $name = $this->getSafeName();
        $link = Controller::join_links($this->form->FormAction(), 'field/' . $name, $action);
        $this->extend('updateLink', $link, $action);
        return $link;
    }
}