VersionedFileUploadField

Complexity

Total Complexity

25

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
F	upload()	0	118	25

<?php
class VersionedFileUploadField extends UploadField
{
    private static $allowed_actions = array(

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

        'upload'
    );

    /**
     * The file to upload a new version of
     * @var File
     */
    public $currentVersionFile;


    /**
     * Action to handle upload of a single file
     * 
     * @param SS_HTTPRequest $request
     * @return string json
     */
    public function upload(SS_HTTPRequest $request)
    {
        if (!$this->currentVersionFile) {
            return;
        }


        if ($this->isDisabled() || $this->isReadonly()) {
            return $this->httpError(403);
        }

        // Protect against CSRF on destructive action
        $token = $this->getForm()->getSecurityToken();
        if (!$token->checkRequest($request)) {
            return $this->httpError(400);
        }

        $name = $this->getName();
        $tmpfile = $request->postVar($name);
        $record = $this->getRecord();
        
        // Check if the file has been uploaded into the temporary storage.
        if (!$tmpfile) {
            $return = array('error' => _t('UploadField.FIELDNOTSET', 'File information not found'));
        } else {
            $return = array(
                'name' => $tmpfile['name'],
                'size' => $tmpfile['size'],
                'type' => $tmpfile['type'],
                'error' => $tmpfile['error']
            );
        }

        // Check for constraints on the record to which the file will be attached.
        if (!$return['error'] && $this->relationAutoSetting && $record && $record->exists()) {
            $tooManyFiles = false;
            // Some relationships allow many files to be attached.
            if ($this->getConfig('allowedMaxFileNumber') && ($record->has_many($name) || $record->many_many($name))) {

The method DataObject::has_many() has been deprecated with message: 4.0 Method has been replaced by hasMany() and hasManyComponent()

The method DataObject::many_many() has been deprecated with message: 4.0 Method has been renamed to manyMany()

                if (!$record->isInDB()) {
                    $record->write();
                }
                $tooManyFiles = $record->{$name}()->count() >= $this->getConfig('allowedMaxFileNumber');
            // has_one only allows one file at any given time.
            } elseif ($record->has_one($name)) {

The method DataObject::has_one() has been deprecated with message: 4.0 Method has been replaced by hasOne() and hasOneComponent()

                $tooManyFiles = $record->{$name}() && $record->{$name}()->exists();
            }

            // Report the constraint violation.
            if ($tooManyFiles) {
                if (!$this->getConfig('allowedMaxFileNumber')) {
                    $this->setConfig('allowedMaxFileNumber', 1);
                }
                $return['error'] = _t(
                    'UploadField.MAXNUMBEROFFILES',
                    'Max number of {count} file(s) exceeded.',
                    array('count' => $this->getConfig('allowedMaxFileNumber'))

array('count' => $this->getConfig('allowedMaxFileNumber')) is of type array<string,*,{"count":"*"}>, but the function expects a string.

                );
            }
        }

        // Process the uploaded file
        if (!$return['error']) {
            // Get the uploaded file into a new file object.
            try {
                $currentFilePath = $this->currentVersionFile->getFullPath();
                if (file_exists($currentFilePath)) {
                    unlink($this->currentVersionFile->getFullPath());
                }

                // If $folderName == assets (by default), then this will try and create a file inside assets/assets
                // instead of creating it in the root. This check ensures that the newly uploaded files overwrites the
                // old file in the assets root directory.
                $folderName = $this->folderName;
                if ($folderName == basename(ASSETS_PATH)) {
                    $folderName = "/";
                }

                $this->upload->loadIntoFile(
                    array_merge($tmpfile, array('name' => $this->currentVersionFile->Name)),
                    $this->currentVersionFile,
                    $folderName

$folderName is of type string, but the function expects a boolean.

                );
            } catch (Exception $e) {
                // we shouldn't get an error here, but just in case
                $return['error'] = $e->getMessage();
            }

            if (!$return['error']) {
                if ($this->upload->isError()) {
                    $return['error'] = implode(' '.PHP_EOL, $this->upload->getErrors());
                } else {
                    $file = $this->upload->getFile();

                    $file->createVersion();

                    // Attach the file to the related record.
                    if ($this->relationAutoSetting) {
                        $this->attachFile($file);

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

                    }

                    // Collect all output data.
                    $file =  $this->customiseFile($file);
                    $return = array_merge($return, array(
                        'id' => $file->ID,
                        'name' => $file->getTitle() . '.' . $file->getExtension(),

The method getExtension() does not exist on ViewableData_Customised. Did you maybe mean getExtensionInstance()?

                        'url' => $file->getURL(),
                        'thumbnail_url' => $file->UploadFieldThumbnailURL,
                        'edit_url' => $file->UploadFieldEditLink,
                        'size' => $file->getAbsoluteSize(),
                        'buttons' => $file->UploadFieldFileButtons
                    ));
                }
            }
        }
        $response = new SS_HTTPResponse(Convert::raw2json(array($return)));
        $response->addHeader('Content-Type', 'text/plain');
        return $response;
    }
}