FileUpload - Code Metrics - Inspection of "Merge pull request #48 from jaxon-php/develop" - jaxon-php/jaxon-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f42a52...0a9499 )

by Thierry

created 2019-11-11 06:06 UTC

FileUpload B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	417
Duplicated Lines	1.92 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

Metric	Value
dl	8
loc	417
rs	7.92
c	0
b	0
f	0
wmc	51
lcom	1
cbo	10

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	3
A	setFileFilter()	0	4	1
A	filterFilename()	0	9	2
A	getUploadDir()	4	18	4
A	getUploadTempDir()	4	17	4
A	getUploadTempFile()	0	12	2
C	readFromHttpData()	0	94	14
A	saveToTempFile()	0	17	3
A	readFromTempFile()	0	15	3
A	getName()	0	4	1
A	filter()	0	4	1
A	files()	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

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like FileUpload often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use FileUpload, and based on these observations, apply Extract Interface, too.

<?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;
use Jaxon\Response\UploadResponse;

use Exception;
use Closure;

class FileUpload extends RequestPlugin
{
    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 = '';

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

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

    /**
     * Read uploaded files info from the $_FILES global var
     */
    public function __construct()
    {
        $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'];
        }
    }

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

    /**
     * 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->cFileFilter))
        {
            $cFileFilter = $this->cFileFilter;
            $sFilename = (string)$cFileFilter($sFilename, $sVarName);
        }
        return $sFilename;
    }

    /**
     * Get the path to the upload dir
     *
     * @param string        $sFieldId               The filename
     *
     * @return string
     */
    protected function getUploadDir($sFieldId)
    {
        // Default upload dir
        $sDefaultUploadDir = $this->getOption('upload.default.dir');
        $sUploadDir = $this->getOption('upload.files.' . $sFieldId . '.dir', $sDefaultUploadDir);
        $sUploadDir = rtrim(trim($sUploadDir), '/\\') . DIRECTORY_SEPARATOR;
        // Verify that the upload dir exists and is writable
        if(!is_writable($sUploadDir))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
        }
        $sUploadDir .= $this->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 temp dir
     *
     * @return string
     */
    protected function getUploadTempDir()
    {
        // Default upload dir
        $sUploadDir = $this->getOption('upload.default.dir');
        $sUploadDir = rtrim(trim($sUploadDir), '/\\') . DIRECTORY_SEPARATOR;
        // Verify that the upload dir exists and is writable
        if(!is_writable($sUploadDir))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
        }
        $sUploadDir .= 'tmp' . DIRECTORY_SEPARATOR;
        if(!file_exists($sUploadDir) && !@mkdir($sUploadDir))

        {
            throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
        }
        return $sUploadDir;
    }

    /**
     * Get the path to the upload temp file
     *
     * @return string
     */
    protected function getUploadTempFile()
    {
        $sUploadDir = $this->getOption('upload.default.dir');
        $sUploadDir = rtrim(trim($sUploadDir), '/\\') . DIRECTORY_SEPARATOR;
        $sUploadDir .= 'tmp' . DIRECTORY_SEPARATOR;
        $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 = [];
        foreach($_FILES as $sVarName => $aFile)
        {
            if(is_array($aFile['name']))
            {
                $nFileCount = count($aFile['name']);
                for($i = 0; $i < $nFileCount; $i++)
                {
                    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),
                ];
            }
        }

        // 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());
                }
                // Get the path to the upload dir
                $this->getUploadDir($sVarName);
            }
        }

        // Copy the uploaded files from the temp dir to the user dir
        foreach($aTempFiles as $sVarName => $_aTempFiles)
        {
            $this->aUserFiles[$sVarName] = [];
            foreach($_aTempFiles as $aFile)
            {
                // Get the path to the upload dir
                $sUploadDir = $this->getUploadDir($sVarName);
                // 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();
        $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);
        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;
    }

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

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

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


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		use Jaxon\Response\UploadResponse;
19
20		use Exception;
21		use Closure;
22
23		class FileUpload extends RequestPlugin
24		{
25		use \Jaxon\Features\Config;
26		use \Jaxon\Features\Validator;
27		use \Jaxon\Features\Translator;
28
29		/**
30		* The uploaded files copied in the user dir
31		*
32		* @var array
33		*/
34		protected $aUserFiles = [];
35
36		/**
37		* The name of file containing upload data
38		*
39		* @var string
40		*/
41		protected $sTempFile = '';
42
43		/**
44		* The subdir where uploaded files are stored
45		*
46		* @var string
47		*/
48		protected $sUploadSubdir = '';
49
50		/**
51		* A user defined function to transform uploaded file names
52		*
53		* @var Closure
54		*/
55		protected $cFileFilter = null;
56
57		/**
58		* Is the current request an HTTP upload
59		*
60		* @var boolean
61		*/
62		protected $bRequestIsHttpUpload = false;
63
64		/**
65		* Read uploaded files info from the $_FILES global var
66		*/
67		public function __construct()
68		{
69		$this->sUploadSubdir = uniqid() . DIRECTORY_SEPARATOR;
70
71		if(array_key_exists('jxnupl', $_POST))
72		{
73		$this->sTempFile = $_POST['jxnupl'];
74		}
75		elseif(array_key_exists('jxnupl', $_GET))
76		{
77		$this->sTempFile = $_GET['jxnupl'];
78		}
79		}
80
81		/**
82		* Filter uploaded file name
83		*
84		* @param Closure $cFileFilter The closure which filters filenames
85		*
86		* @return void
87		*/
88		public function setFileFilter(Closure $cFileFilter)
89		{
90		$this->cFileFilter = $cFileFilter;
91		}
92
93		/**
94		* Filter uploaded file name
95		*
96		* @param string $sFilename The filename
97		* @param string $sVarName The associated variable name
98		*
99		* @return string
100		*/
101		protected function filterFilename($sFilename, $sVarName)
102		{
103		if(($this->cFileFilter))
104		{
105		$cFileFilter = $this->cFileFilter;
106		$sFilename = (string)$cFileFilter($sFilename, $sVarName);
107		}
108		return $sFilename;
109		}
110
111		/**
112		* Get the path to the upload dir
113		*
114		* @param string $sFieldId The filename
115		*
116		* @return string
117		*/
118		protected function getUploadDir($sFieldId)
119		{
120		// Default upload dir
121		$sDefaultUploadDir = $this->getOption('upload.default.dir');
122		$sUploadDir = $this->getOption('upload.files.' . $sFieldId . '.dir', $sDefaultUploadDir);
123		$sUploadDir = rtrim(trim($sUploadDir), '/\\') . DIRECTORY_SEPARATOR;
124		// Verify that the upload dir exists and is writable
125		if(!is_writable($sUploadDir))
126		{
127		throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
128		}
129		$sUploadDir .= $this->sUploadSubdir;
130	View Code Duplication	if(!file_exists($sUploadDir) && !@mkdir($sUploadDir))
		0 ignored issues – show Duplication introduced 2019-11-11 06:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
131		{
132		throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
133		}
134		return $sUploadDir;
135		}
136
137		/**
138		* Get the path to the upload temp dir
139		*
140		* @return string
141		*/
142		protected function getUploadTempDir()
143		{
144		// Default upload dir
145		$sUploadDir = $this->getOption('upload.default.dir');
146		$sUploadDir = rtrim(trim($sUploadDir), '/\\') . DIRECTORY_SEPARATOR;
147		// Verify that the upload dir exists and is writable
148		if(!is_writable($sUploadDir))
149		{
150		throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
151		}
152		$sUploadDir .= 'tmp' . DIRECTORY_SEPARATOR;
153	View Code Duplication	if(!file_exists($sUploadDir) && !@mkdir($sUploadDir))
		0 ignored issues – show Duplication introduced 2019-11-11 06:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
154		{
155		throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
156		}
157		return $sUploadDir;
158		}
159
160		/**
161		* Get the path to the upload temp file
162		*
163		* @return string
164		*/
165		protected function getUploadTempFile()
166		{
167		$sUploadDir = $this->getOption('upload.default.dir');
168		$sUploadDir = rtrim(trim($sUploadDir), '/\\') . DIRECTORY_SEPARATOR;
169		$sUploadDir .= 'tmp' . DIRECTORY_SEPARATOR;
170		$sUploadTempFile = $sUploadDir . $this->sTempFile . '.json';
171		if(!is_readable($sUploadTempFile))
172		{
173		throw new \Jaxon\Exception\Error($this->trans('errors.upload.access'));
174		}
175		return $sUploadTempFile;
176		}
177
178		/**
179		* Read uploaded files info from HTTP request data
180		*
181		* @return void
182		*/
183		protected function readFromHttpData()
184		{
185		// Check validity of the uploaded files
186		$aTempFiles = [];
187		foreach($_FILES as $sVarName => $aFile)
188		{
189		if(is_array($aFile['name']))
190		{
191		$nFileCount = count($aFile['name']);
192		for($i = 0; $i < $nFileCount; $i++)
193		{
194		if(!$aFile['name'][$i])
195		{
196		continue;
197		}
198		if(!array_key_exists($sVarName, $aTempFiles))
199		{
200		$aTempFiles[$sVarName] = [];
201		}
202		// Filename without the extension
203		$sFilename = $this->filterFilename(pathinfo($aFile['name'][$i], PATHINFO_FILENAME), $sVarName);
204		// Copy the file data into the local array
205		$aTempFiles[$sVarName][] = [
206		'name' => $aFile['name'][$i],
207		'type' => $aFile['type'][$i],
208		'tmp_name' => $aFile['tmp_name'][$i],
209		'error' => $aFile['error'][$i],
210		'size' => $aFile['size'][$i],
211		'filename' => $sFilename,
212		'extension' => pathinfo($aFile['name'][$i], PATHINFO_EXTENSION),
213		];
214		}
215		}
216		else
217		{
218		if(!$aFile['name'])
219		{
220		continue;
221		}
222		if(!array_key_exists($sVarName, $aTempFiles))
223		{
224		$aTempFiles[$sVarName] = [];
225		}
226		// Filename without the extension
227		$sFilename = $this->filterFilename(pathinfo($aFile['name'], PATHINFO_FILENAME), $sVarName);
228		// Copy the file data into the local array
229		$aTempFiles[$sVarName][] = [
230		'name' => $aFile['name'],
231		'type' => $aFile['type'],
232		'tmp_name' => $aFile['tmp_name'],
233		'error' => $aFile['error'],
234		'size' => $aFile['size'],
235		'filename' => $sFilename,
236		'extension' => pathinfo($aFile['name'], PATHINFO_EXTENSION),
237		];
238		}
239		}
240
241		// Check uploaded files validity
242		foreach($aTempFiles as $sVarName => $aFiles)
243		{
244		foreach($aFiles as $aFile)
245		{
246		// Verify upload result
247		if($aFile['error'] != 0)
248		{
249		throw new \Jaxon\Exception\Error($this->trans('errors.upload.failed', $aFile));
250		}
251		// Verify file validity (format, size)
252		if(!$this->validateUploadedFile($sVarName, $aFile))
253		{
254		throw new \Jaxon\Exception\Error($this->getValidatorMessage());
255		}
256		// Get the path to the upload dir
257		$this->getUploadDir($sVarName);
258		}
259		}
260
261		// Copy the uploaded files from the temp dir to the user dir
262		foreach($aTempFiles as $sVarName => $_aTempFiles)
263		{
264		$this->aUserFiles[$sVarName] = [];
265		foreach($_aTempFiles as $aFile)
266		{
267		// Get the path to the upload dir
268		$sUploadDir = $this->getUploadDir($sVarName);
269		// Set the user file data
270		$xUploadedFile = UploadedFile::fromHttpData($sUploadDir, $aFile);
271		// All's right, move the file to the user dir.
272		move_uploaded_file($aFile["tmp_name"], $xUploadedFile->path());
273		$this->aUserFiles[$sVarName][] = $xUploadedFile;
274		}
275		}
276		}
277
278		/**
279		* Save uploaded files info to a temp file
280		*
281		* @return void
282		*/
283		protected function saveToTempFile()
284		{
285		// Convert uploaded file to an array
286		$aFiles = [];
287		foreach($this->aUserFiles as $sVarName => $aUserFiles)
288		{
289		$aFiles[$sVarName] = [];
290		foreach($aUserFiles as $aUserFile)
291		{
292		$aFiles[$sVarName][] = $aUserFile->toTempData();
293		}
294		}
295		// Save upload data in a temp file
296		$sUploadDir = $this->getUploadTempDir();
297		$this->sTempFile = uniqid();
298		file_put_contents($sUploadDir . $this->sTempFile . '.json', json_encode($aFiles));
299		}
300
301		/**
302		* Read uploaded files info from a temp file
303		*
304		* @return void
305		*/
306		protected function readFromTempFile()
307		{
308		// Upload temp file
309		$sUploadTempFile = $this->getUploadTempFile();
310		$aFiles = json_decode(file_get_contents($sUploadTempFile), true);
311		foreach($aFiles as $sVarName => $aUserFiles)
312		{
313		$this->aUserFiles[$sVarName] = [];
314		foreach($aUserFiles as $aUserFile)
315		{
316		$this->aUserFiles[$sVarName][] = UploadedFile::fromTempData($aUserFile);
317		}
318		}
319		// unlink($sUploadTempFile);
320		}
321
322		/**
323		* Return the name of this plugin
324		*
325		* @return string
326		*/
327		public function getName()
328		{
329		return Jaxon::FILE_UPLOAD;
330		}
331
332		/**
333		* Filter uploaded file name
334		*
335		* @param Closure $cFileFilter The closure which filters filenames
336		*
337		* @return void
338		*/
339		public function filter(Closure $cFileFilter)
340		{
341		$this->setFileFilter($cFileFilter);
342		}
343
344		/**
345		* Get the uploaded files
346		*
347		* @return array
348		*/
349		public function files()
350		{
351		return $this->aUserFiles;
352		}
353
354		/**
355		* Generate a hash for the registered browser events
356		*
357		* @return string
358		*/
359		public function generateHash()
360		{
361		return '';
362		}
363
364		/**
365		* Generate client side javascript code for the registered browser events
366		*
367		* @return string
368		*/
369		public function getScript()
370		{
371		return '';
372		}
373
374		/**
375		* Inform this plugin that other plugin can process the current request
376		*
377		* @return void
378		*/
379		public function noRequestPluginFound()
380		{
381		if(count($_FILES) > 0)
382		{
383		$this->bRequestIsHttpUpload = true;
384		}
385		}
386
387		/**
388		* Check if this plugin can process the incoming Jaxon request
389		*
390		* @return boolean
391		*/
392		public function canProcessRequest()
393		{
394		return (count($_FILES) > 0 \|\| ($this->sTempFile));
395		}
396
397		/**
398		* Process the uploaded files into the HTTP request
399		*
400		* @return boolean
401		*/
402		public function processRequest()
403		{
404		if(!$this->canProcessRequest())
405		{
406		return false;
407		}
408
409		if(count($_FILES) > 0)
410		{
411		// Ajax request with upload
412		$this->readFromHttpData();
413
414		if($this->bRequestIsHttpUpload)
415		{
416		// Process an HTTP upload request
417		// This requires to set the response to be returned.
418		$xResponse = new UploadResponse();
419		try
420		{
421		$this->saveToTempFile();
422		$xResponse->setUploadedFile($this->sTempFile);
423		}
424		catch(Exception $e)
425		{
426		$xResponse->setErrorMessage($e->getMessage());
427		}
428		jaxon()->di()->getResponseManager()->append($xResponse);
429		}
430		}
431		elseif(($this->sTempFile))
432		{
433		// Ajax request following and HTTP upload
434		$this->readFromTempFile();
435		}
436
437		return true;
438		}
439		}
440

jaxon-php / jaxon-core