Upload::sizeFormat() - Code Metrics - Inspection of "4efac2a461f26455d65ceff2837c91b835ce48d4" - tnhfw/tnh-fw - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — 1.0.0-dev (4efac2)

by nguereza

created 2020-02-21 15:22 UTC

Upload::sizeFormat() A

↳ Parent: Upload

Complexity

Conditions	3
Paths	3

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	3
eloc	5
nc	3
nop	2
dl	0
loc	8
rs	10
c	2
b	0
f	0

<?php
    defined('ROOT_PATH') or exit('Access denied');
    /**
     * TNH Framework
     *
     * A simple PHP framework using HMVC architecture
     *
     * This content is released under the GNU GPL License (GPL)
     *
     * Copyright (C) 2017 Tony NGUEREZA
     *
     * This program is free software; you can redistribute it and/or
     * modify it under the terms of the GNU General Public License
     * as published by the Free Software Foundation; either version 3
     * of the License, or (at your option) any later version.
     *
     * This program is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     * GNU General Public License for more details.
     *
     * You should have received a copy of the GNU General Public License
     * along with this program; if not, write to the Free Software
     * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    */



    /**
    *    Upload
    *
    *    A complete class to upload files with php 5 or higher, but the best: very simple to use.
    *
    *    @author Olaf Erlandsen <[email protected]>
    *    @author http://www.webdevfreelance.com/
    *
    *    @package FileUpload
    *    @version 1.5
    */
    class Upload{

        /**
        *   Version
        *
        *   @since      1.5
        *   @version    1.0
        */
        const VERSION = '1.5';

        /**
        *    Upload function name
        *    Remember:
        *        Default function: move_uploaded_file
        *        Native options:
        *            - move_uploaded_file (Default and best option)
        *            - copy
        *
        *    @since        1.0
        *    @version    1.0
        *    @var        string
        */
        private $upload_function = 'move_uploaded_file';

        /**
        *    Array with the information obtained from the
        *    variable $_FILES or $HTTP_POST_FILES.
        *
        *    @since        1.0
        *    @version    1.0
        *    @var        array
        */
        private $file_array    = array();

        /**
        *    If the file you are trying to upload already exists it will
        *    be overwritten if you set the variable to true.
        *
        *    @since        1.0
        *    @version    1.0
        *    @var        boolean
        */
        private $overwrite_file = false;

        /**
        *    Input element
        *    Example:
        *        <input type="file" name="file" />
        *    Result:
        *        FileUpload::$input = file
        *
        *    @since        1.0
        *    @version    1.0
        *    @var        string
        */
        private $input;

        /**
        *    Path output
        *
        *    @since        1.0
        *    @version    1.0
        *    @var        string
        */
        private $destination_directory;

        /**
        *    Output filename
        *
        *    @since        1.0
        *    @version    1.0
        *    @var        string
        */
        private $filename;

        /**
        *    Max file size
        *
        *    @since        1.0
        *    @version    1.0
        *    @var        float
        */
        private $max_file_size= 0.0;

        /**
        *    List of allowed mime types
        *
        *    @since        1.0
        *    @version    1.0
        *    @var        array
        */
        private $allowed_mime_types = array();

        /**
        *    Callbacks
        *
        *    @since        1.0
        *    @version    1.0
        *    @var        array
        */
        private $callbacks = array('before' => null, 'after' => null);

        /**
        *    File object
        *
        *    @since        1.0
        *    @version    1.0
        *    @var        object
        */
        private $file;

        /**
        *    Helping mime types
        *
        *    @since        1.0
        *    @version    1.0
        *    @var        array
        */
        private $mime_helping = array(
            'text'      =>    array('text/plain',),
            'image'     =>    array(
                'image/jpeg',
                'image/jpg',
                'image/pjpeg',
                'image/png',
                'image/gif',
            ),
            'document'  =>    array(
                'application/pdf',
                'application/msword',
                'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
                'application/vnd.openxmlformats-officedocument.presentationml.presentation',
                'application/vnd.ms-powerpoint',
                'application/vnd.ms-excel',
                'application/vnd.oasis.opendocument.spreadsheet',
                'application/vnd.oasis.opendocument.presentation',
            ),
            'video'    =>    array(
                'video/3gpp',
                'video/3gpp',
                'video/x-msvideo',
                'video/avi',
                'video/mpeg4',
                'video/mp4',
                'video/mpeg',
                'video/mpg',
                'video/quicktime',
                'video/x-sgi-movie',
                'video/x-ms-wmv',
                'video/x-flv',
            ),
        );

        /**
         * The upload error message
         * @var array
         */
        public $error_messages = array();

        /**
         * The upload error message
         * @var string
         */
        protected $error = null;

        /**
         * The logger instance
         * @var Log
         */
        private $logger;


        /**
        *    Construct
        *
        *    @since     0.1
        *    @version   1.0.1
        *    @return    object
        *    @method    object    __construct
        */
        public function __construct(){
            $this->logger =& class_loader('Log', 'classes');
            $this->logger->setLogger('Library::Upload');

            Loader::lang('file_upload');
            $obj =& get_instance();

            $this->error_messages = array(
                'upload_err_ini_size' => $obj->lang->get('fu_upload_err_ini_size'),
                'upload_err_form_size' => $obj->lang->get('fu_upload_err_form_size'),
                'upload_err_partial' => $obj->lang->get('fu_upload_err_partial'),
                'upload_err_no_file' => $obj->lang->get('fu_upload_err_no_file'),
                'upload_err_no_tmp_dir' => $obj->lang->get('fu_upload_err_no_tmp_dir'),
                'upload_err_cant_write' => $obj->lang->get('fu_upload_err_cant_write'),
                'upload_err_extension' => $obj->lang->get('fu_upload_err_extension'),
                'accept_file_types' => $obj->lang->get('fu_accept_file_types'),
                'file_uploads' => $obj->lang->get('fu_file_uploads_disabled'),
                'max_file_size' => $obj->lang->get('fu_max_file_size'),
                'overwritten_not_allowed' => $obj->lang->get('fu_overwritten_not_allowed'),
            );

            $this->file = array(
                'status'                =>    false,    // True: success upload
                'mime'                  =>    '',       // Empty string
                'filename'              =>    '',       // Empty string
                'original'              =>    '',       // Empty string
                'size'                  =>    0,        // 0 Bytes
                'sizeFormated'          =>    '0B',     // 0 Bytes
                'destination'           =>    './',     // Default: ./
                'allowed_mime_types'    =>    array(),  // Allowed mime types
                'error'                 =>    null,        // File error
            );

            // Change dir to current dir
            $this->destination_directory = dirname(__FILE__) . DIRECTORY_SEPARATOR;

            // Set file array
            if (isset($_FILES) && is_array($_FILES)) {
                $this->file_array = $_FILES;
            }
            $this->logger->info('The upload file information are : ' .stringfy_vars($this->file_array));
        }
        /**
        *    Set input.
        *    If you have $_FILES["file"], you must use the key "file"
        *    Example:
        *        $object->setInput("file");
        *
        *    @since     1.0
        *    @version   1.0
        *    @param     string      $input
        *    @return    object
        *    @method    boolean     setInput
        */
        public function setInput($input)
        {
            if (!empty($input) && (is_string($input) || is_numeric($input) )) {
                $this->input = $input;
            }
            return $this;
        }
        /**
        *    Set new filename
        *    Example:
        *        FileUpload::setFilename("new file.txt")
        *    Remember:
        *        Use %s to retrive file extension
        *
        *    @since     1.0
        *    @version   1.0
        *    @param     string      $filename
        *    @return    object
        *    @method    boolean     setFilename
        */
        public function setFilename($filename)
        {
            if ($this->isFilename($filename)) {
                $this->filename = $filename;
            }
            return $this;
        }
        /**
        *    Set automatic filename
        *
        *    @since     1.0
        *    @version   1.5
        *    @param     string      $extension
        *    @return    object
        *    @method    boolean     setAutoFilename
        */
        public function setAutoFilename()
        {
            $this->filename = sha1(mt_rand(1, 9999).uniqid());
            $this->filename .= time();
            return $this;
        }
        /**
        *    Set file size limit
        *
        *    @since     1.0
        *    @version   1.0
        *    @param     double     $file_size
        *    @return    object
        *    @method    boolean     setMaxFileSize
        */
        public function setMaxFileSize($file_size)
        {
            $file_size = $this->sizeInBytes($file_size);
            if (is_numeric($file_size) && $file_size > -1) {
                // Get php config
                $php_size = $this->sizeInBytes((int) ini_get('upload_max_filesize'));
                // Calculate difference
                if ($php_size < $file_size) {
                    $this->logger->warning('The upload max file size you set [' .$file_size. '] is greather than the PHP configuration for upload max file size [' .$php_size. ']');
                }
                $this->max_file_size = $file_size;
            }
            return $this;
        }
        /**
        *    Set array mime types
        *
        *    @since     1.0
        *    @version   1.0
        *    @param     array       $mimes
        *    @return    object
        *    @method    boolean     setAllowedMimeTypes
        */
        public function setAllowedMimeTypes(array $mimes)
        {
            if (count($mimes) > 0) {
                array_map(array($this , 'setAllowMimeType'), $mimes);
            }
            return $this;
        }
        /**
        *    Set input callback
        *
        *    @since     1.0
        *    @version   1.0
        *    @param     mixed       $callback
        *    @return    object
        *    @method    boolean     setCallbackInput
        */
        public function setCallbackInput($callback)
        {
            if (is_callable($callback, false)) {
                $this->callbacks['input'] = $callback;
            }
            return $this;
        }
        /**
        *    Set output callback
        *
        *    @since     1.0
        *    @version   1.0
        *    @param     mixed       $callback
        *    @return    object
        *    @method    boolean     setCallbackOutput
        */
        public function setCallbackOutput($callback)
        {
            if (is_callable($callback, false)) {
                $this->callbacks['output'] = $callback;
            }
            return $this;
        }
        /**
        *    Append a mime type to allowed mime types
        *
        *    @since     1.0
        *    @version   1.0.1
        *    @param     string      $mime
        *    @return    object
        *    @method    boolean     setAllowMimeType
        */
        public function setAllowMimeType($mime)
        {
            if (!empty($mime) && is_string($mime)) {
                $this->allowed_mime_types[] = strtolower($mime);
                $this->file['allowed_mime_types'][] = strtolower($mime);
            } 
            return $this;
        }
        /**
        *    Set allowed mime types from mime helping
        *
        *    @since     1.0.1
        *    @version   1.0.1
        *    @return    object
        *    @method    boolean    setMimeHelping
        */
        public function setMimeHelping($name)
        {
            if (!empty($name) && is_string($name)) {
                if (array_key_exists($name, $this->mime_helping)) {
                    return $this->setAllowedMimeTypes($this->mime_helping[ $name ]);
                }
            }
            return $this;
        }
        /**
        *    Set function to upload file
        *    Examples:
        *        1.- FileUpload::setUploadFunction("move_uploaded_file");
        *        2.- FileUpload::setUploadFunction("copy");
        *
        *    @since     1.0
        *    @version   1.0
        *    @param     string      $function
        *    @return    object
        *    @method    boolean     setUploadFunction
        */
        public function setUploadFunction($function)
        {
            if (!empty($function) && (is_array($function) || is_string($function) )) {
                if (is_callable( $function)) {
                    $this->upload_function = $function;
                }
            }
            return $this;
        }
        /**
        *    Clear allowed mime types cache
        *
        *    @since     1.0
        *    @version   1.0
        *    @return    object
        *    @method    boolean    clearAllowedMimeTypes
        */
        public function clearAllowedMimeTypes()
        {
            $this->allowed_mime_types = array();
            $this->file['allowed_mime_types'] = array();
            return $this;
        }
        /**
        *    Set destination output
        *
        *    @since     1.0
        *    @version   1.0
        *    @param     string      $destination_directory      Destination path
        *    @param     boolean     $create_if_not_exist
        *    @return    object
        *    @method    boolean     setDestinationDirectory
        */
        public function setDestinationDirectory($destination_directory, $create_if_not_exist = false) {
            $destination_directory = realpath($destination_directory);
            if (substr($destination_directory, -1) != DIRECTORY_SEPARATOR) {
                $destination_directory .= DIRECTORY_SEPARATOR;
            }

            if ($this->isDirpath($destination_directory)) {
                if ($this->dirExists($destination_directory)) {
                    $this->destination_directory = $destination_directory;
                    chdir($destination_directory);
                } else if ($create_if_not_exist === true) {
                    if (mkdir($destination_directory, 0775, true)) {
                        $this->destination_directory = $destination_directory;
                        chdir($destination_directory);
                    }
                    else{
                        $this->logger->warning('Can not create the upload directory [' .$destination_directory. ']');
                    }
                }
            }
            return $this;
        }
        /**
        *    Check file exists
        *
        *    @since      1.0
        *    @version    1.0.1
        *    @param      string     $file_destination
        *    @return     boolean
        *    @method     boolean    fileExists
        */
        public function fileExists($file_destination)
        {
            if ($this->isFilename($file_destination)) {
                return (file_exists($file_destination) && is_file($file_destination));
            }
            return false;
        }
        /**
        *    Check dir exists
        *
        *    @since        1.0
        *    @version    1.0.1
        *    @param      string     $path
        *    @return     boolean
        *    @method     boolean    dirExists
        */
        public function dirExists($path)
        {
            if ($this->isDirpath($path)) {
                return (file_exists($path) && is_dir($path));
            }
            return false;
        }
        /**
        *    Check valid filename
        *
        *    @since     1.0
        *    @version   1.0.1
        *    @param     string      $filename
        *    @return    boolean
        *    @method    boolean     isFilename
        */
        public function isFilename($filename)
        {
            $filename = basename($filename);
            return (!empty($filename) && (is_string( $filename) || is_numeric($filename)));
        }
        /**
        *    Validate mime type with allowed mime types,
        *    but if allowed mime types is empty, this method return true
        *
        *    @since     1.0
        *    @version   1.0
        *    @param     string      $mime
        *    @return    boolean
        *    @method    boolean     checkMimeType
        */
        public function checkMimeType($mime)
        {
            if (count($this->allowed_mime_types) == 0) {
                return true;
            }
            return in_array(strtolower($mime), $this->allowed_mime_types);
        }
        /**
        *    Retrive status of upload
        *
        *    @since     1.0
        *    @version   1.0
        *    @return    boolean
        *    @method    boolean    getStatus
        */
        public function getStatus()
        {
            return $this->file['status'];
        }
        /**
        *    Check valid path
        *
        *    @since        1.0
        *    @version    1.0.1
        *    @param        string    $filename
        *    @return     boolean
        *    @method     boolean    isDirpath
        */
        public function isDirpath($path)
        {
            if (!empty( $path) && (is_string( $path) || is_numeric($path) )) {
                if (DIRECTORY_SEPARATOR == '/') {
                    return (preg_match( '/^[^*?"<>|:]*$/' , $path) == 1 );
                } else {
                    return (preg_match( "/^[^*?\"<>|:]*$/" , substr($path,2) ) == 1);
                }
            }
            return false;
        }
        /**
        *    Allow overwriting files
        *
        *    @since      1.0
        *    @version    1.0
        *    @return     object
        *    @method     boolean    allowOverwriting
        */
        public function allowOverwriting()
        {
            $this->overwrite_file = true;
            return $this;
        }
        /**
        *    File info
        *
        *    @since      1.0
        *    @version    1.0
        *    @return     object
        *    @method     object    getInfo
        */
        public function getInfo()
        {
            return (object)$this->file;
        }


        /**
         * Check if the file is uploaded
         * @return boolean
         */
        public function isUploaded(){
            return isset($this->file_array[$this->input])
            && is_uploaded_file($this->file_array[$this->input]['tmp_name']);
        }

        
        /**
        *    Upload file
        *
        *    @since     1.0
        *    @version   1.0.1
        *    @return    boolean
        *    @method    boolean    save
        */
        public function save(){
            if (count($this->file_array) > 0 && array_key_exists($this->input, $this->file_array)) {
                // set original filename if not have a new name
                if (empty($this->filename)) {
                    $this->filename = $this->file_array[$this->input]['name'];
                }
                else{
                    // Replace %s for extension in filename
                    // Before: /[\w\d]*(.[\d\w]+)$/i
                    // After: /^[\s[:alnum:]\-\_\.]*\.([\d\w]+)$/iu
                    // Support unicode(utf-8) characters
                    // Example: "русские.jpeg" is valid; "Zhōngguó.jpeg" is valid; "Tønsberg.jpeg" is valid
                    $extension = preg_replace(
                        '/^[\p{L}\d\s\-\_\.\(\)]*\.([\d\w]+)$/iu',
                        '$1',
                        $this->file_array[$this->input]['name']
                    );
                    $this->filename = $this->filename . '.' . $extension;
                }

                // set file info
                $this->file['mime']         = $this->file_array[$this->input]['type'];
                $this->file['tmp']          = $this->file_array[$this->input]['tmp_name'];
                $this->file['original']     = $this->file_array[$this->input]['name'];
                $this->file['size']         = $this->file_array[$this->input]['size'];
                $this->file['sizeFormated'] = $this->sizeFormat($this->file['size']);
                $this->file['destination']  = $this->destination_directory . $this->filename;
                $this->file['filename']     = $this->filename;
                $this->file['error']        = $this->file_array[$this->input]['error'];

                $this->logger->info('The upload file information to process is : ' .stringfy_vars($this->file));

                $error = $this->uploadHasError();
                if($error){
                    return false;
                }
                // Execute input callback
                $this->runCallback('input');

                $this->file['status'] = call_user_func_array(
                    $this->upload_function, array(
                        $this->file_array[$this->input]['tmp_name'],
                        $this->destination_directory . $this->filename
                    )
                );

                // Execute output callback
                $this->runCallback('output');

                return $this->file['status'];
            }
            return false;
        }


        /**
        *    File size for humans.
        *
        *    @since      1.0
        *    @version    1.0
        *    @param      integer    $bytes
        *    @param      integer    $precision
        *    @return     string
        *    @method     string     sizeFormat
        */
        public function sizeFormat($size, $precision = 2)
        {
            if($size > 0){
                $base       = log($size) / log(1024);
                $suffixes   = array('B', 'K', 'M', 'G', 'T');
                return round(pow(1024, $base - floor($base)), $precision) . ( isset($suffixes[floor($base)]) ? $suffixes[floor($base)] : '');
            }
            return null;
        }

        
        /**
        *    Convert human file size to bytes
        *
        *    @since      1.0
        *    @version    1.0.1
        *    @param      integer|double    $size
        *    @return     integer|double
        *    @method     string     sizeInBytes
        */
        public function sizeInBytes($size)
        {
            $unit = 'B';
            $units = array('B' => 0, 'K' => 1, 'M' => 2, 'G' => 3, 'T' => 4);
            $matches = array();
            preg_match('/(?<size>[\d\.]+)\s*(?<unit>b|k|m|g|t)?/i', $size, $matches);
            if (array_key_exists('unit', $matches)) {
                $unit = strtoupper($matches['unit']);
            }
            return (floatval($matches['size']) * pow(1024, $units[$unit]) ) ;
        }

        /**
         * Get the upload error message
         * @return string
         */
        public function getError(){
            return $this->error;
        }

        /**
         * Set the upload error message
         * @param string $message the upload error message to set
         */
        public function setError($message){
            $this->logger->info('The file upload got error : ' . $message);
            $this->error = $message;
        }

        /**
         * Run the callbacks in the file uploaded
         * @param string $type the type of callback "input" or "output"
         * @return void 
         */
        protected function runCallback($type){
            if (!empty( $this->callbacks[$type])) {
                call_user_func($this->callbacks[$type], (object)$this->file);
            }
        }

        /**
         * Check if file upload has error
         * @return boolean
         */
        protected function uploadHasError(){
            //check if file upload is  allowed in the configuration
            if(! ini_get('file_uploads')){
                $this->setError($this->error_messages['file_uploads']);
                return true;
            }

             //check for php upload error
            if(is_numeric($this->file['error']) && $this->file['error'] > 0){
                $this->setError($this->getPhpUploadErrorMessageByCode($this->file['error']));
                return true;
            }
            
            //check for mime type
            if (! $this->checkMimeType($this->file['mime'])) {
                $this->setError($this->error_messages['accept_file_types']);
                return true;
            }

             // Check file size
            if ($this->max_file_size > 0 && $this->max_file_size < $this->file['size']) {
                $this->setError(sprintf($this->error_messages['max_file_size'], $this->sizeFormat($this->max_file_size)));
                return true;
            }

            // Check if exists file
            if ($this->fileExists($this->destination_directory . $this->filename) && $this->overwrite_file === false) {
                $this->setError($this->error_messages['overwritten_not_allowed']);
                return true;
            }
            return false;
        }

        /**
         * Get the PHP upload error message for the given code
         * @param  int $code the error code
         * @return string the error message
         */
        private function getPhpUploadErrorMessageByCode($code){
            $codeMessageMaps = array(
                1 => $this->error_messages['upload_err_ini_size'],
                2 => $this->error_messages['upload_err_form_size'],
                3 => $this->error_messages['upload_err_partial'],
                4 => $this->error_messages['upload_err_no_file'],
                6 => $this->error_messages['upload_err_no_tmp_dir'],
                7 => $this->error_messages['upload_err_cant_write'],
                8 => $this->error_messages['upload_err_extension'],
            );
            return isset($codeMessageMaps[$code]) ? $codeMessageMaps[$code] : null;
        }
    }


1			<?php
2			defined('ROOT_PATH') or exit('Access denied');
3			/**
4			* TNH Framework
5			*
6			* A simple PHP framework using HMVC architecture
7			*
8			* This content is released under the GNU GPL License (GPL)
9			*
10			* Copyright (C) 2017 Tony NGUEREZA
11			*
12			* This program is free software; you can redistribute it and/or
13			* modify it under the terms of the GNU General Public License
14			* as published by the Free Software Foundation; either version 3
15			* of the License, or (at your option) any later version.
16			*
17			* This program is distributed in the hope that it will be useful,
18			* but WITHOUT ANY WARRANTY; without even the implied warranty of
19			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20			* GNU General Public License for more details.
21			*
22			* You should have received a copy of the GNU General Public License
23			* along with this program; if not, write to the Free Software
24			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25			*/
26
27
28
29			/**
30			* Upload
31			*
32			* A complete class to upload files with php 5 or higher, but the best: very simple to use.
33			*
34			* @author Olaf Erlandsen <[email protected]>
35			* @author http://www.webdevfreelance.com/
36			*
37			* @package FileUpload
38			* @version 1.5
39			*/
40			class Upload{
41
42			/**
43			* Version
44			*
45			* @since 1.5
46			* @version 1.0
47			*/
48			const VERSION = '1.5';
49
50			/**
51			* Upload function name
52			* Remember:
53			* Default function: move_uploaded_file
54			* Native options:
55			* - move_uploaded_file (Default and best option)
56			* - copy
57			*
58			* @since 1.0
59			* @version 1.0
60			* @var string
61			*/
62			private $upload_function = 'move_uploaded_file';
63
64			/**
65			* Array with the information obtained from the
66			* variable $_FILES or $HTTP_POST_FILES.
67			*
68			* @since 1.0
69			* @version 1.0
70			* @var array
71			*/
72			private $file_array = array();
73
74			/**
75			* If the file you are trying to upload already exists it will
76			* be overwritten if you set the variable to true.
77			*
78			* @since 1.0
79			* @version 1.0
80			* @var boolean
81			*/
82			private $overwrite_file = false;
83
84			/**
85			* Input element
86			* Example:
87			* <input type="file" name="file" />
88			* Result:
89			* FileUpload::$input = file
90			*
91			* @since 1.0
92			* @version 1.0
93			* @var string
94			*/
95			private $input;
96
97			/**
98			* Path output
99			*
100			* @since 1.0
101			* @version 1.0
102			* @var string
103			*/
104			private $destination_directory;
105
106			/**
107			* Output filename
108			*
109			* @since 1.0
110			* @version 1.0
111			* @var string
112			*/
113			private $filename;
114
115			/**
116			* Max file size
117			*
118			* @since 1.0
119			* @version 1.0
120			* @var float
121			*/
122			private $max_file_size= 0.0;
123
124			/**
125			* List of allowed mime types
126			*
127			* @since 1.0
128			* @version 1.0
129			* @var array
130			*/
131			private $allowed_mime_types = array();
132
133			/**
134			* Callbacks
135			*
136			* @since 1.0
137			* @version 1.0
138			* @var array
139			*/
140			private $callbacks = array('before' => null, 'after' => null);
141
142			/**
143			* File object
144			*
145			* @since 1.0
146			* @version 1.0
147			* @var object
148			*/
149			private $file;
150
151			/**
152			* Helping mime types
153			*
154			* @since 1.0
155			* @version 1.0
156			* @var array
157			*/
158			private $mime_helping = array(
159			'text' => array('text/plain',),
160			'image' => array(
161			'image/jpeg',
162			'image/jpg',
163			'image/pjpeg',
164			'image/png',
165			'image/gif',
166			),
167			'document' => array(
168			'application/pdf',
169			'application/msword',
170			'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
171			'application/vnd.openxmlformats-officedocument.presentationml.presentation',
172			'application/vnd.ms-powerpoint',
173			'application/vnd.ms-excel',
174			'application/vnd.oasis.opendocument.spreadsheet',
175			'application/vnd.oasis.opendocument.presentation',
176			),
177			'video' => array(
178			'video/3gpp',
179			'video/3gpp',
180			'video/x-msvideo',
181			'video/avi',
182			'video/mpeg4',
183			'video/mp4',
184			'video/mpeg',
185			'video/mpg',
186			'video/quicktime',
187			'video/x-sgi-movie',
188			'video/x-ms-wmv',
189			'video/x-flv',
190			),
191			);
192
193			/**
194			* The upload error message
195			* @var array
196			*/
197			public $error_messages = array();
198
199			/**
200			* The upload error message
201			* @var string
202			*/
203			protected $error = null;
204
205			/**
206			* The logger instance
207			* @var Log
208			*/
209			private $logger;
210
211
212			/**
213			* Construct
214			*
215			* @since 0.1
216			* @version 1.0.1
217			* @return object
218			* @method object __construct
219			*/
220			public function __construct(){
221			$this->logger =& class_loader('Log', 'classes');
222			$this->logger->setLogger('Library::Upload');
223
224			Loader::lang('file_upload');
225			$obj =& get_instance();
226
227			$this->error_messages = array(
228			'upload_err_ini_size' => $obj->lang->get('fu_upload_err_ini_size'),
229			'upload_err_form_size' => $obj->lang->get('fu_upload_err_form_size'),
230			'upload_err_partial' => $obj->lang->get('fu_upload_err_partial'),
231			'upload_err_no_file' => $obj->lang->get('fu_upload_err_no_file'),
232			'upload_err_no_tmp_dir' => $obj->lang->get('fu_upload_err_no_tmp_dir'),
233			'upload_err_cant_write' => $obj->lang->get('fu_upload_err_cant_write'),
234			'upload_err_extension' => $obj->lang->get('fu_upload_err_extension'),
235			'accept_file_types' => $obj->lang->get('fu_accept_file_types'),
236			'file_uploads' => $obj->lang->get('fu_file_uploads_disabled'),
237			'max_file_size' => $obj->lang->get('fu_max_file_size'),
238			'overwritten_not_allowed' => $obj->lang->get('fu_overwritten_not_allowed'),
239			);
240
241			$this->file = array(
242			'status' => false, // True: success upload
243			'mime' => '', // Empty string
244			'filename' => '', // Empty string
245			'original' => '', // Empty string
246			'size' => 0, // 0 Bytes
247			'sizeFormated' => '0B', // 0 Bytes
248			'destination' => './', // Default: ./
249			'allowed_mime_types' => array(), // Allowed mime types
250			'error' => null, // File error
251			);
252
253			// Change dir to current dir
254			$this->destination_directory = dirname(__FILE__) . DIRECTORY_SEPARATOR;
255
256			// Set file array
257			if (isset($_FILES) && is_array($_FILES)) {
258			$this->file_array = $_FILES;
259			}
260			$this->logger->info('The upload file information are : ' .stringfy_vars($this->file_array));
261			}
262			/**
263			* Set input.
264			* If you have $_FILES["file"], you must use the key "file"
265			* Example:
266			* $object->setInput("file");
267			*
268			* @since 1.0
269			* @version 1.0
270			* @param string $input
271			* @return object
272			* @method boolean setInput
273			*/
274			public function setInput($input)
275			{
276			if (!empty($input) && (is_string($input) \|\| is_numeric($input) )) {
277			$this->input = $input;
278			}
279			return $this;
280			}
281			/**
282			* Set new filename
283			* Example:
284			* FileUpload::setFilename("new file.txt")
285			* Remember:
286			* Use %s to retrive file extension
287			*
288			* @since 1.0
289			* @version 1.0
290			* @param string $filename
291			* @return object
292			* @method boolean setFilename
293			*/
294			public function setFilename($filename)
295			{
296			if ($this->isFilename($filename)) {
297			$this->filename = $filename;
298			}
299			return $this;
300			}
301			/**
302			* Set automatic filename
303			*
304			* @since 1.0
305			* @version 1.5
306			* @param string $extension
307			* @return object
308			* @method boolean setAutoFilename
309			*/
310			public function setAutoFilename()
311			{
312			$this->filename = sha1(mt_rand(1, 9999).uniqid());
313			$this->filename .= time();
314			return $this;
315			}
316			/**
317			* Set file size limit
318			*
319			* @since 1.0
320			* @version 1.0
321			* @param double $file_size
322			* @return object
323			* @method boolean setMaxFileSize
324			*/
325			public function setMaxFileSize($file_size)
326			{
327			$file_size = $this->sizeInBytes($file_size);
328			if (is_numeric($file_size) && $file_size > -1) {
329			// Get php config
330			$php_size = $this->sizeInBytes((int) ini_get('upload_max_filesize'));
331			// Calculate difference
332			if ($php_size < $file_size) {
333			$this->logger->warning('The upload max file size you set [' .$file_size. '] is greather than the PHP configuration for upload max file size [' .$php_size. ']');
334			}
335			$this->max_file_size = $file_size;
336			}
337			return $this;
338			}
339			/**
340			* Set array mime types
341			*
342			* @since 1.0
343			* @version 1.0
344			* @param array $mimes
345			* @return object
346			* @method boolean setAllowedMimeTypes
347			*/
348			public function setAllowedMimeTypes(array $mimes)
349			{
350			if (count($mimes) > 0) {
351			array_map(array($this , 'setAllowMimeType'), $mimes);
352			}
353			return $this;
354			}
355			/**
356			* Set input callback
357			*
358			* @since 1.0
359			* @version 1.0
360			* @param mixed $callback
361			* @return object
362			* @method boolean setCallbackInput
363			*/
364			public function setCallbackInput($callback)
365			{
366			if (is_callable($callback, false)) {
367			$this->callbacks['input'] = $callback;
368			}
369			return $this;
370			}
371			/**
372			* Set output callback
373			*
374			* @since 1.0
375			* @version 1.0
376			* @param mixed $callback
377			* @return object
378			* @method boolean setCallbackOutput
379			*/
380			public function setCallbackOutput($callback)
381			{
382			if (is_callable($callback, false)) {
383			$this->callbacks['output'] = $callback;
384			}
385			return $this;
386			}
387			/**
388			* Append a mime type to allowed mime types
389			*
390			* @since 1.0
391			* @version 1.0.1
392			* @param string $mime
393			* @return object
394			* @method boolean setAllowMimeType
395			*/
396			public function setAllowMimeType($mime)
397			{
398			if (!empty($mime) && is_string($mime)) {
399			$this->allowed_mime_types[] = strtolower($mime);
400			$this->file['allowed_mime_types'][] = strtolower($mime);
401			}
402			return $this;
403			}
404			/**
405			* Set allowed mime types from mime helping
406			*
407			* @since 1.0.1
408			* @version 1.0.1
409			* @return object
410			* @method boolean setMimeHelping
411			*/
412			public function setMimeHelping($name)
413			{
414			if (!empty($name) && is_string($name)) {
415			if (array_key_exists($name, $this->mime_helping)) {
416			return $this->setAllowedMimeTypes($this->mime_helping[ $name ]);
417			}
418			}
419			return $this;
420			}
421			/**
422			* Set function to upload file
423			* Examples:
424			* 1.- FileUpload::setUploadFunction("move_uploaded_file");
425			* 2.- FileUpload::setUploadFunction("copy");
426			*
427			* @since 1.0
428			* @version 1.0
429			* @param string $function
430			* @return object
431			* @method boolean setUploadFunction
432			*/
433			public function setUploadFunction($function)
434			{
435			if (!empty($function) && (is_array($function) \|\| is_string($function) )) {
436			if (is_callable( $function)) {
437			$this->upload_function = $function;
438			}
439			}
440			return $this;
441			}
442			/**
443			* Clear allowed mime types cache
444			*
445			* @since 1.0
446			* @version 1.0
447			* @return object
448			* @method boolean clearAllowedMimeTypes
449			*/
450			public function clearAllowedMimeTypes()
451			{
452			$this->allowed_mime_types = array();
453			$this->file['allowed_mime_types'] = array();
454			return $this;
455			}
456			/**
457			* Set destination output
458			*
459			* @since 1.0
460			* @version 1.0
461			* @param string $destination_directory Destination path
462			* @param boolean $create_if_not_exist
463			* @return object
464			* @method boolean setDestinationDirectory
465			*/
466			public function setDestinationDirectory($destination_directory, $create_if_not_exist = false) {
467			$destination_directory = realpath($destination_directory);
468			if (substr($destination_directory, -1) != DIRECTORY_SEPARATOR) {
469			$destination_directory .= DIRECTORY_SEPARATOR;
470			}
471
472			if ($this->isDirpath($destination_directory)) {
473			if ($this->dirExists($destination_directory)) {
474			$this->destination_directory = $destination_directory;
475			chdir($destination_directory);
476			} else if ($create_if_not_exist === true) {
477			if (mkdir($destination_directory, 0775, true)) {
478			$this->destination_directory = $destination_directory;
479			chdir($destination_directory);
480			}
481			else{
482			$this->logger->warning('Can not create the upload directory [' .$destination_directory. ']');
483			}
484			}
485			}
486			return $this;
487			}
488			/**
489			* Check file exists
490			*
491			* @since 1.0
492			* @version 1.0.1
493			* @param string $file_destination
494			* @return boolean
495			* @method boolean fileExists
496			*/
497			public function fileExists($file_destination)
498			{
499			if ($this->isFilename($file_destination)) {
500			return (file_exists($file_destination) && is_file($file_destination));
501			}
502			return false;
503			}
504			/**
505			* Check dir exists
506			*
507			* @since 1.0
508			* @version 1.0.1
509			* @param string $path
510			* @return boolean
511			* @method boolean dirExists
512			*/
513			public function dirExists($path)
514			{
515			if ($this->isDirpath($path)) {
516			return (file_exists($path) && is_dir($path));
517			}
518			return false;
519			}
520			/**
521			* Check valid filename
522			*
523			* @since 1.0
524			* @version 1.0.1
525			* @param string $filename
526			* @return boolean
527			* @method boolean isFilename
528			*/
529			public function isFilename($filename)
530			{
531			$filename = basename($filename);
532			return (!empty($filename) && (is_string( $filename) \|\| is_numeric($filename)));
533			}
534			/**
535			* Validate mime type with allowed mime types,
536			* but if allowed mime types is empty, this method return true
537			*
538			* @since 1.0
539			* @version 1.0
540			* @param string $mime
541			* @return boolean
542			* @method boolean checkMimeType
543			*/
544			public function checkMimeType($mime)
545			{
546			if (count($this->allowed_mime_types) == 0) {
547			return true;
548			}
549			return in_array(strtolower($mime), $this->allowed_mime_types);
550			}
551			/**
552			* Retrive status of upload
553			*
554			* @since 1.0
555			* @version 1.0
556			* @return boolean
557			* @method boolean getStatus
558			*/
559			public function getStatus()
560			{
561			return $this->file['status'];
562			}
563			/**
564			* Check valid path
565			*
566			* @since 1.0
567			* @version 1.0.1
568			* @param string $filename
569			* @return boolean
570			* @method boolean isDirpath
571			*/
572			public function isDirpath($path)
573			{
574			if (!empty( $path) && (is_string( $path) \|\| is_numeric($path) )) {
575			if (DIRECTORY_SEPARATOR == '/') {
576			return (preg_match( '/^[^?"<>\|:]$/' , $path) == 1 );
577			} else {
578			return (preg_match( "/^[^?\"<>\|:]$/" , substr($path,2) ) == 1);
579			}
580			}
581			return false;
582			}
583			/**
584			* Allow overwriting files
585			*
586			* @since 1.0
587			* @version 1.0
588			* @return object
589			* @method boolean allowOverwriting
590			*/
591			public function allowOverwriting()
592			{
593			$this->overwrite_file = true;
594			return $this;
595			}
596			/**
597			* File info
598			*
599			* @since 1.0
600			* @version 1.0
601			* @return object
602			* @method object getInfo
603			*/
604			public function getInfo()
605			{
606			return (object)$this->file;
607			}
608
609
610			/**
611			* Check if the file is uploaded
612			* @return boolean
613			*/
614			public function isUploaded(){
615			return isset($this->file_array[$this->input])
616			&& is_uploaded_file($this->file_array[$this->input]['tmp_name']);
617			}
618
619
620			/**
621			* Upload file
622			*
623			* @since 1.0
624			* @version 1.0.1
625			* @return boolean
626			* @method boolean save
627			*/
628			public function save(){
629			if (count($this->file_array) > 0 && array_key_exists($this->input, $this->file_array)) {
630			// set original filename if not have a new name
631			if (empty($this->filename)) {
632			$this->filename = $this->file_array[$this->input]['name'];
633			}
634			else{
635			// Replace %s for extension in filename
636			// Before: /[\w\d]*(.[\d\w]+)$/i
637			// After: /^[\s[:alnum:]\-\_\.]*\.([\d\w]+)$/iu
638			// Support unicode(utf-8) characters
639			// Example: "русские.jpeg" is valid; "Zhōngguó.jpeg" is valid; "Tønsberg.jpeg" is valid
640			$extension = preg_replace(
641			'/^[\p{L}\d\s\-\_\.\(\)]*\.([\d\w]+)$/iu',
642			'$1',
643			$this->file_array[$this->input]['name']
644			);
645			$this->filename = $this->filename . '.' . $extension;
646			}
647
648			// set file info
649			$this->file['mime'] = $this->file_array[$this->input]['type'];
650			$this->file['tmp'] = $this->file_array[$this->input]['tmp_name'];
651			$this->file['original'] = $this->file_array[$this->input]['name'];
652			$this->file['size'] = $this->file_array[$this->input]['size'];
653			$this->file['sizeFormated'] = $this->sizeFormat($this->file['size']);
654			$this->file['destination'] = $this->destination_directory . $this->filename;
655			$this->file['filename'] = $this->filename;
656			$this->file['error'] = $this->file_array[$this->input]['error'];
657
658			$this->logger->info('The upload file information to process is : ' .stringfy_vars($this->file));
659
660			$error = $this->uploadHasError();
661			if($error){
662			return false;
663			}
664			// Execute input callback
665			$this->runCallback('input');
666
667			$this->file['status'] = call_user_func_array(
668			$this->upload_function, array(
669			$this->file_array[$this->input]['tmp_name'],
670			$this->destination_directory . $this->filename
671			)
672			);
673
674			// Execute output callback
675			$this->runCallback('output');
676
677			return $this->file['status'];
678			}
679			return false;
680			}
681
682
683			/**
684			* File size for humans.
685			*
686			* @since 1.0
687			* @version 1.0
688			* @param integer $bytes
689			* @param integer $precision
690			* @return string
691			* @method string sizeFormat
692			*/
693			public function sizeFormat($size, $precision = 2)
694			{
695			if($size > 0){
696			$base = log($size) / log(1024);
697			$suffixes = array('B', 'K', 'M', 'G', 'T');
698			return round(pow(1024, $base - floor($base)), $precision) . ( isset($suffixes[floor($base)]) ? $suffixes[floor($base)] : '');
699			}
700			return null;
701			}
702
703
704			/**
705			* Convert human file size to bytes
706			*
707			* @since 1.0
708			* @version 1.0.1
709			* @param integer\|double $size
710			* @return integer\|double
711			* @method string sizeInBytes
712			*/
713			public function sizeInBytes($size)
714			{
715			$unit = 'B';
716			$units = array('B' => 0, 'K' => 1, 'M' => 2, 'G' => 3, 'T' => 4);
717			$matches = array();
718			preg_match('/(?<size>[\d\.]+)\s*(?<unit>b\|k\|m\|g\|t)?/i', $size, $matches);
719			if (array_key_exists('unit', $matches)) {
720			$unit = strtoupper($matches['unit']);
721			}
722			return (floatval($matches['size']) * pow(1024, $units[$unit]) ) ;
723			}
724
725			/**
726			* Get the upload error message
727			* @return string
728			*/
729			public function getError(){
730			return $this->error;
731			}
732
733			/**
734			* Set the upload error message
735			* @param string $message the upload error message to set
736			*/
737			public function setError($message){
738			$this->logger->info('The file upload got error : ' . $message);
739			$this->error = $message;
740			}
741
742			/**
743			* Run the callbacks in the file uploaded
744			* @param string $type the type of callback "input" or "output"
745			* @return void
746			*/
747			protected function runCallback($type){
748			if (!empty( $this->callbacks[$type])) {
749			call_user_func($this->callbacks[$type], (object)$this->file);
750			}
751			}
752
753			/**
754			* Check if file upload has error
755			* @return boolean
756			*/
757			protected function uploadHasError(){
758			//check if file upload is allowed in the configuration
759			if(! ini_get('file_uploads')){
760			$this->setError($this->error_messages['file_uploads']);
761			return true;
762			}
763
764			//check for php upload error
765			if(is_numeric($this->file['error']) && $this->file['error'] > 0){
766			$this->setError($this->getPhpUploadErrorMessageByCode($this->file['error']));
767			return true;
768			}
769
770			//check for mime type
771			if (! $this->checkMimeType($this->file['mime'])) {
772			$this->setError($this->error_messages['accept_file_types']);
773			return true;
774			}
775
776			// Check file size
777			if ($this->max_file_size > 0 && $this->max_file_size < $this->file['size']) {
778			$this->setError(sprintf($this->error_messages['max_file_size'], $this->sizeFormat($this->max_file_size)));
779			return true;
780			}
781
782			// Check if exists file
783			if ($this->fileExists($this->destination_directory . $this->filename) && $this->overwrite_file === false) {
784			$this->setError($this->error_messages['overwritten_not_allowed']);
785			return true;
786			}
787			return false;
788			}
789
790			/**
791			* Get the PHP upload error message for the given code
792			* @param int $code the error code
793			* @return string the error message
794			*/
795			private function getPhpUploadErrorMessageByCode($code){
796			$codeMessageMaps = array(
797			1 => $this->error_messages['upload_err_ini_size'],
798			2 => $this->error_messages['upload_err_form_size'],
799			3 => $this->error_messages['upload_err_partial'],
800			4 => $this->error_messages['upload_err_no_file'],
801			6 => $this->error_messages['upload_err_no_tmp_dir'],
802			7 => $this->error_messages['upload_err_cant_write'],
803			8 => $this->error_messages['upload_err_extension'],
804			);
805			return isset($codeMessageMaps[$code]) ? $codeMessageMaps[$code] : null;
806			}
807			}
808

tnhfw / tnh-fw

Branch — 1.0.0-dev (4efac2)

Upload::sizeFormat() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like