silverstripe-framework/src/Forms/FileUploadReceiver.php

<?php

namespace SilverStripe\Forms;

use Exception;
use InvalidArgumentException;
use SilverStripe\Assets\File;
use SilverStripe\Assets\Storage\AssetContainer;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\DataObjectInterface;
use SilverStripe\ORM\RelationList;
use SilverStripe\ORM\SS_List;
use SilverStripe\ORM\UnsavedRelationList;
use SilverStripe\ORM\ValidationException;

/**
 * Provides operations for reading and writing uploaded files to/from
 * {@see File} dataobject instances.
 * Allows writing to a parent record with the following relation types:
 *   - has_one
 *   - has_many
 *   - many_many
 * Additionally supports writing directly to the File table not attached
 * to any parent record.
 *
 * Note that this trait expects to be applied to a {@see FormField} class
 *
 * @mixin FormField
 */
trait FileUploadReceiver
{
    use UploadReceiver;

    /**
     * Flag to automatically determine and save a has_one-relationship
     * on the saved record (e.g. a "Player" has_one "PlayerImage" would
     * trigger saving the ID of newly created file into "PlayerImageID"
     * on the record).
     *
     * @var boolean
     */
    public $relationAutoSetting = true;

    /**
     * Parent data record. Will be inferred from parent form or controller if blank.
     *
     * @var DataObject
     */
    protected $record;

    /**
     * Items loaded into this field. May be a RelationList, or any other SS_List
     *
     * @var SS_List
     */
    protected $items;

    protected function constructFileUploadReceiver()
    {
        $this->constructUploadReceiver();
    }


    /**
     * Force a record to be used as "Parent" for uploaded Files (eg a Page with a has_one to File)
     *
     * @param DataObject $record
     * @return $this
     */
    public function setRecord($record)
    {
        $this->record = $record;
        return $this;
    }
    /**
     * Get the record to use as "Parent" for uploaded Files (eg a Page with a has_one to File) If none is set, it will
     * use Form->getRecord() or Form->Controller()->data()
     *
     * @return DataObject
     */
    public function getRecord()
    {
        if ($this->record) {
            return $this->record;
        }
        if (!$this->getForm()) {
            return null;
        }

        // Get record from form
        $record = $this->getForm()->getRecord();
        if ($record && ($record instanceof DataObject)) {
            $this->record = $record;
            return $record;
        }

        // Get record from controller
        $controller = $this->getForm()->getController();
        if ($controller
            && $controller->hasMethod('data')
            && ($record = $controller->data())
            && ($record instanceof DataObject)
        ) {
            $this->record = $record;
            return $record;
        }

        return null;
    }


    /**
     * Loads the related record values into this field. This can be uploaded
     * in one of three ways:
     *
     *  - By passing in a list of file IDs in the $value parameter (an array with a single
     *    key 'Files', with the value being the actual array of IDs).
     *  - By passing in an explicit list of File objects in the $record parameter, and
     *    leaving $value blank.
     *  - By passing in a dataobject in the $record parameter, from which file objects
     *    will be extracting using the field name as the relation field.
     *
     * Each of these methods will update both the items (list of File objects) and the
     * field value (list of file ID values).
     *
     * @param array $value Array of submitted form data, if submitting from a form
     * @param array|DataObject|SS_List $record Full source record, either as a DataObject,
     * SS_List of items, or an array of submitted form data
     * @return $this Self reference
     * @throws ValidationException
     */
    public function setValue($value, $record = null)
    {

        // If we're not passed a value directly, we can attempt to infer the field
        // value from the second parameter by inspecting its relations
        $items = new ArrayList();

        // Determine format of presented data
        if ($value instanceof File) {
            $items = ArrayList::create([$value]);
            $value = null;
        } elseif ($value instanceof SS_List) {
            $items = $value;
            $value = null;
        } elseif (empty($value) && $record) {
            // If a record is given as a second parameter, but no submitted values,
            // then we should inspect this instead for the form values

            if (($record instanceof DataObject) && $record->hasMethod($this->getName())) {
                // If given a dataobject use reflection to extract details

                $data = $record->{$this->getName()}();
                if ($data instanceof DataObject) {
                    // If has_one, add sole item to default list
                    $items->push($data);
                } elseif ($data instanceof SS_List) {
                    // For many_many and has_many relations we can use the relation list directly
                    $items = $data;
                }
            } elseif ($record instanceof SS_List) {
                // If directly passing a list then save the items directly
                $items = $record;
            }
        } elseif (is_array($value) && !empty($value['Files'])) {
            // If value is given as an array (such as a posted form), extract File IDs from this
            $class = $this->getRelationAutosetClass();
            $items = DataObject::get($class)->byIDs($value['Files']);
        }

        // If javascript is disabled, direct file upload (non-html5 style) can
        // trigger a single or multiple file submission. Note that this may be
        // included in addition to re-submitted File IDs as above, so these
        // should be added to the list instead of operated on independently.
        if ($uploadedFiles = $this->extractUploadedFileData($value)) {
            foreach ($uploadedFiles as $tempFile) {
                $file = $this->saveTemporaryFile($tempFile, $error);
                if ($file) {
                    $items->add($file);
                } else {
                    throw new ValidationException($error);
                }
            }
        }

        // Filter items by what's allowed to be viewed
        $filteredItems = new ArrayList();
        $fileIDs = [];
        /** @var File $file */
        foreach ($items as $file) {
            if ($file->isInDB() && $file->canView()) {
                $filteredItems->push($file);
                $fileIDs[] = $file->ID;
            }
        }

        // Filter and cache updated item list
        $this->items = $filteredItems;
        // Same format as posted form values for this field. Also ensures that
        // $this->setValue($this->getValue()); is non-destructive
        $value = $fileIDs ? ['Files' => $fileIDs] : null;

        // Set value using parent
        parent::setValue($value, $record);
        return $this;
    }

    /**
     * Sets the items assigned to this field as an SS_List of File objects.
     * Calling setItems will also update the value of this field, as well as
     * updating the internal list of File items.
     *
     * @param SS_List $items
     * @return $this self reference
     */
    public function setItems(SS_List $items)
    {
        return $this->setValue(null, $items);
    }

    /**
     * Retrieves the current list of files
     *
     * @return SS_List|File[]
     */
    public function getItems()
    {
        return $this->items ? $this->items : new ArrayList();
    }

    /**
     * Retrieves the list of selected file IDs
     *
     * @return array
     */
    public function getItemIDs()
    {
        $value = $this->Value();
        return empty($value['Files']) ? [] : $value['Files'];
    }

    public function Value()
    {
        // Re-override FileField Value to use data value
        return $this->dataValue();
    }

    /**
     * @param DataObject|DataObjectInterface $record
     * @return $this
     */
    public function saveInto(DataObjectInterface $record)
    {
        // Check required relation details are available
        $fieldname = $this->getName();
        if (!$fieldname) {
            return $this;
        }

        // Get details to save
        $idList = $this->getItemIDs();

        // Check type of relation
        $relation = $record->hasMethod($fieldname) ? $record->$fieldname() : null;
        if ($relation && ($relation instanceof RelationList || $relation instanceof UnsavedRelationList)) {
            // has_many or many_many
            $relation->setByIDList($idList);
        } elseif ($class = DataObject::getSchema()->hasOneComponent(get_class($record), $fieldname)) {
            // Assign has_one ID
            $id = $idList ? reset($idList) : 0;
            $record->{"{$fieldname}ID"} = $id;

            // Polymorphic assignment
            if ($class === DataObject::class) {
                $file = $id ? File::get()->byID($id) : null;
                $fileClass = $file ? get_class($file) : File::class;
                $record->{"{$fieldname}Class"} = $id ? $fileClass : null;
            }
        }
        return $this;
    }

    /**
     * Loads the temporary file data into a File object
     *
     * @param array $tmpFile Temporary file data
     * @param string $error Error message
     * @return AssetContainer File object, or null if error
     */
    protected function saveTemporaryFile($tmpFile, &$error = null)
    {
        // Determine container object
        $error = null;
        $fileObject = null;

        if (empty($tmpFile)) {
            $error = _t('SilverStripe\\Forms\\FileUploadReceiver.FIELDNOTSET', 'File information not found');
            return null;
        }

        if ($tmpFile['error']) {
            $this->getUpload()->validate($tmpFile);
            $error = implode(' ' . PHP_EOL, $this->getUpload()->getErrors());
            return null;
        }

        // Search for relations that can hold the uploaded files, but don't fallback
        // to default if there is no automatic relation
        if ($relationClass = $this->getRelationAutosetClass(null)) {
            // Allow File to be subclassed
            if ($relationClass === File::class && isset($tmpFile['name'])) {
                $relationClass = File::get_class_for_file_extension(
                    File::get_file_extension($tmpFile['name'])
                );
            }
            // Create new object explicitly. Otherwise rely on Upload::load to choose the class.
            $fileObject = Injector::inst()->create($relationClass);
            if (! ($fileObject instanceof DataObject) || !($fileObject instanceof AssetContainer)) {
                throw new InvalidArgumentException("Invalid asset container $relationClass");
            }
        }

        // Get the uploaded file into a new file object.
        try {
            $this->getUpload()->loadIntoFile($tmpFile, $fileObject, $this->getFolderName());
        } catch (Exception $e) {
            // we shouldn't get an error here, but just in case
            $error = $e->getMessage();
            return null;
        }

        // Check if upload field has an error
        if ($this->getUpload()->isError()) {
            $error = implode(' ' . PHP_EOL, $this->getUpload()->getErrors());
            return null;
        }

        // return file
        return $this->getUpload()->getFile();
    }

    /**
     * Gets the foreign class that needs to be created, or 'File' as default if there
     * is no relationship, or it cannot be determined.
     *
     * @param string $default Default value to return if no value could be calculated
     * @return string Foreign class name.
     */
    public function getRelationAutosetClass($default = File::class)
    {
        // Don't autodetermine relation if no relationship between parent record
        if (!$this->getRelationAutoSetting()) {
            return $default;
        }

        // Check record and name
        $name = $this->getName();
        $record = $this->getRecord();
        if (empty($name) || empty($record)) {
            return $default;
        } else {
            $class = $record->getRelationClass($name);
            return empty($class) ? $default : $class;
        }
    }

    /**
     * Set if relation can be automatically assigned to the underlying dataobject
     *
     * @param bool $auto
     * @return $this
     */
    public function setRelationAutoSetting($auto)
    {
        $this->relationAutoSetting = $auto;
        return $this;
    }

    /**
     * Check if relation can be automatically assigned to the underlying dataobject
     *
     * @return bool
     */
    public function getRelationAutoSetting()
    {
        return $this->relationAutoSetting;
    }

    /**
     * Given an array of post variables, extract all temporary file data into an array
     *
     * @param array $postVars Array of posted form data
     * @return array List of temporary file data
     */
    protected function extractUploadedFileData($postVars)
    {
        // Note: Format of posted file parameters in php is a feature of using
        // <input name='{$Name}[Uploads][]' /> for multiple file uploads
        $tmpFiles = [];
        if (!empty($postVars['tmp_name'])
            && is_array($postVars['tmp_name'])
            && !empty($postVars['tmp_name']['Uploads'])
        ) {
            for ($i = 0; $i < count($postVars['tmp_name']['Uploads'] ?? []); $i++) {
                // Skip if "empty" file
                if (empty($postVars['tmp_name']['Uploads'][$i])) {
                    continue;
                }
                $tmpFile = [];
                foreach (['name', 'type', 'tmp_name', 'error', 'size'] as $field) {
                    $tmpFile[$field] = $postVars[$field]['Uploads'][$i];
                }
                $tmpFiles[] = $tmpFile;
            }
        } elseif (!empty($postVars['tmp_name'])) {
            // Fallback to allow single file uploads (method used by AssetUploadField)
            $tmpFiles[] = $postVars;
        }

        return $tmpFiles;
    }
}