Jaxon\Request\Support\FileUpload

Complexity

Total Complexity

15

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	setNameSanitizer()	0	4	1
A	checkFiles()	0	19	5
A	getUploadedFile()	0	24	3
B	getUploadedFiles()	0	37	6

<?php

/**
 * FileUpload.php - This class handles HTTP file upload.
 *
 * @package jaxon-core

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

 * @author 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\Support;

use Closure;

class FileUpload

Missing doc comment for class FileUpload

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

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

    /**
     * Filter uploaded file name
     *
     * @param Closure       $cNameSanitizer            The closure which filters filenames

Expected 1 spaces after parameter type; 7 found

Expected 1 spaces after parameter name; 12 found

     *
     * @return void
     */
    public function setNameSanitizer(Closure $cNameSanitizer)
    {
        $this->cNameSanitizer = $cNameSanitizer;
    }

    /**
     * Check uploaded files
     *
     * @param array     $aFiles     The uploaded files

Expected 1 spaces after parameter type; 5 found

Expected 1 spaces after parameter name; 5 found

     *
     * @return void
     * @throws \Jaxon\Exception\Error
     */
    private function checkFiles(array $aFiles)
    {
        foreach($aFiles as $sVarName => $aVarFiles)
        {
            foreach($aVarFiles 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 a file from upload entry
     *
     * @param string    $sVarName       The corresponding variable

Expected 2 spaces after parameter type; 4 found

Expected 2 spaces after parameter name; 7 found

     * @param array     $aVarFiles      An entry in the PHP $_FILES array

Expected 3 spaces after parameter type; 5 found

Expected 1 spaces after parameter name; 6 found

     * @param integer   $nPosition      The postion of the file to be processed

Expected 1 spaces after parameter type; 3 found

Expected 1 spaces after parameter name; 6 found

     *
     * @return array|null

Consider making the return type a bit more specific; maybe use null|array.

     */
    private function getUploadedFile($sVarName, array $aVarFiles, $nPosition)
    {
        if(!$aVarFiles['name'][$nPosition])
        {
            return null;
        }

        // Filename without the extension
        $sFilename = pathinfo($aVarFiles['name'][$nPosition], PATHINFO_FILENAME);
        if(($this->cNameSanitizer))
        {
            $sFilename = (string)call_user_func_array($this->cNameSanitizer, [$sFilename, $sVarName]);
        }

        return [
            'name' => $aVarFiles['name'][$nPosition],
            'type' => $aVarFiles['type'][$nPosition],
            'tmp_name' => $aVarFiles['tmp_name'][$nPosition],
            'error' => $aVarFiles['error'][$nPosition],
            'size' => $aVarFiles['size'][$nPosition],
            'filename' => $sFilename,
            'extension' => pathinfo($aVarFiles['name'][$nPosition], PATHINFO_EXTENSION),
        ];
    }

    /**
     * Read uploaded files info from HTTP request data
     *
     * @return array
     */
    public function getUploadedFiles()
    {
        // Check validity of the uploaded files
        $aUploadedFiles = [];
        foreach($_FILES as $sVarName => $aVarFiles)
        {
            // If there is only one file, transform each entry into an array,
            // so the same processing for multiple files can be applied.
            if(!is_array($aVarFiles['name']))
            {
                $aVarFiles['name'] = [$aVarFiles['name']];

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

                $aVarFiles['type'] = [$aVarFiles['type']];

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

                $aVarFiles['tmp_name'] = [$aVarFiles['tmp_name']];
                $aVarFiles['error'] = [$aVarFiles['error']];

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

                $aVarFiles['size'] = [$aVarFiles['size']];

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

            }

            $nFileCount = count($aVarFiles['name']);
            for($i = 0; $i < $nFileCount; $i++)
            {
                $aUploadedFile = $this->getUploadedFile($sVarName, $aVarFiles, $i);
                if(is_array($aUploadedFile))
                {
                    if(!array_key_exists($sVarName, $aUploadedFiles))
                    {
                        $aUploadedFiles[$sVarName] = [];
                    }
                    $aUploadedFiles[$sVarName][] = $aUploadedFile;
                }
            }
        }

        // Check uploaded files validity
        $this->checkFiles($aUploadedFiles);

        return $aUploadedFiles;
    }
}