Notice: Undefined index: GEOIP_CITY in /var/www/vhosts/geekinside.fr/httpdocs/overall.php on line 7

Notice: Undefined index: GEOIP_REGION_NAME in /var/www/vhosts/geekinside.fr/httpdocs/overall.php on line 7
Geekin'Side
Français
English

Classe d'upload de fichiers en PHP

Par Admin, mer 05 jan 2011 20:18:44 - Catégorie : Développement

Commentaires 0 Commentaires

N'ayant pas trouvé de classe simple et gérant correctement les exceptions pour uploader des fichiers sur un serveur via PHP, j'ai décidé de développer ma propre classe.

Voici donc sa première version, qui, tout en restant simple, permet déjà tout ce qui a pu m'être nécessaire, à savoir :

  • Définir les types de fichiers autorisés (via leur MIME-type ou leur extension).
  • Laisser la classe catcher les exceptions elle-même ou les catcher soi-même pour pouvoir les gérer à sa façon.
  • Activer un mode debug. Il est possible de l'activer en mode HTML, ou bien directement via console.debug() en Javascript.
  • Définir la taille maximale des fichiers pouvant être uploadés. 
  • Définir s'il faut ou non écraser les fichiers qui sont déjà présents sur le serveur (nom identique). 
  • Définir les noms des fichiers pour qu'ils soient envoyés avec le nom que vous souhaitez. (à partir du script en version 1.0.1)

Ce script est décomposé en 2 classes distinctes :

1. La classe à proprement parler. Elle gère l'intégralité des fonctionnalités. C'est elle qui est instanciée.

PHP : class_Uploader.phpAfficher/Masquer le code
<?php
/*
    Version : 1.0.1
    Last modified : 08/01/2011
    Author : Thomas Bordinat
    Email : ulti@geekinside.fr
    Website : http://www.geekinside.fr

    This program is free software. It comes without any warranty, to
    the extent permitted by applicable law. You can redistribute it
    and/or modify it under the terms of the Do What The Fuck You Want
    To Public License, Version 2, as published by Sam Hocevar. See
    http://sam.zoy.org/wtfpl/COPYING for more details.
*/
namespace GeekinSide;

define('UPLOAD_UNIT_OCTET', 1);
define('UPLOAD_UNIT_KO', 2);
define('UPLOAD_UNIT_MO', 3);
define('UPLOAD_UNIT_GO', 4);

/**
 * SimpleUploader allow you to upload files easily.
 *    Just build your HTML form, and after submit, use the uploader object to save files on your server.
 *
 * Example :
 *
 * [code]
 *        $uploader = new GeekinSide\Uploader();
 *        $uploader->setDestinationFolder('./uploadDir/');
 *
 *        $uploader->setOverwrite(true);
 *
 *        if($uploader->upload()) {
 *            echo '<pre>'; var_dump($uploader->getUploadInformation()); echo '</pre>';
 *        }
 * [/code]
 *
 *
 * See full documentation and get updates at www.geekinside.fr
 *
 *
 * @author Thomas Bordinat <ulti@geekinside.fr>
 * @since PHP 5.3.0
 */
class Uploader {

    /**
     * array(<String>) Allowed MIME
     * default : everything is allowed, this is inadvisable
     */
    private $_allowedMime = array();

    /**
     *    boolean Should this class catch Exception ? If not, you'll have to the way you want.
     *    default value : true
     */
    private $_catchException = true;

    /**
     *    String/boolean If false, debug is desactivated. Else :
     *        - 'js'             =        Debug in JS console
     *        - 'html'         =        Debug in HTML
     *    default value : false
     */
    private $_debug = false;

    /**
     *    String Path of the folder where files will be uploaded (with or without the final /)
     */
    private $_destinationFolder = '.';

    /**
     *    array() Contains all $_FILES[]
     */
    private $_files;

    /**
     *    int Available space on hard drive (octet)
     */
    private $_freeSpace;

    /**
     * int Max file size (octet)
     * default : 0 = no limit
     */
    private $_maxFileSize = 0;
    
    /**
     * array(String) Name(s) to give to uploaded files
     */
    private $_names = '';

    /**
     *    boolean Should the Uploader overwrite files in the destination folder during upload if a file with the same name exists ?
     *    default value : false
     */
    private $_overwrite = false;

    /**
     *    boolean This boolean is true when uploads are done
     */
    private $_uploadOk = false;

    /**
     *    array() Contains all uploads information
     */
    private $_uploadInformation = array();

    /**
     *    Constructs an uploader instance
     *
     * @param debug (@see $_debug)
     */
    public function __construct($debug=false) {
        require_once(dirname(__FILE__).'/class_UploaderException.php');
        $this->setDebug($debug);
        $this->debug('__construct()');
        $this->initFiles();
    }

    /**
     *    Performs the upload
     *
     * @return true if all is ok
     * @throws UploaderException
     */
    public function upload() {
        $this->debug('upload()');

        try {
            $this->checkDestination();
            $this->initFreeSpace();

            // Number of uploaded files
            $i = 0;
            
            $names = $this->getNames();

            foreach($this->getFiles() as $form) {

                foreach($form as $file) {
                    $this->debug('-> File in progress... '.print_r($file, true));
                    if($file['size']>0) {
                        if($file['error']!=UPLOAD_ERR_OK) {
                            throw new UploaderException($file['error']);
                        }

                        if(!$this->checkMime($file['type'])) {
                            $this->debug('--> File mime not allowed');
                            // If the mime is not allowed, we store the information into the $_uploadInformation array
                            $this->_uploadInformation[] = array(
                                'index' => $file['index'],
                                'uploaded' => false,
                                'name' => $file['name'],
                                'type' => $file['type'],
                                'typeAllowed' => false,
                                'size' => $file['size'],
                                'sizeOk' => true,
                                'path' => null,
                                'overwrite' => false
                            );
                        }
                        elseif(!$this->checkFileSize($file['size'])) {
                            $this->debug('--> File is too big');
                            // If the file is too big, we store the information into the $_uploadInformation array
                            $this->_uploadInformation[] = array(
                                'index' => $file['index'],
                                'uploaded' => false,
                                'name' => $file['name'],
                                'type' => $file['type'],
                                'typeAllowed' => true,
                                'size' => $file['size'],
                                'sizeOk' => false,
                                'path' => null,
                                'overwrite' => false
                            );
                        }
                        else {
                            $fileAlreadyExists = file_exists($this->getDestinationFolder().$file['name']);

                            // If we can't overwrite the file, we store the information into the $_uploadInformation array
                            if(!$this->getOverwrite() && $fileAlreadyExists) {
                                $this->debug('--> File already exists, do not overwrite');
                                $this->_uploadInformation[] = array(
                                    'index' => $file['index'],
                                    'uploaded' => false,
                                    'name' => $file['name'],
                                    'type' => $file['type'],
                                    'typeAllowed' => true,
                                    'size' => $file['size'],
                                    'sizeOk' => true,
                                    'path' => null,
                                    'overwrite' => false
                                );
                            }
                            else {
                                if(isSet($names[$file['index']]) && !empty($names[$file['index']])) {
                                    $this->debug('--> Replacing '.$file['name'].' by '.$names[$file['index']]);
                                    $file['name'] = $names[$file['index']];
                                }
                                
                                // Upload done, the file has been moved to his destination
                                if(@move_uploaded_file($file['tmp_name'], $this->getDestinationFolder().$file['name'])) {
                                    $this->debug('--> File moved successfully from tmp to his final destination');
                                    $this->_uploadInformation[] = array(
                                        'index' => $file['index'],
                                        'uploaded' => true,
                                        'name' => $file['name'],
                                        'type' => $file['type'],
                                        'typeAllowed' => true,
                                        'size' => $file['size'],
                                        'sizeOk' => true,
                                        'path' => $this->getDestinationFolder().$file['name'],
                                        'overwrite' => $fileAlreadyExists ? true : false
                                    );
                                }
                                // An error occurred with the move_uploaded_file function, we try to find the problem
                                else {
                                    $this->debug('--> Error with move_uploaded_file function');
                                    // We check the space available...
                                    if($file['size']>$this->getFreeSpace()) {
                                        throw new UploaderException(UPLOAD_ERR_MOVE_UPLOADED_FILE_FREE_SPACE);
                                    }
                                    // WTF happened ?!
                                    else {
                                        throw new UploaderException(UPLOAD_ERR_MOVE_UPLOADED_FILE);
                                    }
                                }
                            }
                        }

                        $this->setFreeSpace($this->getFreeSpace()-$file['size']);
                        ++$i;
                    }
                }
            }

            if($i==0) {
                throw new UploaderException(UPLOAD_ERR_NO_FILE);
            }

            $this->setUploadOk(true);
            return true;
        }
        catch (\Exception $e) {
            if($this->_catchException) {
                if($this->_debug!==false) {
                    $this->debug('Exception : '.$e->getMessage());
                }
                else {
                    echo '<b>Exception : '.$e->getMessage().'</b>';
                }
            }
            else {
                throw new \Exception($e->getMessage(), $e->getCode(), $e);
            }

        }
    }


    /**********
     *
     *
     *     Check
     *
     *
     **********/

    /**
     * Check if all is ok with the destination folder.
     * Add a slash at the end of the destination folder string if there's not
     * @throws UploaderException
     */
    private function checkDestination() {
        $this->debug('checkDestination()');
        if(!is_dir($this->getDestinationFolder())) {
            throw new UploaderException(UPLOAD_ERR_DESTINATION_IS_NOT_A_FOLDER);
        }

        if(!preg_match('#/$#', $this->getDestinationFolder())) {
            $this->debug('-> add slash');
            $this->setDestinationFolder($this->getDestinationFolder().'/');
        }

        if(!is_writable($this->getDestinationFolder())) {
            throw new UploaderException(UPLOAD_ERR_CANT_WRITE_DESTINATION_FOLDER);
        }
    }
    /**
     * Check if the given MIME is allowed
     *
     * @param String MIME
     * @return boolean Does the MIME is allowed ?
     */
    private function checkMime($mime=null) {
        $this->debug('checkMime('.$mime.')');
        if(empty($mime)) {
            return false;
        }
        elseif($this->getAllowedMime()!=array()) {
            $this->debug(print_r($this->getAllowedMime(), true));
            return in_array($mime, $this->getAllowedMime());
        }
        else {
            return true;
        }
    }
    /**
     * Check if the file is small enough
     * @param int $fileSize
     * @return boolean Does the file size ok ?
     */
    private function checkFileSize($fileSize) {
        return $this->getMaxFileSize()==0 || $fileSize<=$this->getMaxFileSize();
    }


    /**********
     *
     *
     *     Init
     *
     *
     **********/

    /**
     * Get data from $_FILES and build the $_files array with it
     */
    private function initFiles() {
        $files = array();
        
        // File index
        $j = 0;
        foreach($_FILES as $formName=>$data) {

            // Example : <input type="file" name="array[]" />
            if(is_array($_FILES[$formName]['name'])) {
                $nbFiles = count($_FILES[$formName]['name']);
                for($i=0; $i<$nbFiles; $i++) {
                    foreach($_FILES[$formName] as $key=>$value) {
                        $files[$formName][$i][$key] = $value[$i];
                    }
                    $files[$formName][$i]['index'] = $j;
                    ++$j;
                }
            }

            // Example : <input type="file" name="simpleName" />
            else {
                foreach($_FILES[$formName] as $key=>$value) {
                    $files[$formName][0][$key] = $value;
                }
                $files[$formName][0]['index'] = $j;
                ++$j;
            }

        }

        /**
         * Fill type if not defined (example: .php file)
         */
        foreach($files as $keyFiles=>$valueFiles) {
            $i = 0;
            foreach($valueFiles as $file) {
                if(empty($file['type']) && !empty($file['name'])) {
                    $this->debug('Fill type for file '.$file['name']);
                    $mime = $this->getMimeForExtension($this->getExtension($file['name']));
                    $files[$keyFiles][$i]['type'] = $mime[0];
                }
                ++$i;
            }
        }

        $this->debug('initFiles() -> '.print_r($files, true).'');
        $this->_files = $files;
    }
    /**
     * Get free space on the destination folder
     */
    private function initFreeSpace() {
        $this->debug('initFreeSpace()');
        $this->setFreeSpace(disk_free_space($this->getDestinationFolder()));
    }


    /**********
     *
     *
     *     Getter
     *
     *
     **********/

    /**
     * Get the allowed mime array
     * @return array(String) $_allowedMime
     */
    private function getAllowedMime() {
        $this->debug('getAllowedMime()');
        return $this->_allowedMime;
    }
    /**
     * Get the destination folder
     * @return String $_destinationFolder
     */
    private function getDestinationFolder() {
        $this->debug('getDestinationFolder()');
        return $this->_destinationFolder;
    }
    /**
     * Get given file's extension
     * @param String filename
     * @return String extension
     */
    private function getExtension($fileName) {
        $pathInfo = pathinfo($fileName);
        return $pathInfo['extension'];
    }
    /**
     * Returns the $_files to upload
     * @return array() $_files
     */
    private function getFiles() {
        $this->debug('getFiles()');
        return $this->_files;
    }
    /**
     * Get the available space on destination folder
     * @return int $_freeSpace
     */
    private function getFreeSpace() {
        $this->debug('getFreeSpace()');
        return $this->_freeSpace;
    }
    /**
     * Get the maximum file size
     * @return int $_maxFileSize
     */
    private function getMaxFileSize() {
        $this->debug('getMaxFileSize()');
        return $this->_maxFileSize;
    }
    /**
     * Get the name(s) to give
     * @return array(String) $_names
     */
    private function getNames() {
        $this->debug('getNames()');
        return $this->_names;
    }
    /**
     * Get the overwrite property
     * @return boolean $_overwrite
     */
    public function getOverwrite() {
        $this->debug('getOverwrite()');
        return $this->_overwrite;
    }
    /**
     * If the upload is done, this method returns some information about the files uploaded
     *
     * @return array(mixed)
     * @example :
     *
     * array( 0=>array(
     *        'uploaded' => true,
     *        'name' => 'filename.jpg',
     *        'type' => 'image/jpg',
     *        'typeAllowed' => true,
     *        'size' => 1573215,
     *        'sizeOk' => true,
     *        'path' => './upload/filename.jpg',
     *        'overwrite' => false
     * ));
     *
     * @throws UploaderException
     */
    public function getUploadInformation() {
        $this->debug('getUploadInformation()');
        if($this->getUploadOk()) {
            return $this->_uploadInformation;
        }
        else {
            throw new UploaderException(UPLOAD_ERR_CANT_ACCESS_INFORMATION);
        }
    }
    /**
     * Get $_uploadOk boolean
     * @return boolean $_uploadOk
     */
    private function getUploadOk() {
        $this->debug('getUploadOk()');
        return $this->_uploadOk;
    }


    /**********
     *
     *
     *     Setter
     *
     *
     **********/

    /**
     * Set the allowedMime array
     * @param array(String) $allowedMime
     */
    public function setAllowedMime($allowedMime) {
        $this->debug('setAllowedMime('.print_r($allowedMime, true).')');
        $this->_allowedMime = $allowedMime;
    }
    /**
     * Set the catchException property
     * @param boolean $catchException
     */
    public function setCatchException($catchException) {
        $this->debug('setCatchException('.($catchException ? 'true' : 'false').')');
        $this->_catchException = $catchException;
    }
    /**
     * Set the destination folder
     * @param String $destinationFolder
     */
    public function setDestinationFolder($destinationFolder) {
        $this->debug('setDestinationFolder('.$destinationFolder.')');
        $this->_destinationFolder = $destinationFolder;
    }
    /**
     * Set the debug property
     * @param boolean $debug
     */
    public function setDebug($debug) {
        $this->debug('setDebug('.($debug ? 'true' : 'false').')');
        $this->_debug = $debug;
    }
    /**
     * Set the available space on destination folder
     * @param int $freeSpace
     */
    private function setFreeSpace($freeSpace) {
        $this->debug('setFreeSpace('.$freeSpace.')');
        $this->_freeSpace = $freeSpace;
    }
    /**
     * Set the max file size property
     * @param int $maxFileSize
     */
    public function setMaxFileSize($maxFileSize=0, $unit=UPLOAD_UNIT_OCTET) {
        switch($unit) {
            case UPLOAD_UNIT_KO :
                $maxFileSize *= 1024;
            break;
            case UPLOAD_UNIT_MO :
                $maxFileSize *= 1048576;
            break;
            case UPLOAD_UNIT_GO :
                $maxFileSize *= 1073741824;
            break;
        }
        $this->debug('setMaxFileSize('.$maxFileSize.')');
        $this->_maxFileSize = $maxFileSize;
    }
    /**
     * Set the names
     * @param mixed $names
     */
    public function setNames($names) {
        $this->debug('setNames('.print_r($names, true).')');
        if(!is_array($names)) {
            $this->_names = array($names);
        }
        else {
            $this->_names = $names;
        }
    }
    /**
     * Set the overwrite property
     * @param boolean $overwrite
     */
    public function setOverwrite($overwrite) {
        $this->debug('setOverwrite('.($overwrite ? 'true' : 'false').')');
        $this->_overwrite = $overwrite;
    }
    /**
     * Set the uploadOk boolean
     * @param boolean $uploadOk
     */
    private function setUploadOk($uploadOk) {
        $this->debug('setUploadOk('.($uploadOk ? 'true' : 'false').')');
        $this->_uploadOk = $uploadOk;
    }


    /**********
     *
     *
     *     Utilities
     *
     *
     **********/

    /**
     * Add a mime on the $_allowedMime array
     *
     * @param array(String) | String $mime Mime to allow
     */
    public function addMime($mime) {
        $this->debug('addMime('.print_r($mime, true).')');
        if(!is_array($mime)) {
            $mime = array($mime);
        }

        $allowedMime = $this->getAllowedMime();
        foreach($mime as $toBeAdded) {
            array_push($allowedMime, $toBeAdded);
        }
        $this->setAllowedMime($allowedMime);
    }
    public function addExtension($extension) {
        $this->debug('addExtention('.$extension.')');
        $mime = $this->getMimeForExtension($extension);
        $this->addMime($mime);
    }
    /**
     * Remove a mime off the $_allowedMime array
     *
     * @param array(String) | String $mime Mime to remove
     */
    public function removeMime($mime) {
        $this->debug('removeMime('.print_r($mime, true).')');
        if(!is_array($mime)) {
            $mime = array($mime);
        }

        $allowedMime = $this->getAllowedMime();
        $tmpArray = array();
        foreach($allowedMime as $value) {
            if(!in_array($value, $mime)) {
                array_push($tmpArray, $value);
            }
        }
        $this->setAllowedMime($tmpArray);
    }
    public function removeExtension($extension) {
        $this->debug('removeExtension('.$extension.')');
        $mime = $this->getMimeForExtension($extension);
        $this->removeMime($mime);
    }
    /**
     * Get all MIME that corresponds to the given extension
     *
     * @param String $extension Extension needed
     * @return array(String) Mime
     */
    private function getMimeForExtension($extension) {
        $this->debug('getMimeForExtension('.$extension.')');
        if(preg_match('#^\.#', $extension)) {
            $extension = preg_replace('#^\.#', '', $extension);
        }

        switch($extension) {
            case 'gif' :
                $mime = array('image/gif');
            break;
            case 'jpg' :
            case 'jpeg' :
            case 'jpe' :
                $mime = array('image/jpg', 'image/jpeg', 'image/pjpeg');
            break;
            case 'png' :
                $mime = array('image/png', 'image/x-png');
            break;
            case 'bmp' :
                $mime = array('image/bmp', 'image/x-ms-bmp', 'image/x-windows-bmp');
            break;
            case 'tiff' :
                $mime = array('image/tiff');
            break;
            case 'flv' :
                $mime = array('video/x-flv');
            break;
            case 'js' :
                $mime = array('application/x-javascript');
            break;
            case 'json' :
                $mime = array('application/json');
            break;
            case 'css' :
                $mime = array('text/css');
            break;
            case 'xml' :
                $mime = array('application/xml');
            break;
            case 'doc' :
            case 'docx' :
                $mime = array('application/msword');
            break;
            case 'xls' :
            case 'xlt' :
            case 'xlm' :
            case 'xld' :
            case 'xla' :
            case 'xlc' :
            case 'xlw' :
            case 'xll' :
                $mime = array('application/vnd.ms-excel');
            break;
            case 'ppt' :
            case 'pps' :
                $mime = array('application/vnd.ms-powerpoint');
            break;
            case 'rtf' :
                $mime = array('application/rtf');
            break;
            case 'pdf' :
                $mime = array('application/pdf');
            break;
            case 'html' :
            case 'htm' :
            case 'php' :
                $mime = array('text/html');
            break;
            case 'txt' :
                $mime = array('text/plain');
            break;
            case 'mpeg' :
            case 'mpg' :
            case 'mpe' :
                $mime = array('video/mpeg');
            break;
            case 'mp3' :
                $mime = array('audio/mpeg3');
            break;
            case 'wav' :
                $mime = array('audio/wav');
            break;
            case 'aiff' :
            case 'aif' :
                $mime = array('audio/aiff');
            break;
            case 'avi' :
                $mime = array('video/msvideo');
            break;
            case 'wmv' :
                $mime = array('video/x-ms-wmv');
            break;
            case 'mov' :
                $mime = array('video/quicktime');
            break;
            case 'zip' :
                $mime = array('application/zip');
            break;
            case 'tar' :
                $mime = array('application/x-tar');
            break;
            case 'swf' :
                $mime = array('application/x-shockwave-flash');
            break;
            case 'odt' :
                $mime = array('application/vnd.oasis.opendocument.text');
            break;
            case 'ott' :
                $mime = array('application/vnd.oasis.opendocument.text-template');
            break;
            case 'oth' :
                $mime = array('application/vnd.oasis.opendocument.text-web');
            break;
            case 'odm' :
                $mime = array('application/vnd.oasis.opendocument.text-master');
            break;
            case 'odg' :
                $mime = array('application/vnd.oasis.opendocument.graphics');
            break;
            case 'otg' :
                $mime = array('application/vnd.oasis.opendocument.graphics-template');
            break;
            case 'odp' :
                $mime = array('application/vnd.oasis.opendocument.presentation');
            break;
            case 'otp' :
                $mime = array('application/vnd.oasis.opendocument.presentation-template');
            break;
            case 'ods' :
                $mime = array('application/vnd.oasis.opendocument.spreadsheet');
            break;
            case 'ots' :
                $mime = array('application/vnd.oasis.opendocument.spreadsheet-template');
            break;
            case 'odc' :
                $mime = array('application/vnd.oasis.opendocument.chart');
            break;
            case 'odf' :
                $mime = array('application/vnd.oasis.opendocument.formula');
            break;
            case 'odb ':
                $mime = array('application/vnd.oasis.opendocument.database');
            break;
            case 'odi' :
                $mime = array('application/vnd.oasis.opendocument.image');
            break;
            case 'oxt' :
                $mime = array('application/vnd.openofficeorg.extension');
            break;
            case 'docm' :
                $mime = array('application/vnd.ms-word.document.macroEnabled.12');
            break;
            case 'dotx' :
                $mime = array('application/vnd.openxmlformats-officedocument.wordprocessingml.template');
            break;
            case 'dotm' :
                $mime = array('application/vnd.ms-word.template.macroEnabled.12');
            break;
            case 'xlsx' :
                $mime = array('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
            break;
            case 'xlsm' :
                $mime = array('application/vnd.ms-excel.sheet.macroEnabled.12');
            break;
            case 'xltx' :
                $mime = array('application/vnd.openxmlformats-officedocument.spreadsheetml.template');
            break;
            case 'xltm' :
                $mime = array('application/vnd.ms-excel.template.macroEnabled.12');
            break;
            case 'xlsb' :
                $mime = array('application/vnd.ms-excel.sheet.binary.macroEnabled.12');
            break;
            case 'xlam' :
                $mime = array('application/vnd.ms-excel.addin.macroEnabled.12');
            break;
            case 'pptx' :
                $mime = array('application/vnd.openxmlformats-officedocument.presentationml.presentation');
            break;
            case 'pptm' :
                $mime = array('application/vnd.ms-powerpoint.presentation.macroEnabled.12');
            break;
            case 'ppsx' :
                $mime = array('application/vnd.openxmlformats-officedocument.presentationml.slideshow');
            break;
            case 'ppsm' :
                $mime = array('application/vnd.ms-powerpoint.slideshow.macroEnabled.12');
            break;
            case 'potx' :
                $mime = array('application/vnd.openxmlformats-officedocument.presentationml.template');
            break;
            case 'potm' :
                $mime = array('application/vnd.ms-powerpoint.template.macroEnabled.12');
            break;
            case 'ppam' :
                $mime = array('application/vnd.ms-powerpoint.addin.macroEnabled.12');
            break;
            case 'sldx' :
                $mime = array('application/vnd.openxmlformats-officedocument.presentationml.slide');
            break;
            case 'sldm' :
                $mime = array('application/vnd.ms-powerpoint.slide.macroEnabled.12');
            break;
            case 'thmx' :
                $mime = array('application/vnd.ms-officetheme');
            break;
            case 'onetoc' :
            case 'onetoc2' :
            case 'onetmp' :
            case 'onepkg' :
                $mime = array('application/onenote');
            break;
            default :
                $mime = array('text/plain');
            break;
        }
        return $mime;
    }


    /**********
     *
     *
     *     Debug
     *
     *
     **********/

    /**
     * Display the String $s if the debug property is set to 'js' or 'html'
     * @param String $s String to display
     */
    private function debug($s) {
        if($this->_debug!==false) {
            if($this->_debug=='js') {
                echo '<script type="text/javascript">console.debug('.json_encode($s).');</script>';
            }
            elseif($this->_debug=='html') {
                echo '<pre>'.$s.'</pre>';
            }
        }
    }

    /**
     * Destruct this object
     */
    public function __destruct() {
        $this->debug('__destruct()');
    }

}
?>

2. La classe étendant Exception, qui contient toutes les exceptions générées par l'Uploader.

PHP : class_UploaderException.phpAfficher/Masquer le code
<?php
/*
    Author : Thomas Bordinat
    Email : ulti@geekinside.fr
    Website : http://www.geekinside.fr

    This program is free software. It comes without any warranty, to
    the extent permitted by applicable law. You can redistribute it
    and/or modify it under the terms of the Do What The Fuck You Want
    To Public License, Version 2, as published by Sam Hocevar. See
    http://sam.zoy.org/wtfpl/COPYING for more details.
*/
namespace GeekinSide;

/**
 * Adding some new UPLOAD_ERR constants
 */
define('UPLOAD_ERR_DESTINATION_IS_NOT_A_FOLDER', 9);
define('UPLOAD_ERR_MOVE_UPLOADED_FILE', 10);
define('UPLOAD_ERR_MOVE_UPLOADED_FILE_FREE_SPACE', 11);
define('UPLOAD_ERR_CANT_ACCESS_INFORMATION', 12);
define('UPLOAD_ERR_CANT_WRITE_DESTINATION_FOLDER', 13);

/**
 *
 * Uploader exceptions
 *
 * @author Thomas Bordinat <ulti@geekinside.fr>
 * @since PHP 5.3.0
 */
class UploaderException extends \Exception {
    /**
     * Constructor
     *
     * @param int $code Error code
     */
    public function __construct($code) {
        $message = $this->getUploadError($code);
        parent::__construct($message, $code);
    }

    /**
     * Return the message that you'll find with $e->getMessage(); ($e is an \Exception)
     *
     * @param int $code Error code
     * @return String $message
     */
    private function getUploadError($code) {
        switch ($code) {
            case UPLOAD_ERR_INI_SIZE :
                $message = 'The uploaded file exceeds the upload_max_filesize directive in php.ini.';
            break;
            case UPLOAD_ERR_FORM_SIZE :
                $message = 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form.';
            break;
            case UPLOAD_ERR_PARTIAL :
                $message = 'The uploaded file was only partially uploaded.';
            break;
            case UPLOAD_ERR_NO_FILE :
                $message = 'No file was uploaded.';
            break;
            case UPLOAD_ERR_NO_TMP_DIR :
                $message = 'Missing a temporary folder.';
            break;
            case UPLOAD_ERR_CANT_WRITE :
                $message = 'Failed to write file to disk.';
            break;
            case UPLOAD_ERR_EXTENSION :
                $message = 'A PHP extension stopped the file upload.';
            break;
            case UPLOAD_ERR_DESTINATION_IS_NOT_A_FOLDER :
                $message = 'The destination path is not a folder or doesn\'t exists.';
            break;
            case UPLOAD_ERR_MOVE_UPLOADED_FILE :
                $message = 'The file cannot be move to the destination folder.';
            break;
            case UPLOAD_ERR_MOVE_UPLOADED_FILE_FREE_SPACE :
                $message = 'The uploaded file exceeds the available disk space.';
            break;
            case UPLOAD_ERR_CANT_ACCESS_INFORMATION :
                $message = 'Cannot access upload information until it is not ended successfully.';
            break;
            case UPLOAD_ERR_CANT_WRITE_DESTINATION_FOLDER :
                $message = 'Failed to write on destination folder.';
            break;
            default :
                $message = 'Unknown error occurred, please contact the author.';
            break;
        }
        return $message;
    }

}
?>

Pour illustrer tout ça, rien ne vaut un exemple. Ce fichier est à placer dans le même dossier que les deux classes composant l'Uploader. Il présente un peu son fonctionnement et permet de voir les différentes méthodes utiles.

PHP : uploaderExample.phpAfficher/Masquer le code
<?php
require('./file/php/uploader/class_Uploader.php');

if(!isSet($_FILES) || empty($_FILES)) {
    echo '<form action="'.$_SERVER['PHP_SELF'].'" method="POST" enctype="multipart/form-data">
        Choose a file to upload : <input name="test" type="file" /><br />
        Choose a file to upload : <input name="array[]" type="file" /><br />
        Choose a file to upload : <input name="array[]" type="file" /><br />
        <input type="submit" value="Upload those files" />
    </form>';
}
else {
    try {
        $uploader = new GeekinSide\Uploader('js');    // Open your JS console to see debug information (or replace 'js' by 'html')
        $uploader->setDestinationFolder('./log/'); // Files will be uploaded into the current folder

        $uploader->setOverwrite(true); // If file exists, it will be overwritten

        $uploader->setMaxFileSize(100, UPLOAD_UNIT_KO); // Set the max file size to 10 Ko (you can also use UPLOAD_UNIT_MO, UPLOAD_UNIT_GO or UPLOAD_UNIT_OCTET (by default)

        // Add / Remove available MIME or extensions
        $uploader->addMime('image/png');
        $uploader->addMime('image/gif');
        $uploader->addExtension('zip');
        $uploader->addMime(array('application/x-javascript', 'application/json'));
        $uploader->addMime('text/plain');
        $uploader->addExtension('.jpg');
        $uploader->addExtension('.php');
        $uploader->removeMime('application/json');
        $uploader->removeExtension('.js');
        
        $uploader->setNames(array('file1.ext', '', 'file3.ext'));

        // Upload files
        if($uploader->upload()) {
            echo count($uploader->getUploadInformation()).' file(s) :';

            $files = $uploader->getUploadInformation();
            foreach($files as $file) {
                echo '<br />';
                foreach($file as $key=>$value) {
                    if(is_bool($value)) {
                        echo $key.' : <b>'.($value ? 'true' : 'false').'</b> ';
                    }
                    elseif(is_null($value)) {
                        echo $key.' : <b><i>null</i></b> ';
                    }
                    else {
                        echo $key.' : <b>'.$value.'</b> ';
                    }
                }
            }
        }
    }
    catch (Exception $e) {
        echo 'Error : '.$e->getMessage();
    }
}
?>

 

Téléchargements Téléchargement Uploader.tar.gz
PHP 5.3.0 minimum
Serveur Linux
Licence WTFPL
En espérant que ça puisse être utile :)

 

Partager cet article ! Partager cet article ! Facebook
Commentaires Commentaires  Laisser un commentaire Laisser un commentaire
Pseudo

DoNotFillIt


 Commentaire *




Il n'y a pas encore de commentaires
Suivez-nous sur Facebook !