Avaliação de classe

Gabriel Jacinto · Novembro 23, 2012

Olá pessoas!

Desde a semana passada estava trabalhando nessa classe. Hoje terminei (mas será melhorada no futuro).

Gostariam de saber o que acharam :grin:/>

Com ela é permitido:

Escolher o tipo de arquivo permitido para upload, desde as extensões até o tipo
Fazer o redimensionamento de imagens
Definir o tamanho máximo do arquivo (em KB, MB e GB)
Definir a pasta para o upload ser direcionado
Definir o nome do arquivo
Definir, se caso a função de redimensionamento for chamada, se só será feito o upload da imagem redimensionada ou da normal e dela.
Gerar o nome da imagem, com diretório ou sem (Ex: com dir: path/file.ext ; sem dir: file.ext)

<?php

class Upload{

/**
 * Upload de arquivos
 * @author Gabriel Jacinto
 */

/**
 * Dados do arquivo
    * @var $file = recebe o arquivo
    * @var $name = recebe o nome da imagem
    * @var $tmpName = recebe o tmp_name do arquivo
    * @var $size = recebe o tamanho (kb) do arquivo
    * @var $sizeMax = define o tamanho máximo do arquivo
    * @var $ext = recebe a extensão do arquivo
    * @var $directoryFinal = define o diretório (+ nome) para onde o arquivo sereá enviado e com que nome
    * @var $errors = recebe os erros do arquivo
    * @var $path = pasta para onde o arquivo será mandado
 */
protected
	$file,
       $name,
       $nameMiniature,
	$tmpName,
       $size,
       $sizeMax,
	$ext,
	$directoryFinal,
       $directoryFinalMiniature,
	$errors,
       $typeFile,
       $type,
	$path = "uploads/";

/**
    * Lista com possíveis erros do arquivo
 * @var $this->errors = array : erros da imagem
 */    
   protected
       $errorsList = array();

   /**
    * Constantes para dizer qual o tipo de arquivo permitido para upload
    * @const IMAGE = somente imagens
    * @const AUDIO = somente arquivos de audio
    * @const VIDEO = somente arquivos de vídeo
    * @const ALL = para qualquer arquivo
    */    
   const IMAGE = 'Image';
   const AUDIO = 'Audio';
   const VIDEO = 'Video';
   const ALL = 'All';

   /**
    * @const ONLY_RESIZE = somente redimensionar
    * @var $onlyResize = se true, somente o upload da imagem redimensionada será feito
    */
   const ONLY_RESIZE = true;
   protected $onlyResize;

   /**
    * @const WITH_DIR = retorna o diretório mais o nome da imagem (Ex: dir/file.ext)
    * @const ONLY_NAME = retorna somente o nome da imagem (Ex: file.ext)
    */
   const WITH_DIR = 'with_dir';
   const ONLY_NAME = 'only_name';

   /**
    * Especificações para imagem
    * @var $width = largura da imagem
    * @var $height = altura da imagem
    * @var $resizeImageToWidth = largura de nova imagem
    * @var $resizeImageToHeight = altura da nova imagem
    */
   protected
       $width,
       $height,
       $resizeImageToWidth,
       $resizeImageToHeight;

/**
 * Pega as informações do arquivo enviado (método construtor)
 * @param $file = arquivo a ser enviado
 * @var $this->file = arquivo e armazana nessa mesma variável
 * @method $this->setTmpName() = pega o tmp_name do arquivo e armazana na variável $this->tmpName
 * @method $this->setName() = pega o nome do arquivo e armazena na variável $this->name
 * @method $this->setExt() = pega a extensão do arquivo e armazena na variável $this->ext
 */
   public function __construct( $file ){
     		$this->file = $file;
           $this->searchErrors();
   		$this->setTmpName();
           $this->setName();
           $this->setTypeFile();
           $this->setSize();
   		$this->setExt();
   }

/**
 * Trocando a para onde o arquivo será mandado
    * @param $path = novo diretório
    * @var $this->path = define um novo diretório para onde o arquivo será mandado (Original: 'uploads/')
 */
public function setPath( $path ){
	$this->path = $path;
       $this->setDirectoryFinal();
}

   protected function setTypeFile(){
       $this->typeFile = $this->file['type'];
   }

/**
 * Recebe o nome do arquivo
 * @param string = novo nome da imagem
 */
   public function setName( $name = null ){
       if( $name != null ){
           $this->name = $name . '.' . $this->ext;
           $this->setDirectoryFinal();
       }else{
           $this->name = $this->file['name'];
           $explode = explode( '.', $this->file['name'] );
           $nameForMiniature = str_replace( end( $explode ), '', $this->file['name'] );
           $nameForMiniature = str_replace( '.', '', $nameForMiniature );
           $this->nameMiniature = $nameForMiniature . '_miniature.';
           $this->setDirectoryFinal();
       }
   }

   /**
    * Retornará o nome do arquivo
    * @param $name = com const's WITH_DIR ou ONLY_DIR
    */
   public function getName( $name ){
       if( $name == 'with_dir' ){
           return $this->directoryFinal;
       }elseif( $name == 'only_name' ){
           return $this->name;
       }
   }

   /**
    * Retornará o nome da imagem redimensionada
    * @param $name = com const's WITH_DIR ou ONLY_DIR
    */
   public function getNameMiniature( $name ){
       if( $name == 'with_dir' ){
           return $this->directoryFinalMiniature;
       }elseif( $name == 'only_name' ){
           return $this->nameMiniature;
       }
   }
/**
 * Pega o tamanho do arquivo
 * @var $this->size = onde será armazanado o tamanho do arquivo em KB's
 */
   protected function setSize(){
       $this->size = $this->file['size'];
   }

/**
 * Pega o tmp_name do arquivo
 * @var $this->tmpName = onde o tmp_name do arquivo é armazanado
 */
protected function setTmpName(){
	$this->tmpName = $this->file['tmp_name'];
}

/**
 * Pega a exntensão do arquivo
 * @var $this->ext = onde será armazenada a extensão do arquivo
 */
protected function setExt(){
	$explode = explode( '.', $this->name );
	$this->ext = end( $explode );
}

/**
 * Cria o diretório final do arquivo a ser enviado
 * @var $this->directoryFinal = str com o diretório
 */
protected function setDirectoryFinal(){
	$this->directoryFinal = $this->path . $this->name;
       $this->directoryFinalMiniature = $this->path . $this->nameMiniature . $this->ext;
}

/**
 * Escolhe o tipo de arquivo a ser enviado
 * @param $type = o tipo do arquivo a ser enviado (self::IMAGE, self::AUDIO, self::VIDEO)
    * @param $allowed = tipos permitidos de arquivos (se for vazio, valores padrões são aplicados)
 * @var $allowedForImages = array : tipos de imagens permitidas
 * @var $allowedForAudio = array : tipos de arquivos de áudio permitidos
 * @var $allowedForVideo = array : tipos de arquivos de vídeo permitidos
 */
public function typeAllowed( $type, array $allowed = null ){
    $allowedForAll = array();
       $allowedForImages = array( 'JPEG', 'jpeg', 'JPG', 'jpg', 'GIF', 'gif', 'PNG', 'png', 'BMP', 'bmp' );
       $allowedForAudio  = array( 'MP3', 'mp3', 'WMA', 'wma', 'AAC', 'aac', 'WMA', 'wma', 'OGG', 'ogg', 'AC3', 'ac3' );
       $allowedForVideo  = array( 'AVI', 'avi', 'WMV', 'wmv', 'MP4', 'mp4', 'FLV', 'flv' );

       if( $allowed != null ){
           switch( $type ){
               case 'Image':
                   $allowedForImages = $allowed;
                   break;

               case 'Audio':
                   $allowedForAudio = $allowed;
                   break;

               case 'Video':
                   $allowedForVideo = $allowed;
                   break;

               case 'All':
                   $allowedForAll = $allowed;
                   break;
           }
       }

	switch( $type ){
           case 'Image':
               $this->type = 'image';
			if( !array_search( $this->ext, $allowedForImages ) ){
				die( "<script>alert('O arquivo não é uma imagem, por isso o upload foi cancelado.');</script>" );
			}
               break;

           case 'Audio':
               $this->type = 'audio';
               if( !in_array( $this->ext, $allowedForAudio ) ){
				die( "<script>alert('O arquivo não um arquivo de áudio, por isso o upload foi cancelado.');</script>" );
			}
               break;

           case 'Video':
               $this->type = 'video';
               if( !in_array( $this->ext, $allowedForVideo ) ){
				die( "<script>alert('O arquivo não é um arquivo de vídeo, por isso o upload foi cancelado.');</script>" );
			}
               break;
           case 'All':
               if( !in_array( $this->ext, $allowedForAll ) ){
                   die( "<script>alert('Tipo de arquivo inválido!');</script>" );
               }
       }		
}

/**
 * Define o tamanho máximo do arquivo a ser enviado
 * @param $size_max = tamanho máximo (float)
 * @param $type = tipo de unidade de medida ('KB', 'MB', 'GB')
 */
   public function sizeMax( $size_max, $type ){
       switch( strtolower( $type ) ){
           case "kb":
               $kb = $size_max;
               $this->sizeMax = 1024 * $kb;
               if( $this->sizeMax < $this->size ){
                   die( "O arquivo é muito grande, o máximo é ".$kb."KB" );
               }
               break;

           case "mb":
               $mb = $size_max;
               $this->sizeMax = 1024 * 1024 * $mb;
               if( $this->sizeMax < $this->size ){
                   die( "O arquivo é muito grande, o máximo é ".$mb."MB" );
               }
               break;

           case "gb":
               $gb = $size_max;
               $this->sizeMax = 1024 * 1024 * 1024 * $gb;
               if( $this->sizeMax < $this->size ){
                   die( "O arquivo é muito grande, o máximo é ".$gb."MB" );
               }
               break;

           default:
               die( "Unidade de medida de tamenho de arquivo inválida" );
               break;
       }
   }

   /**
    * Redimensionamento da imagem
    * @param $width = nova largura da imagem
    * @param $height = nova altura da imagem
    * @return caso tente ser feito o redimensionamento e o arquivo não for imagem, para
    */
   public function resizeImage( $width, $height, $onlyResize = false ){
       if( $this->type == 'image' or 
       strtolower($this->ext) == 'jpg' or 
       strtolower($this->ext) == 'jpeg' or 
       strtolower($this->ext) == 'gif' or 
       strtolower($this->ext) == 'png' or 
       strtolower($this->ext) == 'bmp' ) {
           $this->type = 'image';
           $this->onlyResize = $onlyResize;
           $this->redirectImageToWidth = $width;
           $this->redirectImageToHeight = $height;
       }else{
           die( 'Upload cancelado. Você não pode redimensionar arquivos que não sejam imagem' );
       }
   }

  	/**
 * Verifica se há erros no arquivo
 * @var $this->errors = fica armazanados os erros do arquivo
 * @var $this->errorsList = erros em string (Erros by Thiago Belem (http://blog.thiagobelem.net))
 * @return morre se huver erros
 */
protected function searchErrors(){
	$this->errors = $this->file['error'];

	$this->errorsList[0] = 'Não houve erro';
	$this->errorsList[1] = 'O arquivo no upload é maior do que o limite do PHP';
	$this->errorsList[2] = 'O arquivo ultrapassa o limite de tamanho especifiado no HTML';
	$this->errorsList[3] = 'O upload do arquivo foi feito parcialmente';
	$this->errorsList[4] = 'Não foi feito o upload do arquivo';

	if( $this->errors != 0 ){
		die( "<b>Ao fazer o upload, erros foram encontrados:</b> " . $this->errorsList[ $this->errors ] );
	}
}

   /**
    * Faz o redimensionamento de imagens
    */
   protected function actionResize(){

       if ( $this->typeFile == "image/jpeg" ){
		$img = imagecreatefromjpeg( $this->tmpName );
	}elseif ( $this->typeFile == "image/gif" ){
		$img = imagecreatefromgif( $this->tmpName );
	}elseif ( $this->typeFile == "image/png" ){
		$img = imagecreatefrompng( $this->tmpName );
	}

	$this->width = imagesx($img);
	$this->height = imagesy($img);

	$nova = imagecreatetruecolor( $this->redirectImageToWidth, $this->redirectImageToHeight );
	imagecopyresampled($nova, $img, 0, 0, 0, 0, $this->redirectImageToWidth, $this->redirectImageToHeight, $this->width, $this->height );

	if ( $this->typeFile == "image/jpeg" ){
		if( imagejpeg( $nova, $this->directoryFinalMiniature ) ){
		     return true;
		}

	}else if ( $this->typeFile == "image/gif" ){
		if( imagegif( $nova, $this->directoryFinalMiniature ) ){
               return true;
		}
	}else if ( $this->typeFile == "image/png" ){
		if( imagepng( $nova, $this->directoryFinalMiniature ) ){
		     return true;
		}

       }
   }

/**
 * Faz o upload do arquivo caso não haja erros
 * @param $msg = mensagem de sucesso caso o arquivo seja enviado
 * @var $upload = faz o upload do arquivo
 */
public function upload( $msgSucessCustom = null ){

       $msgSucessDefault = "<script type=\"text/javascript\">alert( 'Upload realizado com sucesso!' );</script>";

       if( $this->type == 'image' ){
           if( $this->redirectImageToHeight != null and $this->redirectImageToWidth != null ){
               if( $this->actionResize() ){
                   if( $this->onlyResize ){
                       if( $msgSucessCustom == null ){
                           echo $msgSucessDefault;
                       }else{
                           echo $msgSucessCustom;
                       }
                   }
               }   
           }
       }

       if( !$this->onlyResize ){
	    $upload = move_uploaded_file( $this->tmpName, $this->directoryFinal );
           if( $upload ){
               if( $msgSucessCustom == null ){
                   echo $msgSucessDefault;
               }else{
                   echo $msgSucessCustom;
               }

           }
       }

}

}
?>

Para dar um exemplo de funcionamento com imagens:

$up = new Upload( $arquivo );
$up->setPath( 'imagens' );//Se esse método não for chamado, o arquivo irá para 'upload/'
$up->setName( 'file' );//Se esse método não for chamado, o arquivo irá com o nome original
$up->typeAllowed( Upload::IMAGE, array('jpg', 'gif') );/* self::AUDIO (para arquivos de áudio)
self::VIDEO (para arquivos de video)
self::ALL (para qualquer tipo) 
OBS.: Esse método é opcional ($this->typeAllowed) e se o 1º parâmetro for self::ALL, apenas servirá para que você possa escolher a extensão do arquivo no segundo param em forma de array.
Se for IMAGE, ou AUDIO ou VIDEO, pode ser escolhida a extensão, mas haverá extensões padrão permitidos (como pode ser visto na class) */
$up->resizeImage( 200, 200 );/* Redimensiona a imagem para width: 200 / height: 200
Se for passado um terceiro param com self::ONLY_RESIZE, apenas o upload da imagem redimensionada será feito, senão, o da normal e o da redimensionada */
$up->sizeMax( '1', 'MB' );/* Será permitido arquivos de até 1 MB, mas pode se usar:
1 KB : sizeMax( 1 , 'KB' )
1 GB : sizeMax( 1 , 'GB' ) */
$up->upload( 'Upload realizado com sucesso!' );/* Realiza o upload
Se o parâmetro for passado em null, haverá uma mensagem padrão de sucesso
*/

~ Posso ter me perdido ao tentar explicar algo ~

01100011cc · Novembro 23, 2012

Achei que ta grande d+ para ter poucos recursos...

Manda um MP pro joão batista dar uma olhadinha, ele é o cara do OO.

Evandro Oliveira · Novembro 23, 2012

Tópico gêmeo. Os erros são idênticos.

http://forum.imasters.com.br/topic/478129-avaliacao-de-classe-php/page__pid__1905003

Gabriel Jacinto · Novembro 23, 2012

Obs.: O alinhamento do código foi meio que desfeito pelo fórum, pois está bem organizado.

Wercks Oliveira

Você acha que eu poderia criar uma class para o redimensionamento e depois estende-la?

Vinicius Rangel · Novembro 23, 2012

Tópico gêmeo. Os erros são idênticos.

http://forum.imasters.com.br/topic/478129-avaliacao-de-classe-php/page__pid__1905003

acho que quando ensinam orientado a objeto falam muito sobre a linguagem e esquecem do CONCEITO que é importante, se não fosse no hangout de OO eu não saberia que o objeto precisa ter uma única responsabilidade, acho que é um bom tópico para criar uma boa discussão.

João Batista Neto · Novembro 23, 2012

acho que quando ensinam orientado a objeto falam muito sobre a linguagem e esquecem do CONCEITO que é importante, se não fosse no hangout de OO eu não saberia que o objeto precisa ter uma única responsabilidade, acho que é um bom tópico para criar uma boa discussão.

Valeu a lembrança Vinícius!

João Batista Neto · Novembro 23, 2012

São vários princípios em OOD.

São, exatamente, 5:

S.O.L.I.D.

S :seta: S.R.P. => Single Responsibility Principle => Uma classe de ter uma, e apenas 1, razão para ser modificada.

O :seta: O.C.P. => Open/Closed Principle => Entidades (classes, funções, etc) devem ser abertas para extensão, mas fechadas para edição.

L :seta: L.S.P. => Liskov Substitution Principle => Classes derivadas devem ser substituíveis por suas classes bases. Estabelece que os métodos das classes derivadas não devem ser nem mais fortes, nem mais fracos que as classes base.

I :seta: I.S.P. => Interface Segregation Principle => Melhor ter várias interfaces "magras", que uma única interface "gorda".

D :seta: D.I.P. => Dependency Inversion Principle => Participantes de alto nível não devem depender de participantes de baixo nível, ambos devem depender de abstrações. Abstrações não devem depender de detalhes de implementações, ambos devem depender de abstrações.

Não existe um mais importante que outro. Todos são fundamentais para um bom design.

Seu código, Gabriel Jacinto, viola, com exceção de L.S.P. (já que não há herança), todos os outros princípios de design:

1. S.R.P. => Você tem várias responsabilidades em um único participante.

2. O.C.P. => Se um novo formato de arquivo precisar ser adicionado, você precisará editar seu código.

3. I.S.P. => Você tem uma interface gigante, causando um acoplamento com coisas específicas para imagens em participantes que utilizem vídeos.

4. D.I.P. => Você depende de detalhes dentro da sua classe, detalhes esses referentes a imagens ou vídeos, que não dizem respeito uns aos outros.

João Batista Neto · Novembro 23, 2012

De fato os principios de design de classe são 5 mas ainda tem mais 6 principios em OOD

REP = Release Equivalency Principle

CCP = Common Closure Principle

CRP = Common Reuse Principle

ADP = Acyclic Dependencies Principle

SDP = Stable Dependencies Principle

SAP = Stable Abstractions Principle

Enjoy!

Esses são princípios de empacotamento, relacionados com binários (.jar e similares), não com design de objetos e, principalmente, não tem tanta relevância com PHP até a versão 5.3.

Mas, tá valendo, apesar de não fazer muita diferença para esse tópico.

Gabriel Jacinto · Novembro 24, 2012

Pessoal, desculpa a demora pra resposta, fui dormir na escola.

Bom, vou dar uma bela estudada em tudo o que vocês me passaram sobre OOD e S.O.L.I.D.

:thumbsup:

Gabriel Jacinto · Novembro 25, 2012

Deixar eu ver, eu faria uma classe separada para o redimensionamento, certo?!

Mas para a classe de upload, eu poderia criar uma classe abstrata para pegar as informações do arquivo?

Vinicius Rangel · Novembro 25, 2012

a ideia principal é.

você vai jogar um arquivo para o seu servidor só que não importa qual arquivo é mas isso você não pode tratar dentro da sua própria classe, no caso algo indicado seria uma interface.

Gabriel Jacinto · Novembro 25, 2012

Espera, tente me explicar melhor, como assim? Não entendi isso:

não importa qual arquivo é mas isso você não pode tratar dentro da sua própria classe

Vinicius Rangel · Novembro 25, 2012

http://forum.imasters.com.br/topic/393052-141-metodos-de-interface-e-polimorfismo/

no exemplo, ao invés de ele criar uma classe alvo e fazer um monte de condições dentro para saber que alvo é esse ele simplesmente criou uma interface e então qualquer objeto que ele tiver ele pode definir como alvo.

o que acontece com isso? na hora de chamar o método atira ele não precisa ser um objeto especifico para passar pro parametro.

tentando deixar claro agora.

o método atira aceita qualquer objeto por tanto que ele implemente um alvo, e o método não precisa saber qual é especificamente o alvo, no caso um cachorro ou uma janela, ele só precisa saber que aquele objeto que ele desconhece é um alvo.

para você a ideia é que sua classe pode fazer o upload de qualquer arquivo sem precisar saber que arquivo é esse.

Gabriel Jacinto · Novembro 25, 2012

Uma interface assim ajudaria?

interface NameOfInterface{

public function sizeMax( $size, $type );
public function typeAllower( array $ext );
public function searchErrors();
public function upload( $msg = null );

}

Gabriel Jacinto · Novembro 26, 2012

Desculpe minha ignorância, mas eu não entendi porque isso aqui é public e não protected, se eu irei usar somente na classe de upload:

public function getFile(){
               return $this->file;
       }

       public function getPath(){
               return $this->path;
       }

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

       public function getTmp(){
               return $this->tmpName;
       }

       public function getExt(){
               return $this->ext;
       }

E outra dúvida, eu poderia usar nessa classe os set's né? Pra pegar a extensão do arquivo etc?

Esta estrutura estaria correta?

abstract class InfoOfFile{
//Setters e getters com as informações do arquivo (name, ext etc)
}

class Security extends InfoOfFile{
//Contendo os métodos typeAllowed, siezeMax etc
}

class Upload extends Security{
//Contendo os métodos para a realização do upload
}

Gabriel Jacinto · Novembro 26, 2012

Ei, não fui eu que dei -1, garanto.

Se quiser, dou até +1 pra não ficar desativado.

Dei uma boa reformulada, separei-a em 3 classes, creio que melhorou bem na organização.

abstract class InfoOfFile{

private
       $file,
       $name,
	$tmpName,
       $size,
       $error,
	$ext,
       $path,
       $directoryFinal;

   protected function setFile( $file ){
       $this->file = $file;
   }

   public function getFile(){
       return $this->file;
   }

   public function setPath( $path ){
       $this->path = $path;
       $this->setDirectoryFinal();
   }

   public function getPath(){
       return $this->path;
   }

   protected function setSize(){
       $this->size = $this->file['size'];
   }

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

   public function setName( $name = null ){
       if( $name == null ){
           $this->name = $this->file['name'];
       }else{
           $this->name = $name . '.' . $this->ext;
           $this->setDirectoryFinal();
       }
   }

   public function getName(){
       return $this->name;
   }

   protected function setTmpName(){
       $this->tmpName = $this->file['tmp_name'];
   }

   public function getTmpName(){
       return $this->tmpName;
   }

   protected function setExt(){
       $explode = explode( '.', $this->name );
	$this->ext = end( $explode );
   }

   public function getExt(){
       return $this->ext;
   }

   protected function setError(){
       $this->error = $this->file['error'];
   }

   public function getError(){
       return $this->error;
   }

   protected function setDirectoryFinal(){
           $this->directoryFinal = $this->path . $this->name;
   }

   public function getDirectoryFinal(){
       return $this->directoryFinal;
   }
}

class Security extends InfoOfFile{

       private $sizeMax;
       private $errorList = array();

       public function sizeMax( $size_max, $type ){
           switch( strtolower( $type ) ){
               case "kb":
                   $kb = $size_max;
                   $this->sizeMax = 1024 * $kb;
                   if( $this->sizeMax < $this->getSize() ){
                       die( "O arquivo é muito grande, o máximo é ".$kb."KB" );
                   }
                   break;

               case "mb":
                   $mb = $size_max;
                   $this->sizeMax = 1024 * 1024 * $mb;
                   if( $this->sizeMax < $this->getSize() ){
                       die( "O arquivo é muito grande, o máximo é ".$mb."MB" );
                   }
                   break;

               case "gb":
                   $gb = $size_max;
                   $this->sizeMax = 1024 * 1024 * 1024 * $gb;
                   if( $this->sizeMax < $this->getSize() ){
                       die( "O arquivo é muito grande, o máximo é ".$gb."MB" );
                   }
                   break;

               default:
                   die( "Unidade de medida de tamenho de arquivo inválida" );
                   break;
           }
   }

   public function typeAllowed( array $allowed ){
    if( !in_array( $this->getExt(), $allowed ) ){
       die( "Tipo de arquivo inválido" );
    }
}

   protected function searchErrors(){
               $this->errorsList[0] = 'Não houve erro';
               $this->errorsList[1] = 'O arquivo no upload é maior do que o limite do PHP';
               $this->errorsList[2] = 'O arquivo ultrapassa o limite de tamanho especifiado no HTML';
               $this->errorsList[3] = 'O upload do arquivo foi feito parcialmente';
               $this->errorsList[4] = 'Não foi feito o upload do arquivo';

               if( $this->getError() != 0 ){
                       die( "<b>Ao fazer o upload, erros foram encontrados:</b> " . $this->errorsList[ $this->getError() ] );
               }
       }

}

class Upload extends Security{

   public function __construct( $file ){
       $this->setFile( $file );
       $this->setExt();
       $this->setName();
       $this->setSize();
       $this->setTmpName();
       $this->searchErrors();
       $this->setDirectoryFinal();
   }

   public function upload( $msgSucess = null ){

       $msgSucessDefault = "<script>alert('Upload realizado com sucesso!');</script>";
       echo $this->getDirectoryFinal();
       $upload = move_uploaded_file( $this->getTmpName(), $this->getDirectoryFinal() );

       if( $upload ){
           if( $msgSucess != null ){
               echo $msgSucess;
           }else{
               echo $msgSucessDefault;
           }
       }
   }

}

Henrique Barcelos · Novembro 27, 2012

Pra que a herança???

Gabriel Jacinto · Novembro 27, 2012

Não havia pensado sem herança. Tive que mudar a visibilidade de alguns objetos da classe InfoOfFile para public e a classe Upload ficou da seguinte forma:

class Upload{

   public $security;

   public function __construct( $file ){
       $this->security = new Security();
       $this->security->setFile( $file );
       $this->security->setExt();
       $this->security->setName();
       $this->security->setSize();
       $this->security->setTmpName();
       $this->security->searchErrors();
       $this->security->setDirectoryFinal();
   }

   public function upload( $msgSucess = null ){

       $msgSucessDefault = "<script>alert('Upload realizado com sucesso!');</script>";

       $upload = move_uploaded_file( $this->security->getTmpName(), $this->security->getDirectoryFinal() );

       if( $upload ){
           if( $msgSucess != null ){
               echo $msgSucess;
           }else{
               echo $msgSucessDefault;
           }
       }
   }

}

    $up = new Upload( $_FILES['file'] );
   $up->security->setPath('ups/');
   $up->security->sizeMax( 1500, 'KB' );
   //etc
   $up->upload();

Henrique Barcelos · Novembro 27, 2012

 public function __construct( $file ){
       $this->security = new Security();

Ainda não está bom, tente assim:

public function __construct($file, Security $security) {
   $this->security = $security;

A isso se dá o nome de Injeção de Dependências.

Nesse exemplo final aí estão faltando algumas classes. Poste também.

Gabriel Jacinto · Novembro 27, 2012

As outras duas ficaram assim, mas você não acha que seria ruim ter que chamar duas classes, que problemas poderiam ocorrer sem a Injeção de Dependências?

abstract class InfoOfFile{

private
       $file,
       $name,
	$tmpName,
       $size,
       $error,
	$ext,
       $path,
       $directoryFinal;

   public function setFile( $file ){
       $this->file = $file;
   }

   public function getFile(){
       return $this->file;
   }

   public function setPath( $path ){
       $this->path = $path;
       $this->setDirectoryFinal();
   }

   public function getPath(){
       return $this->path;
   }

   public function setSize(){
       $this->size = $this->file['size'];
   }

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

   public function setName( $name = null ){
       if( $name == null ){
           $this->name = $this->file['name'];
       }else{
           $this->name = $name . '.' . $this->ext;
           $this->setDirectoryFinal();
       }
   }

   public function getName(){
       return $this->name;
   }

   public function setTmpName(){
       $this->tmpName = $this->file['tmp_name'];
   }

   public function getTmpName(){
       return $this->tmpName;
   }

   public function setExt(){
       $explode = explode( '.', $this->name );
	$this->ext = end( $explode );
   }

   public function getExt(){
       return $this->ext;
   }

   public function setError(){
       $this->error = $this->file['error'];
   }

   public function getError(){
       return $this->error;
   }

   public function setDirectoryFinal(){
           $this->directoryFinal = $this->path . $this->name;
   }

   public function getDirectoryFinal(){
       return $this->directoryFinal;
   }
}

class Security extends InfoOfFile{

       private $sizeMax;
       private $errorList = array();

       public function sizeMax( $size_max, $type ){
           switch( strtolower( $type ) ){
               case "kb":
                   $kb = $size_max;
                   $this->sizeMax = 1024 * $kb;
                   if( $this->sizeMax < $this->getSize() ){
                       die( "O arquivo é muito grande, o máximo é ".$kb."KB" );
                   }
                   break;

               case "mb":
                   $mb = $size_max;
                   $this->sizeMax = 1024 * 1024 * $mb;
                   if( $this->sizeMax < $this->getSize() ){
                       die( "O arquivo é muito grande, o máximo é ".$mb."MB" );
                   }
                   break;

               case "gb":
                   $gb = $size_max;
                   $this->sizeMax = 1024 * 1024 * 1024 * $gb;
                   if( $this->sizeMax < $this->getSize() ){
                       die( "O arquivo é muito grande, o máximo é ".$gb."MB" );
                   }
                   break;

               default:
                   die( "Unidade de medida de tamenho de arquivo inválida" );
                   break;
           }
   }

   public function typeAllowed( array $allowed ){
    if( !in_array( $this->getExt(), $allowed ) ){
       die( "Tipo de arquivo inválido" );
    }
}

   public function searchErrors(){
               $this->errorsList[0] = 'Não houve erro';
               $this->errorsList[1] = 'O arquivo no upload é maior do que o limite do PHP';
               $this->errorsList[2] = 'O arquivo ultrapassa o limite de tamanho especifiado no HTML';
               $this->errorsList[3] = 'O upload do arquivo foi feito parcialmente';
               $this->errorsList[4] = 'Não foi feito o upload do arquivo';

               if( $this->getError() != 0 ){
                       die( "<b>Ao fazer o upload, erros foram encontrados:</b> " . $this->errorsList[ $this->getError() ] );
               }
       }

}

Arquivado

Avaliação de classe

Recommended Posts

Gabriel Jacinto 74

Compartilhar este post

Link para o post

Compartilhar em outros sites

01100011cc 15

Compartilhar este post

Link para o post

Compartilhar em outros sites

Evandro Oliveira 331

Compartilhar este post

Link para o post

Compartilhar em outros sites

Gabriel Jacinto 74

Compartilhar este post

Link para o post

Compartilhar em outros sites

Vinicius Rangel 208

Compartilhar este post

Link para o post

Compartilhar em outros sites

João Batista Neto 448

Compartilhar este post

Link para o post

Compartilhar em outros sites

João Batista Neto 448

Compartilhar este post

Link para o post

Compartilhar em outros sites

João Batista Neto 448

Compartilhar este post

Link para o post

Compartilhar em outros sites

Gabriel Jacinto 74

Compartilhar este post

Link para o post

Compartilhar em outros sites

Gabriel Jacinto 74

Compartilhar este post

Link para o post

Compartilhar em outros sites

Vinicius Rangel 208

Compartilhar este post

Link para o post

Compartilhar em outros sites

Gabriel Jacinto 74

Compartilhar este post

Link para o post

Compartilhar em outros sites

Vinicius Rangel 208

Compartilhar este post

Link para o post

Compartilhar em outros sites

Gabriel Jacinto 74

Compartilhar este post

Link para o post

Compartilhar em outros sites

Gabriel Jacinto 74

Compartilhar este post

Link para o post

Compartilhar em outros sites

Gabriel Jacinto 74

Compartilhar este post

Link para o post

Compartilhar em outros sites

Henrique Barcelos 290

Compartilhar este post

Link para o post

Compartilhar em outros sites

Gabriel Jacinto 74

Compartilhar este post

Link para o post

Compartilhar em outros sites

Henrique Barcelos 290

Compartilhar este post

Link para o post

Compartilhar em outros sites

Gabriel Jacinto 74