Mostrando entradas con la etiqueta Ficheros. Mostrar todas las entradas
Mostrando entradas con la etiqueta Ficheros. Mostrar todas las entradas

martes, 5 de enero de 2016

Descargando ficheros desde una web con PHP

 
En este artículo mostraré con un ejemplo muy sencillo cómo copiar un fichero desde un sitio hacia otro, es decir, tenemos un fichero en una dirección http://sitio_externo/path/file.ext y queremos compartirlo en nuestro sitio http://mi_sitio/downloads/file.ext, o sencillamente queremos copiarlo hacia nuestro sitio servidor no se desee publicar.
Partimos de que el código PHP se ejecuta en nuestro sitio “mi_sitio”, por lo que tendríamos que descargar el fichero desde la web externa y copiarlo hacia la carpeta downloads en la raíz de nuestro sitio.
Para esto no copiaremos el fichero completamente, sino que utilizaremos las funciones de PHP de trabajo con ficheros (abrir ficheros, crear ficheros, copiar con fwrite…). Veamos el siguiente código:
   1: //capturar fuente por input o por cualquier vía, ejemplo http://sitio_externo/path/file.ext

   2: $http_path = …; 

   3:  

   4: //carpeta destino en nuestro servidor

   5: $upload_path = './downloads/';

   6:  

   7: //estableciendo un timeout límite para copiar

   8: set_time_limit (24 * 60 * 60);

   9:  

  10: //fichero destino incluyendo el path

  11: $newfname = $upload_path.basename($http_path);

  12:  

  13: //si se puede abrir el fichero fuente en modo lectura, se copia el contenido al fichero destino en modo escritura, por pedazos

  14: $source_file = fopen ($http_path, "rb");

  15: if ($file)

  16: {

  17:     $target_file = fopen ($newfname, "wb");

  18:  

  19:     if ($target_file)

  20:     {

  21:         while(!feof($source_file))

  22:             fwrite($target_file, fread($file, 1024 * 8 ), 1024 * 8 );

  23:          }

  24:      }

  25:  

  26: if ($source_file) fclose($source_file);

  27: if ($target_file) fclose($target_file);
Este método permite pasar el contenido de un fichero al otro por pedazos, lo que garantiza que no haya un límite de tamaño por el servidor. El límite de tiempo lo ponemos por seguridad.
Espero sea de utilidad este artículo.



{ Leer Más }


martes, 27 de octubre de 2015

Cargar varios archivos usando CodeIgniter con JQuery 2

En el presente artículo continuaremos hablando del método para cargar múltiples ficheros usando CodeIgniter con JQuery.

En el articulo pasado, hablamos de como crear de manera dinámica múltiples componentes visuales en tiempo real usando JQuery.

Ahora pasaremos al trabajo con CodeIgniter. Lo primero que tienes que tener en cuenta es que el formulario que creaste en la vista tienes que declararlo multipart.

   1: form_open_multipart()


Esta función es absolutamente idéntica a form_open(), excepto que agrega un atributo multipart que es necesario si quisiera usar el formulario para subir archivos.

Una vez tenido esto claro. En nuestro controlador realizamos una función para cargar por un post la información de los componentes visuales que creamos anteriormente en nuestra vista.

Para esto empleamos la clase de subir ficheros de CodeIgniter. En el siguiente ejemplo especifico la carpeta hacia la que voy a subir el fichero, el tipo de fichero que quiero recibir (* para cualquier tipo), el tamaño máximo de fichero. El overwrite permite sobrescribir los ficheros en el servidor. He cargado la clase upload que trae CodeIgniter en una de sus bibliotecas, y al cargarla le he pasado mi configuración. Y por último la cantidad de ficheros que voy a cargar. Como en otros artículos referentes a este tema, no tratare lo de la validación de carga de ficheros ya que por ahora no es el objetivo aunque no deja de ser necesario e importante.



   1: function nomre_de_la_funcion()
   2: {
   3:     $config['upload_path']   = './uploads/';
   4:     $config['allowed_types'] = 'gif|jpg|png|doc|rar|zip|xls';
   5:     $config['overwrite']     = TRUE;
   6:       $config['max_size']     = '100';
   7:     $file_number = $this->input->post('file-number');
   8:         
   9:       $this->load->library('upload', $config);
  10:     
  11:  
  12:  
  13:      for($i = 0; $i< $file_number; $i++)
  14:             $this->upload->do_upload('file_name'.$i)}  


Si resultó positivo puedes acceder al nombre del fichero, que ya está en el servidor, a través del mismo $_FILES ['file_name]['name'], y guardar el nombre en la base de datos.

Otra vía para subir varios ficheros desde un mismo formulario, puedes ponerle a todos los input files el mismo nombre con corchete (ej. file_name[]), y accedes a ellos a través de:



   1:  
   2: $_FILES['filename']['name'][0];
   3: $_FILES['filename']['name'][1];
   4:
   5:       


Como habrás podido ver, esta es una vía muy sencilla para la carga de múltiples ficheros, y a mí, en lo particular me funcionó. Espero que sea de ayuda para futuras soluciones a problemas de este tipo.

{ Leer Más }


miércoles, 14 de octubre de 2015

Cargar varios archivos usando CodeIgniter con JQuery 1

En este artículo quiero mostrarles una solución bastante sencilla para generar varios componentes visuales para cargar múltiples archivos.

Partiendo de la necesidad que tuve de subir al servidor varios archivos, y teniendo en cuenta que con el siguiente código incorporas el componente visual que te permite escoger un fichero.

   1: <input type="file" name="file_name" id="file_id"/>

image


Una variante que tienes para subir múltiples archivos es la de predefinirlos con nombres diferentes pero entonces te limitarías a subir solo la cantidad de predefiniste.

La solución que utilicé para darle solución a mi problema fue de ir adicionando en tiempo real, tantos componentes visuales como necesitara. Para esto le adicioné al lado del componente visual un vínculo vacío con el texto “adicionar”, que es el que se va a cargar con la función de adicionar más elementos visuales. Y un componente input de tipo hidden que fuera almacenando la cantidad de componentes que fuese creando.



   1: <input type="hidden" id="file-number" name="file-number" value="1" />


Inicialmente tiene el valor 1 (value="1") porque por defecto ya tengo creado un componente visual.

Creo un div contenedor que es el que va a tener el elemento actual y los elementos que voy creando.



   1: <div id="file-list">
   2:   Aquí van todos los elementos visuales que se irán creando
   3: </div>


Luego dentro de ese div adiciono el primer componente que se visualizará por defecto y quedaría de esta forma



   1: <div id="file-list">
   2: <input type="file" name="file_name0" id="file_id0"/><a href="" id="add-file" name="add-file">adicionar</a>  
   3: </div>

image

Una vez introducido el código anterior voy a generar usando JQuery tantos componentes visuales como necesite.



   1: <script type="text/javascript">
   2: $(document).ready(function(){
   3:   $('.add-file').live('click',function(event){
   4:         event.preventDefault();               
   5:         var  pos = Number($("#file-number").val());
   6: var new_component = ' <div class="file"> <input type="file"  name="file_name'+pos+'" id=" file_id'+pos+'" /> &nbsp;<a href="" id="del-file" class="del-file">eliminar</a></div>';
   7: $('#file-list).append(new_component);                        $("#file-number").val(Number($("#file-number").val())+1);
   8:     });
   9: });
  10: </script>

La variable pos guarda el número actual del componente oculto (<input type="hidden"……) que me servirá para darle nombre diferente a los componentes que voy creando.



   1: var new_component = ' <div class="file"> <input type="file"  name="file_name'+pos+'" id=" file_id'+pos+'" /> &nbsp;<a href="" id="del-file" class="del-file">eliminar</a></div>';

Nótese que en la variable new_component voy creando un input de tipo file con el mismo nombre lo que lo diferencia es el final que es el valor del componente de tipo hidden que creé este también me servirá más adelante para saber la cantidad de componentes que tengo en mi página y para saber la cantidad de veces tengo que recorrer el ciclo para adicionar todos los archivos de que seleccioné y además un nuevo componente que es un vínculo vacío que tendrá como id del-file con el texto eliminar que será al que le cargaré la función de eliminar el componente al cual se encuentra asociado. Y todos estos elementos dentro de un div que contendrá el input y el href con el texto eliminar

Le adiciono al div con el id file-list el código html que almaceno en la variable new_component.



   1: $('#file-list).append(new_component);              

Y por último aumento el valor del componente oculto (<input type="hidden"……).



   1: $("#file-number").val(Number($("#file-number").val())+1);

Luego el eliminar quedaría de esta manera:



   1: $('.del-file').live('click', function(event){     
   2:         event.preventDefault();         
   3:  $("#file-number").val(parseInt($("file-number").val())-1);      
   4:  $(this).parent().remove();
   5:  });

Y al final quedaría un código javascript similar a este



   1: <script type="text/javascript">
   2: $(document).ready(function(){
   3:   $('.add-file').live('click',function(event){
   4:         event.preventDefault();               
   5:         var  pos = Number($("#file-number").val());
   6: var new_component = ' <div class="file"> <input type="file"  name="file_name'+pos+'" id=" file_id'+pos+'" /> &nbsp;<a href="" id="del-file" class="del-file">eliminar</a></div>';
   7: $('#file-list).append(new_component);                        $("#file-number").val(Number($("#file-number").val())+1);
   8:     });
   9: });
  10: $('.del-file').live('click', function(event){     
  11:         event.preventDefault();         
  12:  $("#file-number").val(parseInt($("file-number").val())-1);      
  13:  $(this).parent().remove();
  14:  });
  15:  
  16:  
  17: </script>







image


Hasta aquí este código me ha funcionado sin problemas.

En la segunda parte de este articulo te hablaré sobre la carga de múltiples archivos con CodeIgniter.

{ Leer Más }


lunes, 15 de diciembre de 2014

Conociendo la estructura de un proyecto Android.

En los artículos anteriores sobre la programación en Android, vimos una breve reseña de lo que es Android y su historia y luego abordamos cómo preparar nuestro ambiente de desarrollo para estar listos para adentrarnos en este fascinante mundo.

Pero antes de escribir una línea de código es importante conocer la estructura de un proyecto Android de forma que a la hora de programar podamos saber de forma exacta donde encontrar cada recurso.

Cuando creamos un proyecto de Android en Eclipse se crean una serie de carpetas y ficheros para luego generar la aplicación. Esta estructura será común para cualquier tipo de aplicaciones, independientemente de la versión para la que la estemos desarrollando o su complejidad.

A continuación veremos una imagen con la estructura inicial de Android:

image

Para un mejor entendimiento vamos a explicar los elementos principales de esta estructura de ficheros.

Carpeta src

Como su nombre lo sugiere, es en esta carpeta donde estará todo el código fuente de la aplicación, la programación de la interfaz gráfica, clases auxiliares, entre otras. En un inicio se creará el código elemental del Activity principal de la aplicación.

Carpeta res

Es en esta carpeta donde estarán los recursos necesarios que se utilizarán en la aplicación como son los textos, las imágenes, los videos, entre otros. Dentro de la carpeta res existen otras carpetas con el objetivo de organizar aún mejor los recursos.

image

Vamos a dar un breve repaso de lo que son cada una de destas carpetas

drawable: Contiene las imágenes. Se puede dividir en drawable-ldpi, drawable-mdpi y drawable-hdpi. Los recursos se pondrán en cada una de estas carpetas dependiendo de la resolución del dispositivo que esté consumiendo la aplicación.

layout: Contiene la estructura XML de las pantallas de la interfaz gráfica. Esta carpeta se puede subdividir en layout y layaout-land para diferenciar por la orientación del dispositivo.

anim: Contiene las animaciones de la aplicación.

menú: Contiene la definición de los menús de la aplicación.

values: Contiene recursos como son los textos, los estilos, los colores, entre otros.

xml: Contiene los ficheros XML utilizados por la aplicación.

raw: Contiene recursos adicionales que no sean XML.

Carpeta gen

Es en esta carpeta donde se almacena el código que se genera automáticamente al compilar el proyecto. De estos códigos es importante particularizar en el fichero R.java que es la que contiene la clase R que es donde se almacenan una serie de constantes con los ID de los recursos incluidos en la carpeta res. Esto nos posibilita que desde el código podamos acceder fácilmente a estos recursos.

Carpeta assets

En esta carpeta se van a almacenar los ficheros auxiliares. La diferencia de estos ficheros con los de que se pondrán en la carpeta res/draw es que estos últimos se podrán acceder desde el código a través de la ya mencionada clase R mientras que los de la carpeta assets se tendrá que acceder a través de su ruta.

Fichero AndroidManifest.xml

Es un fichero escrito en XML con los aspectos principales de la aplicación. Ahí nos vamos a encontrar el nombre, los componentes que usan, los permisos de la aplicación entre otras cosas.

Esto es lo esencial de la estructura de ficheros de un proyecto Android, conociendo esto, ya estaremos listos para próximamente desarrollar una pequeña aplicación para Android.

{ Leer Más }


jueves, 3 de abril de 2014

Utilizando el componente Plupload desde Php para subir múltiples archivos

Plupload, disponible en http://www.plupload.com, es un excelente componente que podemos utilizar para subir múltiples archivos desde una interfaz atractiva y con pocas líneas de código. En este artículo mostraremos como utilizar este componente desde Php y especialmente utilizando CodeIgniter.

La interfaz básica de este componente es como la que se muestra en la siguiente imagen:

image

En su interfaz tenemos dos botones, uno para agregar archivos y otro para comenzar la subida al servidor de los archivos que hemos cargado. Lo primero que tenemos que realizar para poner a funcionar este componente es adicionar correctamente al proyecto los estilos (css), las imágenes y los archivos javascript que utiliza el componente, y que se encuentran disponibles en http://www.plupload.com/download/ .

Después en el código javascript agregamos la siguiente función:

<script type="text/javascript">
// Initialize the widget when the DOM is ready
$(function() {
$("#uploader").plupload({
// General settings
runtimes : 'html5,flash,silverlight,html4',
url : " controller/multiple_upload",
// Maximum file size
max_file_size : '10mb',
chunk_size: '1mb',
// Resize images on clientside if we can
resize : {
width : 200,
height : 200,
quality : 90,
crop: true // crop to exact dimensions
},
// Specify what files to browse for
filters : [
{title : "Image files", extensions : "jpg,gif,png"},
{title : "Zip files", extensions : "zip,avi"}
],

// Rename files by clicking on their titles
rename: true,
// Sort files
sortable: true,
});
});
</script>

Prestar atención al parámetro url que es donde especificaremos a que controller/function se va a invocar para realizar la subida de los ficheros. Existen otros parámetros interesantes como max_file_size para especificar el tamaño máximo de los archivos, filters que especifica qué tipo de archivos permitiremos subir desde el componente, o runtimes donde especificaremos con cuál plataforma queremos que funcione el componente, pudiéndose especificar más de una y se utilizarán la primera que aparezca de la lista definida.

En el código html colocamos el siguiente bloque de contenido, con el cual se visualizará nuestro componente:

<div id="uploader">
<p>Your browser doesn't have Flash, Silverlight or HTML5 support.</p>
</div>

Si el componente no funciona se muestra el error especificado. Al dar clic en el botón “Start Upload” se llamará a la función que hemos especificado para subir cada uno de los archivos. Como en este caso estamos utilizando CodeIgniter podemos utilizar la librería upload para subir archivos que nos proporciona este framework, y la función multiple_upload será como sigue:

public function multiple_upload()
{
$dir_upload = './uploads/';
$config['upload_path'] = $dir_upload;
$config['allowed_types'] = 'jpg|gif|png|avi|zip';
$config['max_size'] = '10240';
$config['overwrite'] = true;

$this->load->library('upload', $config);
if(!file_exists($config['upload_path'])){
mkdir ($config['upload_path'], 0775, true);
}
if ($this->upload->do_upload('file') )
{
//do
}
}

Otro comportamiento que podemos desear para utilizar este componente es no hacer la subida de los archivos a través del botón que se establece para ello, sino por ejemplo cuando enviamos un formulario completo. En este caso no utilizaríamos el botón plupload_start, una de las formas de ocultarlo es modificando el estilo del botón:

<style type="text/css">
.plupload_button.plupload_start
{
display:none;
}
</style>

Y como queremos subir los ficheros justo cuando se envía el formulario (en este caso current_form) tendríamos que especificarlo en el submit del mismo:

$(document).ready(function() {   
$("#current_form").submit(function(e) {
var uploader = $('#uploader').pluploadQueue();
// Files in queue upload them first
if (uploader.files.length > 0) {
// When all files are uploaded submit form
uploader.bind('StateChanged', function() {
if (uploader.files.length === (uploader.total.uploaded + uploader.total.failed)) {
$('form')[0].submit();
}
});
uploader.start();
return false;
}
//Other events
return true;
})
});

Con estos sencillos pasos tendremos una forma sencilla de subir múltiples ficheros utilizando el componente Plupload, ya sea cargándolos de una vez desde la forma básica o utilizando un formulario.

Es todo, espero haya sido de utilidad.

{ Leer Más }


miércoles, 19 de febrero de 2014

Leer ficheros de texto con Php.

En algunas aplicaciones nos es necesario entrar información al sistema obtenida desde ficheros de texto en lugar de utilizar formularios. Por ejemplo si tenemos facturas de productos vendidos, el proceso sería más rápido si cargamos estos ficheros y procesamos la información que nos interesa en un proceso automático.

En este artículo queremos brindar algunas prácticas interesantes para realizar este procesamiento utilizando las ventajas para el trabajo con ficheros que nos brinda Php.

Por ejemplo utilizando el caso de productos que habíamos mencionado, supongamos que tenemos un fichero en formato txt que tiene la información de una factura, pondremos un caso bien sencillo donde tenemos el número de factura, algunos datos adicionales del emisor y receptor de la factura y una tabla que contiene los detalles de la venta realizada:

En este caso podemos leer el fichero línea a línea e ir realizando las validaciones que nos interesan y recoger la información. Para realizar el procesamiento del fichero e ir sacándonos del programa cuando se encuentre que no cumple algunas reglas de validación podemos usar las sentencias Try-catch y lanzamos el error detectado.

Por ejemplo:

<?php          
try{
if (file_exists("Factura.txt")===FALSE)
throw new Exception('El fichero no existe.');
$text = file_get_contents("Factura.txt");
if ($text === FALSE)
{
throw new Exception('El fichero no puedo ser leído.');
}
$text= mb_convert_encoding($text, 'UTF-8',mb_detect_encoding($text, 'UTF-8, ISO-8859-1', true));
$texts = explode("\n",$text);
echo "Fichero leído correctamente." ;
}
catch (Exception $e)
{
echo 'Excepción capturada: ', $e->getMessage(), "\n";
}
?>

Con la función file_exists verificamos que efectivamente el fichero exista en nuestro directorio, y procedemos a leer el archivo completo como una única cadena con file_get_contents, en caso de fallo esta función devuelve false. Y finalmente en este bloque dividimos esa cadena en líneas, para esto hacemos uso de una función muy interesante para este caso que es la función explode que divide una cadena ($text) por otra (“/n”) en este caso fin de línea y nos devuelve una matriz que contiene las subcadenas contenidas en la cadena $text y separadas por el fin de línea. Ya con esto tenemos en $texts el fichero línea a línea.

Para las primeras cuatro líneas hacemos un procesamiento similar en todos los casos, siempre debe leerse una etiqueta determinada y después la información asociada a esta etiqueta:

$invoice_no = trim($texts[0]);
$invoice_no = explode("Factura No.",$invoice_no);
if(count($invoice_no)!=2)
throw new ErrorException('La etiqueta "Factura No." no existe o está escrita incorrectamente');
$invoice_no = trim($invoice_no[0]);

Siempre es interesante utilizar la función trim para eliminar los espacios en blanco (u otros caracteres) del principio y final de la cadena. Siempre verificamos en estos caso que la cantidad de elementos contenidos en la matriz $invoice_no después de aplicar explode no puede ser diferente de 2, porque si la información viene correctamente en la posición 1 vamos a obtener la que nos interesa.

Lo que sigue es leer la información de la tabla de productos, para eso primeramente verificamos que los datos de la cabecera sean correctos, comparándolo con un arreglo que previamente tenemos y después en un ciclo recorremos los productos hasta llegar al fin de la tabla, asumimos que terminamos la lectura de la tabla cuando llegamos a encontrar la cadena “Total:” que es lo que sigue detrás de la misma.

$cabecera = array('Cantidad','Nombre','Precio Unitario', 'Descuento', 'Importe');
$cabecera_tabla = trim($texts[5]);
$cabecera_tabla = explode("\t",$cabecera_tabla);
$result= array_diff($cabecera_tabla,$cabecera);
if(!empty($result))
throw new ErrorException("Los datos de la cabecera de la tabla de productos están escritos incorrectamente");

$datos = array();
$tabla = true;
$no_producto = 0;
$j= 6;
while ($tabla==TRUE)
{
//Verificar si se terminó la tabla
$end = strpos($texts[$j], 'Total:');
if($end === FALSE)
{
$detalle = explode("\t",trim($texts[$j]));
$datos[$no_producto]->CANTIDAD = $detalle[0];
$datos[$no_producto]->NOMBRE = $detalle[1];
$datos[$no_producto]->PRECIOUNITARIO = $detalle[2];
$datos[$no_producto]->DESCUENTO = $detalle[3];
$datos[$no_producto]->IMPORTE = $detalle[4];
$no_producto++;
$j++;
}
else
{
//termino la tabla
$tabla = false;
}
}

La función strpos devuelve la posición numérica de la primera aparición de una cadena, si necesitáramos la cadena en sí utilizáramos strstr aunque esta última es más lenta y consume más memoria. Si no queremos distinguir entre mayúsculas y minúsculas podemos utilizar stripos y stristr.

Es todo, espero haya sido de utilidad.

{ Leer Más }


IconIconIcon