Clase upload

[cesarpunk]

Hola, estoy creando una clase para subir archivos pero quisiera hacerlo lo más reutilizable posible, lo malo es que los parámetros de mi funcion "Upload()" dependen también de los campos demás campos de un formulario (como texfiles combox, etc), quisiera que mi clase sólo devuelva la ruta, el tipo y el peso para poder almacenar estos datos en la BD mediante otro método independiente (quizás de otra clase diferente)... actualmente lo estoy implementando asi:

Código PHP:

  <?php
//...
 
//Método para subir rl archivo al servidor
     public function UploadFile($nombre,$categoria,$file_upload,$file_name,$file_size,$target_path){
         //Reporte de Salida : 0(campo vacio), 1(excedio peso), 2(tipo de archivo), 3(existe separata), 4(subio)
     
        if ($this->validTypeFile($file_name)==true){
            if($file_size<1048576){//1MB
                if (!file_exists($target_path)){                          
                    if(@move_uploaded_file($file_upload, $target_path)){
                    
                        //guardamos los datos
                        $size_archivo = $this->sizeFile($file_size);
                        $type_archivo = $this->typeFile($file_name);
                        $saveFile = $this->addFile($nombre,$categoria,$target_path,$type_archivo,$size_archivo);
                        if($saveFile==true){$report = 4;}
                            
                    }else{$report = 0;}
                }else{$report = 3;}/*en esta seccion ingresa el file repetido, en caso de pasar... le mandamos error*/
            }else{$report = 1;}
        }else{$report = 2;}
        
        return $report;
     }
 
 
     //Método para registrar el archivo en le BD
     public function addFile($nombre,$categoria,$raiz_archivo,$tipo_archivo,$peso_archivo){
        $today = date("Y-m-d H:i:s");
        
        $sql = "INSERT INTO archivo(archivo_nombre,categoria_id,archivo_path,archivo_tipo,archivo_peso,archivo_fecha) VALUES('".$nombre."','".$categoria."','".$raiz_archivo."','".$tipo_archivo."','".$peso_archivo."','".$today."');";
        $result = $this->db->ejecutar($sql);
        if(!$result){    
            exit('Perdonen las molestias. Tenemos un problema técnico. Esperamos resolverlo en los próximos minutos');
        }else{return true;}
     }
?>   

Como en este ejemplo, en la funcion pongo $nombre y $categoria, campos de un formulario, cosa que sólo deberían estar en la funcion addFile() que guarda en la bd, mi intención es que UploadFile() sólo devuelva $target_path,$type_archivo,$size_archivo... pero como retorno estos valores en caso quiera mandarlos a otro método (quizas de otra clase) como array dentro de una variable de sesion? como una instancia? espero me puedan recomendar alguna solución, ya que no quiero estar creando la misma función por cada formulario diferente que tenga un input file.

[pateketrueke]

porque no buscas una clase similar en Internet, la lees, la estudias, la analizas, reflexionas e intentas aplicar lo aprendido a tu clase??

[GatorV]

Te dejo un ejemplo de una clase que uso:

Código PHP:

<?php
//
// +------------------------------------------------------------------------+
// | File Operations                                                                   |
// +------------------------------------------------------------------------+
//
 
require_once dirname(__FILE__) . '/Interface.php';
 
/**
 * File Object
 *
 * @author  Christopher Valderrama <[email protected]>
 */
class File_Upload implements File_Interface
{
    /**
     * The file info array
     * @var array
     */
    private $_file;
    
    /**
     * Creates a new File Object for processing upload files
     * 
     * @param string $sFileName
     */
    public function __construct($sFileName)
    {
        if (!isset($_FILES)) {
            throw new Exception('No File upload detected');
        }
        if (!isset($_FILES[$sFileName])) {
            throw new Exception('File ' . $sFileName . ' not found in upload array');
        }
        
        $this->_file = $_FILES[$sFileName];
    }
    
    /**
     * Returns the file name
     *
     * @return string
     */
    public function getName()
    {
        return $this->_file['name'];
    }
    
    /**
     * Returns the file type
     *
     * @return string
     */
    public function getType()
    {
        return $this->_file['type'];
    }
    
    /**
     * Returns the file size
     *
     * @return string
     */
    public function getSize()
    {
        return $this->_file['size'];
    }
    
    /**
     * Returns the file extension 
     *
     * @return string
     */
    public function getExtension()
    {
        return strstr('.', $this->getName());
    }
    
    /**
     * Returns the Temporary file name and path
     *
     * @return string
     */
    public function getTemporaryName()
    {
        return $this->_file['tmp_name'];
    }
    
    /**
     * Returns the error code
     *
     * @return integer
     */
    public function getErrorCode()
    {
        return $this->_file['error'];
    }
    
    /**
     * Checks if the file is uploaded correctly
     *
     * @return bool
     */
    public function noErrors()
    {
        return ($this->getErrorCode() == UPLOAD_ERR_OK);
    }
    
    /**
     * Moves the file to a new location
     * 
     * @param string $sDestination
     * @param string $sNewFileName
     * @return bool
     */
    public function moveFile($sDestination, $sNewFileName = '') {
        if (!$this->isUploaded()) {
            throw new Exception('Invalid upload file, error code:' . $this->getErrorCode());
        }
        
        if (!is_dir($sDestination)) {
            throw new Exception("Invalid Destination path: $sDestination");
        }
        
        if (empty($sNewFileName)) {
            $sFileName = $this->getName();
        } else {
            $sFileName = $sNewFileName;
        }
        
        return move_uploaded_file($this->getTemporaryName(), $sDestination . '/' . $sFileName);
    }
    
    /**
     * Checks if a file isUploaded
     * 
     * @return bool
     */
    public function isUploaded()
    {
        return ($this->noErrors() && is_uploaded_file($this->getTemporaryName()));
    }
    
    /**
     * Cleanup on destruction
     * @return void
     */
    public function __destruct()
    {
        if (file_exists($this->getTemporaryName())) {
            unlink($this->getTemporaryName());
        }
    }
}
 

Interface:

Código PHP:

<?php
//
// +------------------------------------------------------------------------+
// | File Operations                                                                   |
// +------------------------------------------------------------------------+
//
 
/**
 * File Interface
 *
 * @author  Christopher Valderrama <[email protected]>
 */
interface File_Interface
{
    /**
     * Returns the Filename
     * @return string
     */
    public function getName();
    /**
     * Returns the File type
     * @return string
     */
    public function getType();
    /**
     * Returns the File size
     * @return int
     */
    public function getSize();
    /**
     * Moves this file to a new place
     * @param string $sDestination the path file destination
     * @param string $sNewFileName optionally you can pass a new file name
     * @return bool
     */
    public function moveFile($sDestination, $sNewFileName = '');
}
 

La razón de tener una interface es que también tengo otra clase para trabajar con archivos locales, lo que me da flexibilidad en su uso.

Para usarla hago algo así:

Código PHP:

$File = new File_Upload('picture');
$File->moveFile('./uploads');
$sFileName = $File->getName();
$nSize = $File->getSize();
 

Saludos.

[cesarpunk]

Hola Gatorv, gracias por tu respuesta... entiendo varias cosas de tu clase, está muy interesante. Pero un par de preguntas:

Si tu tuvieras que validar el peso, el tipo u otras cosas... lo harías dentro de la funcion moveFile() o crearías otros métodos para eso?

Y siguiendo con el moveFile() que te retorna el move_uploaded_file() ... un true/false? Porque dependiendo de eso tendría que guardar los registros en la BD.

Yo hacia métodos parecidos al gettype y getsize (como muestro en mi ejemplo) pero para validar el file y retornaba un indicador de error para la validación del formulario. No retornaba el peso u otros valores del file como la haces en esas funciones de interface que por cierto no estaba muy enterado y las comenzaré a aplicar.


Trataré de modificar mi clase al ejemplo que me has mostrado, muchas gracias!

[GatorV]

Validar el peso o el tipo ya es parte de la implementación, y como tu comentabas primeramente puede variar en cada proyecto o tipo de requermiento por lo que en ese caso yo extendería la clase y le agregaría un método para checar eso, o hacerlo concretamente en la implementación de la clase.

move_uploaded_file en efecto, regresa true o false dependiendo de si se pudo o no mover el archivo, te recomiendo veas el Manual.

Saludos.