Jaxon\Request\Plugin\FileUpload

Complexity

Total Complexity

35

Size/Duplication

Total Lines	322
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	3
A	sanitizer()	0	4	1
A	files()	0	4	1
A	_makeUploadDir()	0	15	4
A	getUploadDir()	0	8	1
A	getUploadTempDir()	0	7	1
A	getUploadTempFile()	0	12	2
A	readFromHttpData()	0	22	3
A	saveToTempFile()	0	17	3
A	readFromTempFile()	0	15	3
A	getName()	0	4	1
A	generateHash()	0	4	1
A	getScript()	0	4	1
A	noRequestPluginFound()	0	7	2
A	canProcessRequest()	0	4	2
B	processRequest()	0	37	6

<?php

/**
 * FileUpload.php - This class implements file upload with Ajax.
 *
 * @package jaxon-core

Package name "jaxon-core" is not valid; consider "Jaxoncore" instead

 * @author Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @copyright 2017 Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */

PHP version not specified

Missing @category tag in file comment

namespace Jaxon\Request\Plugin;

use Jaxon\Jaxon;
use Jaxon\Plugin\Request as RequestPlugin;
use Jaxon\Request\Support\UploadedFile;
use Jaxon\Request\Support\FileUpload as Support;
use Jaxon\Response\UploadResponse;
use Exception;
use Closure;

class FileUpload extends RequestPlugin

Missing doc comment for class FileUpload

{
    use \Jaxon\Features\Config;
    use \Jaxon\Features\Validator;
    use \Jaxon\Features\Translator;

    /**
     * The uploaded files copied in the user dir
     *
     * @var array
     */
    protected $aUserFiles = [];

    /**
     * The name of file containing upload data
     *
     * @var string
     */
    protected $sTempFile = '';

    /**
     * The subdir where uploaded files are stored
     *
     * @var string
     */
    protected $sUploadSubdir = '';

    /**
     * Is the current request an HTTP upload
     *
     * @var boolean
     */
    protected $bRequestIsHttpUpload = false;

    /**
     * HTTP file upload support
     *
     * @var Support
     */
    protected $xSupport = null;

    /**
     * The constructor
     *
     * @param Support       $xSupport       HTTP file upload support

Expected 1 spaces after parameter type; 7 found

Expected 1 spaces after parameter name; 7 found

     */
    public function __construct(Support $xSupport)
    {
        $this->xSupport = $xSupport;

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

        $this->sUploadSubdir = uniqid() . DIRECTORY_SEPARATOR;

        if(array_key_exists('jxnupl', $_POST))
        {
            $this->sTempFile = $_POST['jxnupl'];
        }
        elseif(array_key_exists('jxnupl', $_GET))
        {
            $this->sTempFile = $_GET['jxnupl'];
        }
    }

    /**
     * Set the uploaded file name sanitizer
     *
     * @param Closure       $cSanitizer            The closure

Expected 1 spaces after parameter type; 7 found

Expected 1 spaces after parameter name; 12 found

     *
     * @return void
     */
    public function sanitizer(Closure $cSanitizer)
    {
        $this->xSupport->setNameSanitizer($cSanitizer);
    }

    /**
     * Get the uploaded files
     *
     * @return array
     */
    public function files()
    {
        return $this->aUserFiles;
    }

    /**
     * Make sure the upload dir exists and is writable
     *
     * @param string        $sUploadDir             The filename

Expected 1 spaces after parameter type; 8 found

Expected 4 spaces after parameter name; 13 found

     * @param string        $sUploadSubDir          The filename

Expected 1 spaces after parameter type; 8 found

Expected 1 spaces after parameter name; 10 found

     *
     * @return string
     */
    private function _makeUploadDir($sUploadDir, $sUploadSubDir)
    {
        $sUploadDir = rtrim(trim($sUploadDir), '/\\') . DIRECTORY_SEPARATOR;

Consider using a different name than the parameter $sUploadDir. This often makes code more readable.

        // Verify that the upload dir exists and is writable
        if(!is_writable($sUploadDir))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
        }
        $sUploadDir .= $sUploadSubDir;
        if(!file_exists($sUploadDir) && !@mkdir($sUploadDir))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
        }
        return $sUploadDir;
    }

    /**
     * Get the path to the upload dir
     *
     * @param string        $sFieldId               The filename

Expected 1 spaces after parameter type; 8 found

Expected 1 spaces after parameter name; 15 found

     *
     * @return string
     */
    protected function getUploadDir($sFieldId)
    {
        // Default upload dir
        $sDefaultUploadDir = $this->getOption('upload.default.dir');
        $sUploadDir = $this->getOption('upload.files.' . $sFieldId . '.dir', $sDefaultUploadDir);

Equals sign not aligned with surrounding assignments; expected 8 spaces but found 1 space

        return $this->_makeUploadDir($sUploadDir, $this->sUploadSubdir);
    }

    /**
     * Get the path to the upload temp dir
     *
     * @return string
     */
    protected function getUploadTempDir()
    {
        // Default upload dir
        $sUploadDir = $this->getOption('upload.default.dir');

        return $this->_makeUploadDir($sUploadDir, 'tmp' . DIRECTORY_SEPARATOR);
    }

    /**
     * Get the path to the upload temp file
     *
     * @return string
     */
    protected function getUploadTempFile()
    {
        $sUploadDir = $this->getOption('upload.default.dir');

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

        $sUploadDir = rtrim(trim($sUploadDir), '/\\') . DIRECTORY_SEPARATOR;

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

        $sUploadDir .= 'tmp' . DIRECTORY_SEPARATOR;

Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space

        $sUploadTempFile = $sUploadDir . $this->sTempFile . '.json';
        if(!is_readable($sUploadTempFile))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
        }
        return $sUploadTempFile;
    }

    /**
     * Read uploaded files info from HTTP request data
     *
     * @return void
     */
    protected function readFromHttpData()
    {
        // Check validity of the uploaded files
        $aTempFiles = $this->xSupport->getUploadedFiles();

        // Copy the uploaded files from the temp dir to the user dir
        foreach($aTempFiles as $sVarName => $aFiles)
        {
            $this->aUserFiles[$sVarName] = [];
            // Get the path to the upload dir
            $sUploadDir = $this->getUploadDir($sVarName);

            foreach($aFiles as $aFile)
            {
                // Set the user file data
                $xUploadedFile = UploadedFile::fromHttpData($sUploadDir, $aFile);
                // All's right, move the file to the user dir.
                move_uploaded_file($aFile["tmp_name"], $xUploadedFile->path());
                $this->aUserFiles[$sVarName][] = $xUploadedFile;
            }
        }
    }

    /**
     * Save uploaded files info to a temp file
     *
     * @return void
     */
    protected function saveToTempFile()
    {
        // Convert uploaded file to an array
        $aFiles = [];
        foreach($this->aUserFiles as $sVarName => $aUserFiles)
        {
            $aFiles[$sVarName] = [];
            foreach($aUserFiles as $aUserFile)
            {
                $aFiles[$sVarName][] = $aUserFile->toTempData();
            }
        }
        // Save upload data in a temp file
        $sUploadDir = $this->getUploadTempDir();

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

        $this->sTempFile = uniqid();
        file_put_contents($sUploadDir . $this->sTempFile . '.json', json_encode($aFiles));
    }

    /**
     * Read uploaded files info from a temp file
     *
     * @return void
     */
    protected function readFromTempFile()
    {
        // Upload temp file
        $sUploadTempFile = $this->getUploadTempFile();
        $aFiles = json_decode(file_get_contents($sUploadTempFile), true);

Equals sign not aligned with surrounding assignments; expected 10 spaces but found 1 space

        foreach($aFiles as $sVarName => $aUserFiles)
        {
            $this->aUserFiles[$sVarName] = [];
            foreach($aUserFiles as $aUserFile)
            {
                $this->aUserFiles[$sVarName][] = UploadedFile::fromTempData($aUserFile);
            }
        }
        unlink($sUploadTempFile);
    }

    /**
     * Return the name of this plugin
     *
     * @return string
     */
    public function getName()
    {
        return Jaxon::FILE_UPLOAD;
    }

    /**
     * Generate a hash for the registered browser events
     *
     * @return string
     */
    public function generateHash()
    {
        return '';
    }

    /**
     * Generate client side javascript code for the registered browser events
     *
     * @return string
     */
    public function getScript()
    {
        return '';
    }

    /**
     * Inform this plugin that other plugin can process the current request
     *
     * @return void
     */
    public function noRequestPluginFound()
    {
        if(count($_FILES) > 0)
        {
            $this->bRequestIsHttpUpload = true;
        }
    }

    /**
     * Check if this plugin can process the incoming Jaxon request
     *
     * @return boolean
     */
    public function canProcessRequest()
    {
        return (count($_FILES) > 0 || ($this->sTempFile));
    }

    /**
     * Process the uploaded files into the HTTP request
     *
     * @return boolean
     */
    public function processRequest()
    {
        if(!$this->canProcessRequest())
        {
            return false;
        }

        if(count($_FILES) > 0)
        {
            // Ajax or Http request with upload
            $this->readFromHttpData();

            if($this->bRequestIsHttpUpload)
            {
                // Process an HTTP upload request
                // This requires to set the response to be returned.
                $xResponse = new UploadResponse();
                try
                {
                    $this->saveToTempFile();
                    $xResponse->setUploadedFile($this->sTempFile);
                }
                catch(Exception $e)
                {
                    $xResponse->setErrorMessage($e->getMessage());
                }
                jaxon()->di()->getResponseManager()->append($xResponse);
            }
        }
        elseif(($this->sTempFile))
        {
            // Ajax request following and HTTP upload
            $this->readFromTempFile();
        }

        return true;
    }
}