Ir para o conteúdo

- - - - -

Upload De Arquivos Avançado


Criado por Gremio10, Jul 26 2011 23:40

3 respostas neste tópico
  • Por favor, faça o login para responder

#1 Gremio10

Gremio10
  • Gremio10
  • Colaborador
  • 12 Revisões
  • LocalizaçãoPorto Alegre

Revisou 26 julho 2011 - 23:40

Então, essa nova versão que fiz possui determinação de extensões que podem ser enviadas, e o limite no tamanho dos arquivos...

espero que gostem :D

<?php
/**
 * Classe para upload de arquivos
 *
 * feita para a manipulação mais eficiente
 * de tipos de arquivos
 * determinação de tamanho máximo
 *
 * @author Felipe Pieretti Umpierre
 * felipeumpierre<at>hotmail<dot>com
 */
class Upload {

    /**
    * PRIVATE
    */
    private $file = array();

    /**
    * PUBLIC
    */
    public $dir = "", $extension, $size;

    /**
    * Prepara os dados do $_FILES para uma variavel.
    * 
    * @param Array $_file
    */
    public function  __construct( $_file )
    {
        foreach( $_FILES[ $_file ] as $key => $values ){
            $this->file[ $key ] = $values;
        }

    }

    /**
    * Faz o upload do arquivo
    */
    public function makeUpload( )
    {
        /**
         * Caso a variável dir, estiver vazia, ele retorna um erro
         */
        if( $this->dir == "" )
        {
            print( "Você deve determinar um caminho para os arquivos." );
            exit;
	}

	if( self::isFile() )
        {
            if( self::size( $this->size ) )
            {
                if( self::isArray( $this->file[ "error" ] ) )
                {
                    try
                    {
                        foreach( $this->file[ "error" ] as $key => $error )
                        {
                            if( $error == UPLOAD_ERR_OK )
                            {
                                /**
                                 * Inicia a cópia do arquivo
                                 */
				$newFileName = date( "dmYHis" ) . "_" . $this->file[ "name" ][ $key ];
				move_uploaded_file( $this->file[ "tmp_name" ][ $key ], $this->dir . $newFileName );
                                /**
                                 * retorna o nome do arquivo, para ser salvo no banco
                                 */
				return $newFileName;
                            }
			}
                    }
                    catch( Exception $ex )
                    {
                        echo $ex->getMessage();
                    }
		}
                else
                {
                    try
                    {
                        /**
                         * Inicia a cópia do arquivo
                         */
			$newFileName = date( "dmYHis" ) . "_" . $this->file[ "name" ];
			move_uploaded_file( $this->file[ "tmp_name" ], $this->dir . $newFileName );
                        /**
                        * retorna o nome do arquivo, para ser salvo no banco
                        */
			return $newFileName;
                    }
                    catch( Exception $ex )
                    {
                        echo $ex->getMessage();
                    }
		}

                header( "Location: index.html" );
            }
            else
            {
		print( "O(s) arquivo(s) é(são) acima do tamanho pré-determinado." );
            }
	}
        else
        {
            print( "O(s) arquivo(s) escolhido(s) não é(são) permitido(s)." );
	}
    }

    /**
    * Verifica se o arquivo é do tamanho determinado pelo programador.
    *
    * @param int $_max_size
    * @return Bool
    */
    private function size( $_max_size )
    {
	$_max_size = self::convertMbToBt( $_max_size );

        if( $this->isFile() )
        {
            if( self::isArray( $this->file[ "size" ] ) )
            {
                $count = count( $this->file[ "size" ] );
		$counter = 0;

		foreach( $this->file[ "size" ] as $newSize )
                {
                    ( $newSize <= $_max_size ) ? $counter++ : $counter-- ;
		}

                return ( $counter == $count ) ? true : false ;
            }
            else
            {
		return ( $this->file[ "size" ] <= $_max_size ) ? true : false ;
            }
        }
    }

    /**
    * Verifica se o arquivo enviado é de uma das extensões permitidas.
    *
    * @return Bool
    */
    private function isFile()
    {
        if( self::isArray( $this->extension ) )
        {
            $extensions = implode( "|", $this->extension );

            $_file_test	= self::isArrayEmpty( $this->file[ "name" ] );

            if( self::isArray( $_file_test ) )
            {
                $count = count( $_file_test );
                $counter = 0;

                foreach( $_file_test as $values )
                {
                    ( preg_match( "/.+\.({$extensions})/", $values ) ) ? $counter++ : $counter-- ;
                }
                
                return ( $count == $counter ) ? true : false ;
            }
            else
            {
                return ( preg_match( "/.+\.({$extensions})/", $_file_test ) ) ? true : false ;
            }

        }
    }

    /**
    * Verifica se existe algum campo vazio.
    *
    * @params Array $_array array de uma key do $_FILES
    * @return Array
    */
    private function isArrayEmpty( $_array )
    {
        if( is_array( $_array ) )
        {
            $_array_search = array_search( "", $_array );

            if( is_numeric( $_array_search ) )
		unset( $_array[ $_array_search ] );
        }

            return $_array;
    }

    /**
    * Verifica se é array.
    *
    * @params Array $_array array de uma key do $_FILES
    * @return Bool
    */
    private function isArray( $_array )
    {
        return ( is_array( $_array ) ) ? true : false ;
    }

    /**
    * Transforma o valor em MB para Byte
    *
    * @params int $_size valor em MB do tamanho máximo
    * @return int
    */
    private function convertMbToBt( $_size )
    {
    	return $_size * pow( 2, 1024 );
    }

}
?>

Para testar :

<?php
require_once "class.upload.php";

/**
* 'file' é o name da input file
*/
$_upload = new Upload( "file" );

$_upload->dir = "upload/";

/**
* sempre tem de ser array, mesmo ser for apenas um valor
*/
$_upload->extension = array( "jpg", "png", "gif", "jpeg", "ico", "bmp" );

/**
* colocar em MB
*/
$_upload->size = 10;

/**
* Pode-se fazer de duas maneiras...
*/

$_upload->makeUpload();

/**
* ou
*/

$_nameFile = $_upload->makeUpload();

/**
* Assim tu possui o nome do(s) arquivos(s)
*/
?>

Felipe Pieretti Umpierre

@FelipeUmpierre

www.creativeideas.com.br

#2 Renato Vitor

Renato Vitor
  • Renato Vitor
  • Colaborador
  • 1 Revisões

Revisou 22 agosto 2011 - 20:33

Vlw! Ajudou Muito! :)

#3 Gremio10

Gremio10
  • Gremio10
  • Colaborador
  • 12 Revisões
  • LocalizaçãoPorto Alegre

Revisou 14 fevereiro 2012 - 13:58

Então galera, finalmente fiz uma nova versão da classe de Upload, a única novidade foi a reformulação do código, deixando ela mais orientada, e mais limpa.

<?php

/**
 * Classe para upload multiplo ou simples de arquivos
 * 
 * @author Felipe Pieretti Umpierre 
 * umpierre[dot]felipe[at]gmail[dot]com
 * @package Upload
 */
class Upload 
{    
    private $file = array();    
    
    # Diretório para aonde será enviado os arquivos
    public $dir;
    
    # Extensões permitidas
    public $extension = array(); 
    
    # Tamanho máximo do arquivo, em MB
    public $size;
    
    # Nome(s) do(s) arquivo(s) enviado(s), já com rename
    public $name = array();
    
    /**
     * Repassa os valores da variável FILES para o file.
     * 
     * @param String $file nome do campo file
     */
    public function __construct( $file )
    {
        $this->file = $_FILES[ $file ];        
    }
    
    /**
     * Faz o upload das imagens
     * 
     * @return Array
     */
    public function upload()
    {
        $this->checkExtension()->size()->rename();
        
        # Verifica se é array, ou seja, se é multiplos arquivos a serem enviados.
        if( is_array( $this->file[ "name" ] ) && !empty( $this->file[ "name" ] ) )
        {   
            foreach( $this->file[ "error" ] as $key => $error )
            {
                # Verifica se existe algum erro no envio, se não houver, ele faz o upload
                if( $error == UPLOAD_ERR_OK || !empty( $this->file[ "name" ][ $key ] ) )
                {
                    move_uploaded_file( $this->file[ "tmp_name" ][ $key ], $this->getDir() . $this->file[ "name" ][ $key ] );
                    
                    # Armazena o nome do arquivo para a variável name, aonde depois poderá ser inserido no banco de dados
                    $this->name[] = $this->file[ "name" ][ $key ];
                }
            }
        }
        elseif( !empty( $this->file[ "name" ] ) )
        {            
            move_uploaded_file( $this->file[ "tmp_name" ], $this->getDir() . $this->file[ "name" ] );
            
            # Armazena o nome do arquivo para a variável name, aonde depois poderá ser inserido no banco de dados
            $this->name[] = $this->file[ "name" ];
        }
        
        return $this->name;
    }
    
    /**
     * Verifica se a(s) extenção(ções) do(s) arquivo(s) enviado(s)
     * é(são) permitido(s)
     * 
     * @return \Upload 
     */
    public function checkExtension()
    {
        if( is_array( $this->extension ) )
        {
            $extensions = implode( "|", $this->extension );
            
            if( is_array( $this->file[ "name" ] ) )
            {
                foreach( $this->file[ "name" ] as $key => $val )
                {
                    if( !preg_match( "/.+\.({$extensions})/", $val ) )
                    {
                        $this->file[ "name" ][ $key ] = "";
                    }
                }
            }
            else
            {
                if( !preg_match( "/.+\.({$extensions})/", $this->file[ "name" ] ) )
                {
                    unset( $this->file[ "name" ] );
                }
            }
        }
        
        return $this;
    }
    
    /**
     * Verifica se o tamanho do arquivo é do
     * limite especificado
     * 
     * @return \Upload 
     */
    public function size()
    {
        $size = $this->convertMbToBt();
        
        if( is_array( $this->file[ "size" ] ) )
        {
            foreach( $this->file[ "size" ] as $key => $sizes )
            {
                if( $sizes > $size )
                {
                    $this->file[ "name" ][ $key ] = "";
                    $this->file[ "size" ][ $key ] = "";
                }
            }
        }
        else
        {
            if( $this->file[ "size" ] > $size )
            {
                unset( $this->file[ "size" ] );
            }
        }
        
        return $this;
    }
    
    /**
     * Transaforma os MB para bits
     * 
     * @return int
     */
    private function convertMbToBt()
    {
        $size = $this->getSize() * ( 1024 * 1024 );
        return $size;
    }

    /**
     * Renomeia o(s) nome(s) do(s) arquivo(s) enviado(s)
     * @return \Upload 
     */
    protected function rename()
    {
        if( is_array( $this->file[ "name" ] ) )
        {
            foreach( $this->file[ "name" ] as $key => $val )
            {
                if( !empty( $this->file[ "name" ][ $key ] ) )
                {
                    $exts = preg_split( "[\.]", $this->file[ "name" ][ $key ] );
                    $n = count( $exts ) - 1;            
                    $exts = $exts[ $n ];

                    $this->file[ "name" ][ $key ] = date( "YmdHisu" ) . "_" . uniqid() . "_" . date( "usiHdmY" ) . "." . $exts;
                }
                else
                {
                    $this->file[ "name" ][ $key ] = "";
                }
            }
        }
        else
        {
            $exts = preg_split( "[\.]", $this->file[ "name" ] );
            $n = count( $exts ) - 1;            
            $exts = $exts[ $n ];

            $this->file[ "name" ] = date( "YmdHisu" ) . uniqid() . date( "usiHdmY" ) . "." . $exts;
        }
            
        return $this;
    }
    
    public function getDir()
    {
        return $this->dir;
    }

    public function setDir( $dir )
    {
        $this->dir = $dir;
        return $this;
    }

    public function getExtension()
    {
        return $this->extension;
    }

    public function setExtension( $extension )
    {
        $this->extension = $extension;
        return $this;
    }

    public function getSize()
    {
        return $this->size;
    }

    public function setSize( $size ) 
    {
        $this->size = $size;
        return $this;
    }
    
}

?>

Forma de utilizar:

require_once "../class/Upload.php";

$up = new Upload( "gallery" );
$up->setDir( "../upload/" )->setExtension( array( "jpg", "png", "JPG", "jpeg" ) )->setSize( 2 );

$name = $up->upload();
#ou
$up->upload();

Bom proveito ^^
Felipe Pieretti Umpierre

@FelipeUmpierre

www.creativeideas.com.br

#4 Carlos Coelho

Carlos Coelho
  • Carlos Coelho
  • Colaborador
  • 11 Revisões
  • LocalizaçãoGravataí - RS

Revisou 15 fevereiro 2012 - 22:07

A forma como vc valida o tipo de arquivo enviado está fraca. Eu poderia enviar um arquivo executável(.exe) com extensão .jpg e o script validaria.

Uma possível solução :seta: Como definir os mime types válidos de um tipo de arquivo
O conhecimento incompleto das potencialidades de uma linguagem de programação, pode conduzir a raciocínios (e conseqüentes projetos) relativamente limitados.




1 usuário(s) está(ão) lendo este código

1 membro(s), 0 visitante(s) e 0 membros anônimo(s)