FileUpload::processRequest() - Code Metrics - Inspection of "The library js code is no more generated when the..." - jaxon-php/jaxon-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e11ac2...ace11e )

by Thierry

created 2017-10-12 02:12 UTC

FileUpload::processRequest() A

↳ Parent: FileUpload

Complexity

Conditions	4
Paths	4

Size

Total Lines	16
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	8
nc	4
nop	0
dl	0
loc	16
rs	9.2
c	1
b	0
f	0

<?php

/**
 * FileUpload.php - This class implements file upload with Ajax.
 *
 * @package jaxon-core
 * @author Thierry Feuzeu <[email protected]>
 * @copyright 2017 Thierry Feuzeu <[email protected]>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */

namespace Jaxon\Request\Plugin;

use Jaxon\Jaxon;
use Jaxon\Plugin\Request as RequestPlugin;
use Jaxon\Request\Support\UploadedFile;

class FileUpload extends RequestPlugin
{
    use \Jaxon\Utils\Traits\Validator;
    use \Jaxon\Utils\Traits\Translator;

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

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

    /**
     * A user defined function to transform uploaded file names
     *
     * @var Closure
     */
    protected $fFileFilter = null;

    /**
     * Read uploaded files info from the $_FILES global var
     */
    public function __construct()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        $this->aUserFiles = [];

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

    /**
     * Filter uploaded file name
     *
     * @param Closure       $fFileFilter            The closure which filters filenames
     *
     * @return void
     */
    public function setFileFilter($fFileFilter)
    {
        $this->fFileFilter = $fFileFilter;
    }

    /**
     * Filter uploaded file name
     *
     * @param string        $sFilename              The filename
     * @param string        $sVarName               The associated variable name
     *
     * @return string
     */
    protected function filterFilename($sFilename, $sVarName)
    {
        if(($this->fFileFilter))
        {
            $fFileFilter = $this->fFileFilter;
            $sFilename = (string)$fFileFilter($sFilename, $sVarName);
        }
        return $sFilename;
    }

    /**
     * Read uploaded files info from HTTP request data
     *
     * @return void
     */
    protected function readFromHttpData()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        // Check validity of the uploaded files
        $aTempFiles = [];
        foreach($_FILES as $sVarName => $aFile)
        {
            if(is_array($aFile['name']))
            {
                for($i = 0; $i < count($aFile['name']); $i++)
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                {
                    if(!$aFile['name'][$i])
                    {
                        continue;
                    }
                    if(!array_key_exists($sVarName, $aTempFiles))
                    {
                        $aTempFiles[$sVarName] = [];
                    }
                    // Filename without the extension
                    $sFilename = $this->filterFilename(pathinfo($aFile['name'][$i], PATHINFO_FILENAME), $sVarName);
                    // Copy the file data into the local array
                    $aTempFiles[$sVarName][] = [
                        'name' => $aFile['name'][$i],
                        'type' => $aFile['type'][$i],
                        'tmp_name' => $aFile['tmp_name'][$i],
                        'error' => $aFile['error'][$i],
                        'size' => $aFile['size'][$i],
                        'filename' => $sFilename,
                        'extension' => pathinfo($aFile['name'][$i], PATHINFO_EXTENSION),
                    ];
                }
            }
            else
            {
                if(!$aFile['name'])
                {
                    continue;
                }
                if(!array_key_exists($sVarName, $aTempFiles))
                {
                    $aTempFiles[$sVarName] = [];
                }
                // Filename without the extension
                $sFilename = $this->filterFilename(pathinfo($aFile['name'], PATHINFO_FILENAME), $sVarName);
                // Copy the file data into the local array
                $aTempFiles[$sVarName][] = [
                    'name' => $aFile['name'],
                    'type' => $aFile['type'],
                    'tmp_name' => $aFile['tmp_name'],
                    'error' => $aFile['error'],
                    'size' => $aFile['size'],
                    'filename' => $sFilename,
                    'extension' => pathinfo($aFile['name'], PATHINFO_EXTENSION),
                ];
            }
        }

        // Default upload dir
        $sDefaultUploadDir = $this->getOption('upload.default.dir');

        // Check uploaded files validity
        foreach($aTempFiles as $sVarName => $aFiles)
        {
            foreach($aFiles as $aFile)
            {
                // Verify upload result
                if($aFile['error'] != 0)
                {
                    throw new \Jaxon\Exception\Error($this->trans('errors.upload.failed', $aFile));
                }
                // Verify file validity (format, size)
                if(!$this->validateUploadedFile($sVarName, $aFile))
                {
                    throw new \Jaxon\Exception\Error($this->getValidatorMessage());
                }
                // Verify that the upload dir exists and is writable
                $sUploadDir = $this->getOption('upload.files.' . $sVarName . '.dir', $sDefaultUploadDir);
                $sUploadDir = rtrim(trim($sUploadDir), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
                if(!is_writable($sUploadDir))
                {
                    throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
                }
            }
        }

        // Copy the uploaded files from the temp dir to the user dir
        foreach($aTempFiles as $sVarName => $aTempFiles)
        {
            $this->aUserFiles[$sVarName] = [];
            foreach($aTempFiles as $aFile)
            {
                // Set the user file data
                $sUploadDir = $this->getOption('upload.files.' . $sVarName . '.dir', $sDefaultUploadDir);
                $sUploadDir = rtrim(trim($sUploadDir), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
                $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()
    {
        // Default upload dir
        $sUploadDir = $this->getOption('upload.default.dir');
        $sUploadDir = rtrim(trim($sUploadDir), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
        if(!is_writable($sUploadDir))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
        }
        // 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
        $this->sTempFile = uniqid();
        $sUploadDir .= 'tmp' . DIRECTORY_SEPARATOR;
        @mkdir($sUploadDir);
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
        file_put_contents($sUploadDir . $this->sTempFile . '.json', json_encode($aFiles));
    }

    /**
     * Read uploaded files info from a temp file
     *
     * @return void
     */
    protected function readFromTempFile()
    {
        // Default upload dir
        $sUploadDir = $this->getOption('upload.default.dir');
        $sUploadDir = rtrim(trim($sUploadDir), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
        $sUploadDir .= 'tmp' . DIRECTORY_SEPARATOR;
        if(!is_readable($sUploadDir . $this->sTempFile . '.json'))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
        }
        $aFiles = file_get_contents($sUploadDir . $this->sTempFile . '.json');
        $aFiles = json_decode($aFiles, true);
        foreach($aFiles as $sVarName => $aUserFiles)
        {
            $this->aUserFiles[$sVarName] = [];
            foreach($aUserFiles as $aUserFile)
            {
                $this->aUserFiles[$sVarName][] = UploadedFile::fromTempData($aUserFile);
            }
        }
        unlink($sUploadDir . $this->sTempFile . '.json');
    }

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

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

    /**
     * Register a browser event
     *
     * @param array         $aArgs                An array containing the event specification
     *
     * @return \Jaxon\Request\Request
     */
    public function register($aArgs)
    {
        return false;
    }

    /**
     * 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 '';
    }

    /**
     * Check if this plugin can process the incoming Jaxon request
     *
     * @return boolean
     */
    public function canProcessRequest()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        return (count($_FILES) > 0 || ($this->sTempFile));
    }

    /**
     * Process the uploaded files into the HTTP request
     *
     * @return boolean
     */
    public function processRequest()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if(!$this->canProcessRequest())
        {
            return false;
        }
        if(count($_FILES) > 0)
        {
            $this->readFromHttpData();
        }
        else if(($this->sTempFile))
        {
            $this->readFromTempFile();
        }
        return true;
    }

    /**
     * Check uploaded files validity and move them to the user dir
     *
     * @return boolean
     */
    public function saveUploadedFiles()
    {
        // Process uploaded files
        if(!$this->processRequest())
        {
            return '';
        }
        // Save upload data in a temp file
        $this->saveToTempFile();
        return $this->sTempFile;
    }
}


1			<?php
2
3			/**
4			* FileUpload.php - This class implements file upload with Ajax.
5			*
6			* @package jaxon-core
7			* @author Thierry Feuzeu <[email protected]>
8			* @copyright 2017 Thierry Feuzeu <[email protected]>
9			* @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
10			* @link https://github.com/jaxon-php/jaxon-core
11			*/
12
13			namespace Jaxon\Request\Plugin;
14
15			use Jaxon\Jaxon;
16			use Jaxon\Plugin\Request as RequestPlugin;
17			use Jaxon\Request\Support\UploadedFile;
18
19			class FileUpload extends RequestPlugin
20			{
21			use \Jaxon\Utils\Traits\Validator;
22			use \Jaxon\Utils\Traits\Translator;
23
24			/**
25			* The uploaded files copied in the user dir
26			*
27			* @var array
28			*/
29			protected $aUserFiles;
30
31			/**
32			* The name of file containing upload data
33			*
34			* @var string
35			*/
36			protected $sTempFile = '';
37
38			/**
39			* A user defined function to transform uploaded file names
40			*
41			* @var Closure
42			*/
43			protected $fFileFilter = null;
44
45			/**
46			* Read uploaded files info from the $_FILES global var
47			*/
48			public function __construct()
			0 ignored issues – show Coding Style introduced 2017-10-12 02:15 UTC by Report Bug Copy Issue Report `__construct` uses the super-global variable `$_POST` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history... Coding Style introduced 2017-10-12 02:15 UTC by Report Bug Copy Issue Report `__construct` uses the super-global variable `$_GET` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
49			{
50			$this->aUserFiles = [];
51
52			if(array_key_exists('jxnupl', $_POST))
53			{
54			$this->sTempFile = $_POST['jxnupl'];
55			}
56			else if(array_key_exists('jxnupl', $_GET))
57			{
58			$this->sTempFile = $_GET['jxnupl'];
59			}
60			}
61
62			/**
63			* Filter uploaded file name
64			*
65			* @param Closure $fFileFilter The closure which filters filenames
66			*
67			* @return void
68			*/
69			public function setFileFilter($fFileFilter)
70			{
71			$this->fFileFilter = $fFileFilter;
72			}
73
74			/**
75			* Filter uploaded file name
76			*
77			* @param string $sFilename The filename
78			* @param string $sVarName The associated variable name
79			*
80			* @return string
81			*/
82			protected function filterFilename($sFilename, $sVarName)
83			{
84			if(($this->fFileFilter))
85			{
86			$fFileFilter = $this->fFileFilter;
87			$sFilename = (string)$fFileFilter($sFilename, $sVarName);
88			}
89			return $sFilename;
90			}
91
92			/**
93			* Read uploaded files info from HTTP request data
94			*
95			* @return void
96			*/
97			protected function readFromHttpData()
			0 ignored issues – show Coding Style introduced 2017-10-12 02:15 UTC by Report Bug Copy Issue Report `readFromHttpData` uses the super-global variable `$_FILES` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
98			{
99			// Check validity of the uploaded files
100			$aTempFiles = [];
101			foreach($_FILES as $sVarName => $aFile)
102			{
103			if(is_array($aFile['name']))
104			{
105			for($i = 0; $i < count($aFile['name']); $i++)
			0 ignored issues – show Performance Best Practice introduced 2017-10-04 01:40 UTC by Report Bug Copy Issue Report It seems like you are calling the size function `count()` as part of the test condition. You might want to compute the size beforehand, and not on each iteration. If the size of the collection does not change during the iteration, it is generally a good practice to compute it beforehand, and not on each iteration: for ($i=0; $i<count($array); $i++) { // calls count() on each iteration } // Better for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once } Loading history...
106			{
107			if(!$aFile['name'][$i])
108			{
109			continue;
110			}
111			if(!array_key_exists($sVarName, $aTempFiles))
112			{
113			$aTempFiles[$sVarName] = [];
114			}
115			// Filename without the extension
116			$sFilename = $this->filterFilename(pathinfo($aFile['name'][$i], PATHINFO_FILENAME), $sVarName);
117			// Copy the file data into the local array
118			$aTempFiles[$sVarName][] = [
119			'name' => $aFile['name'][$i],
120			'type' => $aFile['type'][$i],
121			'tmp_name' => $aFile['tmp_name'][$i],
122			'error' => $aFile['error'][$i],
123			'size' => $aFile['size'][$i],
124			'filename' => $sFilename,
125			'extension' => pathinfo($aFile['name'][$i], PATHINFO_EXTENSION),
126			];
127			}
128			}
129			else
130			{
131			if(!$aFile['name'])
132			{
133			continue;
134			}
135			if(!array_key_exists($sVarName, $aTempFiles))
136			{
137			$aTempFiles[$sVarName] = [];
138			}
139			// Filename without the extension
140			$sFilename = $this->filterFilename(pathinfo($aFile['name'], PATHINFO_FILENAME), $sVarName);
141			// Copy the file data into the local array
142			$aTempFiles[$sVarName][] = [
143			'name' => $aFile['name'],
144			'type' => $aFile['type'],
145			'tmp_name' => $aFile['tmp_name'],
146			'error' => $aFile['error'],
147			'size' => $aFile['size'],
148			'filename' => $sFilename,
149			'extension' => pathinfo($aFile['name'], PATHINFO_EXTENSION),
150			];
151			}
152			}
153
154			// Default upload dir
155			$sDefaultUploadDir = $this->getOption('upload.default.dir');
156
157			// Check uploaded files validity
158			foreach($aTempFiles as $sVarName => $aFiles)
159			{
160			foreach($aFiles as $aFile)
161			{
162			// Verify upload result
163			if($aFile['error'] != 0)
164			{
165			throw new \Jaxon\Exception\Error($this->trans('errors.upload.failed', $aFile));
166			}
167			// Verify file validity (format, size)
168			if(!$this->validateUploadedFile($sVarName, $aFile))
169			{
170			throw new \Jaxon\Exception\Error($this->getValidatorMessage());
171			}
172			// Verify that the upload dir exists and is writable
173			$sUploadDir = $this->getOption('upload.files.' . $sVarName . '.dir', $sDefaultUploadDir);
174			$sUploadDir = rtrim(trim($sUploadDir), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
175			if(!is_writable($sUploadDir))
176			{
177			throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
178			}
179			}
180			}
181
182			// Copy the uploaded files from the temp dir to the user dir
183			foreach($aTempFiles as $sVarName => $aTempFiles)
184			{
185			$this->aUserFiles[$sVarName] = [];
186			foreach($aTempFiles as $aFile)
187			{
188			// Set the user file data
189			$sUploadDir = $this->getOption('upload.files.' . $sVarName . '.dir', $sDefaultUploadDir);
190			$sUploadDir = rtrim(trim($sUploadDir), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
191			$xUploadedFile = UploadedFile::fromHttpData($sUploadDir, $aFile);
192			// All's right, move the file to the user dir.
193			move_uploaded_file($aFile["tmp_name"], $xUploadedFile->path());
194			$this->aUserFiles[$sVarName][] = $xUploadedFile;
195			}
196			}
197			}
198
199			/**
200			* Save uploaded files info to a temp file
201			*
202			* @return void
203			*/
204			protected function saveToTempFile()
205			{
206			// Default upload dir
207			$sUploadDir = $this->getOption('upload.default.dir');
208			$sUploadDir = rtrim(trim($sUploadDir), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
209			if(!is_writable($sUploadDir))
210			{
211			throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
212			}
213			// Convert uploaded file to an array
214			$aFiles = [];
215			foreach($this->aUserFiles as $sVarName => $aUserFiles)
216			{
217			$aFiles[$sVarName] = [];
218			foreach($aUserFiles as $aUserFile)
219			{
220			$aFiles[$sVarName][] = $aUserFile->toTempData();
221			}
222			}
223			// Save upload data in a temp file
224			$this->sTempFile = uniqid();
225			$sUploadDir .= 'tmp' . DIRECTORY_SEPARATOR;
226			@mkdir($sUploadDir);
			0 ignored issues – show Security Best Practice introduced 2017-10-12 02:15 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
227			file_put_contents($sUploadDir . $this->sTempFile . '.json', json_encode($aFiles));
228			}
229
230			/**
231			* Read uploaded files info from a temp file
232			*
233			* @return void
234			*/
235			protected function readFromTempFile()
236			{
237			// Default upload dir
238			$sUploadDir = $this->getOption('upload.default.dir');
239			$sUploadDir = rtrim(trim($sUploadDir), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
240			$sUploadDir .= 'tmp' . DIRECTORY_SEPARATOR;
241			if(!is_readable($sUploadDir . $this->sTempFile . '.json'))
242			{
243			throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
244			}
245			$aFiles = file_get_contents($sUploadDir . $this->sTempFile . '.json');
246			$aFiles = json_decode($aFiles, true);
247			foreach($aFiles as $sVarName => $aUserFiles)
248			{
249			$this->aUserFiles[$sVarName] = [];
250			foreach($aUserFiles as $aUserFile)
251			{
252			$this->aUserFiles[$sVarName][] = UploadedFile::fromTempData($aUserFile);
253			}
254			}
255			unlink($sUploadDir . $this->sTempFile . '.json');
256			}
257
258			/**
259			* Return the name of this plugin
260			*
261			* @return string
262			*/
263			public function getName()
264			{
265			return Jaxon::FILE_UPLOAD;
266			}
267
268			/**
269			* Get the uploaded files
270			*
271			* @return array
272			*/
273			public function getUploadedFiles()
274			{
275			return $this->aUserFiles;
276			}
277
278			/**
279			* Register a browser event
280			*
281			* @param array $aArgs An array containing the event specification
282			*
283			* @return \Jaxon\Request\Request
284			*/
285			public function register($aArgs)
286			{
287			return false;
288			}
289
290			/**
291			* Generate a hash for the registered browser events
292			*
293			* @return string
294			*/
295			public function generateHash()
296			{
297			return '';
298			}
299
300			/**
301			* Generate client side javascript code for the registered browser events
302			*
303			* @return string
304			*/
305			public function getScript()
306			{
307			return '';
308			}
309
310			/**
311			* Check if this plugin can process the incoming Jaxon request
312			*
313			* @return boolean
314			*/
315			public function canProcessRequest()
			0 ignored issues – show Coding Style introduced 2017-10-12 02:15 UTC by Report Bug Copy Issue Report `canProcessRequest` uses the super-global variable `$_FILES` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
316			{
317			return (count($_FILES) > 0 \|\| ($this->sTempFile));
318			}
319
320			/**
321			* Process the uploaded files into the HTTP request
322			*
323			* @return boolean
324			*/
325			public function processRequest()
			0 ignored issues – show Coding Style introduced 2017-10-12 02:15 UTC by Report Bug Copy Issue Report `processRequest` uses the super-global variable `$_FILES` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
326			{
327			if(!$this->canProcessRequest())
328			{
329			return false;
330			}
331			if(count($_FILES) > 0)
332			{
333			$this->readFromHttpData();
334			}
335			else if(($this->sTempFile))
336			{
337			$this->readFromTempFile();
338			}
339			return true;
340			}
341
342			/**
343			* Check uploaded files validity and move them to the user dir
344			*
345			* @return boolean
346			*/
347			public function saveUploadedFiles()
348			{
349			// Process uploaded files
350			if(!$this->processRequest())
351			{
352			return '';
353			}
354			// Save upload data in a temp file
355			$this->saveToTempFile();
356			return $this->sTempFile;
357			}
358			}
359

jaxon-php / jaxon-core

Push — master ( e11ac2...ace11e )

FileUpload::processRequest() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like