Explorando la Categoría: "Programación"
PHP Scaffolding
Phpscaffold es una aplicación online muy útil si eres desarrollador PHP y MySQL. Se trata de una aplicación de scaffolding, que, para el que no lo sepa, es una técnica de programación que se basa en generar código de programación a partir de información de la base de datos. Es decir, mediante el esquema de la base de datos es capaz de generar código capaz de introducir, leer, modificar y eleminimar (CRUD) valores de la base de esa base de datos.
La aplicación pide las sentencias SQL necesarias para crear las tablas y a partir de ahí genera el código PHP. Estas sentencias SQL son muy fáciles de obtener a partir de phpMyAdmin,exportando la tabla. Luego solo habrá que configurar el config.php adecuadamente y listo. Ya tenemos el código CRUD generado, ahora si quieres lo puedes personalizar, añadir CSS, etc.. pero el trabajo sucio ya está hecho… una maravilla.
Estas técnicas son muy utilizadas en Frameworks como CakePHP o ruby on rails, y la verdad es que acelera mucho el desarrollo y le resta monotonía.
Yo suelo programar muchos componentes en Joomla y he hechado esta caracteristica mucho de menos, por lo que el otro día me puse a hacer unos scripts en bash para Linux que automatizan este proceso, y generan componentes de Joomla. Dentro de poco espero tenerlo acabado y lo subiré para que el que quiera lo pueda usar.
Enlace: http://www.phpscaffold.com/
Últimamente me ha dado por ponerme un poco al día en C#, y es que la noticia de que Micrososft haya liberado el framework ASP.NET MVC bajo licencia MS-PL, es decir, como software libre, me ha motivado bastante para ponerme con esta tecnología. Pero antes de entrar al trapo con ASP.NET MVC, he querido echar un vistazo a las alternativas de BBDD de las que disponía para programar con Mono en Linux.
Después de mirar los diferentes SGBD de que disponía decidí quedarme con MySQL, porque que estoy muy familiarizado ya que en PHP casi siempre me ha tocado usar esta base de datos. Postgre SQL me ha parecido me ha parecido una alternativa muy buena a MySQL, sobre todo después de la incertidumbre que se me ha generado después de la compra de Sun por parte de Oracle.
Para conectar con MySQL desde .NET lo primero que hay que hacer es bajarse el conector desde el sitio web de MySQL. Yo he bajado la versión 5.2, aunque ya van por la 6.0. Bajaros el que pone “Windows Binaries, no installer ”, estos son los binarios compilados para Windows del conector,es decir, el ensamblado, o dll, como quieras llamarlo.
No te asustes, que aunque estén compilados para Windows, Mono es compatible con estos binarios.
Una vez descargado el fichero lo descomprimes y lo que nos interesa es el directorio “bin”, donde se encuentra la dll del conector.
Ahora hay que instalar el ensamblado en la caché de ensamblados global de Mono, esto se hace con la utilidad gacutil, para ello usamos el comando:
sudo gacutil -i MySql.Data.dll
Se supone que se ha descomprimido el paquete del conector y se tiene acceso al directorio bin, donde se encuentra el fichero MySql.Data.dll.
Ahora ya se encuentra instalado el ensamblado en el entorno Mono.
Lo siguiente es abrir monodevelop y crear un nuevo proyecto, yo lo he creado de consola. Hace poco escribí un post donde puse un vídeo con el proceso de instalación de monodevelop en Suse Linux 11.1, por si te lías con la instalación.
Crear un proyecto de consola en Monodevelop
Ahora pinchamos con el botón derecho del ratón sobre el directorio Referencias->Editar Referencias.
Agregar referencia a System.Data
Hay que agregar el ensamblado del conector que acabamos de descargar y una referencia a la librería System.Data de .NET para trabajar con bases de datos.
Agregar el ensamblado del conector MySQL en Monodevelop
Ahora ya podemos comenzar a programar usando el conector de MySQL desde Mono. Yo he creado una base de datos llamada “NET” y he creado una tabla dentro de ella, a continuación pongo el código SQL necesario para crear la tabla.
CREATE DATABASE `NET` ; CREATE TABLE `NET`.`miTabla` ( `id` INT NOT NULL AUTO_INCREMENT , `cuerpo` VARCHAR( 300 ) NOT NULL , PRIMARY KEY ( `id` ) ) ENGINE = MYISAM ; INSERT INTO `NET`.`miTabla` ( `id` , `cuerpo` ) VALUES ( NULL , 'datos de prueba, 1' ), ( NULL , 'más datos de prueba, 2' );
El ejemplo que he creado es muy simple, uso un Reader para obtener los datos de la tabla, lo recorro y lo imprimo por la pantalla.
A continuación pongo el código.
using System; using System.Data; using MySql.Data.MySqlClient; namespace pruebaMySQL { class MainClass { public static void Main(string[] args) { string connectionString = "Server=localhost;Database=NET;User ID=root;Password=;Pooling=false;"; MySqlConnection conn = new MySqlConnection(connectionString); string query = "SELECT id,cuerpo FROM miTabla"; conn.Open(); MySqlCommand myCommand = new MySqlCommand(query, conn); MySqlDataReader myReader = myCommand.ExecuteReader(); while (myReader.Read()) { Console.Write("El ID es: " + myReader["id"].ToString()); Console.WriteLine(" El cuerpo es: " + myReader["cuerpo"].ToString()); } myReader.Close(); myCommand.Dispose(); conn.Close(); } } }
Se han añadido los espacios de nombres a : System.Data y MySql.Data.MySqlClient, necesarios para trabajar con el conector de MySQL sin tener que estar poniendo siempre la ruta completa de cada objeto.
En la connectionString se ha de poner la cadena con este formato siempre a piñón fijo, sustituyendo los valores dependiendo del servidor y base de datos que quieras consultar. En el objeto myReader se almacena el resultado de la consulta, que se ejecuta con el método ExecuteReader del objeto mySqlCommand, que a su vez necesita una conexión con el servidor (objeto mySqlConnection) y una string que contenga la consulta SQL que se desea realizar (query). Como se puede comprobar es muy sencillo.
Es importante cerrar el reader con el método Close, ejecutar el método Dispose del objeto myCommand para liberar memoria, y cerrar la conexión (objeto conn) con el método Close, para cerrar el socket con el servidor de MySQL y colapsarlo.
Por último, pulsamos F5 y …
Ejecución del programa
Como listar los directorios de un directorio con el framework de Joomla
Frameworks, Joomla, Programación
David | 7/05/2008
Esta vez voy a anotar un pequeño trozo de código que me ha servido de mucho en mi último trabajo.
No es ningún secreto saber cómo se listan los directorios, pero gracias al API de de Joomla! es mucho más sencillo, además se integra con la capa FTP para solucionar problemas cuando no tengamos permisos de escritura en nuestro script.
Para listar los directorios simplemente puse en siguiente código en el fichero view.html.php de mi componente:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | jimport( 'joomla.filesystem.folder' ); //Importamos los ficheros necesarios $carpetas = JFolder::folders(JPATH_COMPONENT.DS.'miDirectorio'); //Obtenemos los directorios, el metodo folders devuelve un array con el nombre de los //directorios if(count($carpetas > 0)) { foreach ($carpetas as $carpeta) { echo "Nombre del directorio: " . $carpeta ; } }else{ echo "No hay directorios en ". JPATH_COMPONENT.DS.'miDirectorio'; } |
Ahora veamos como hacer lo mismo con php sin usar el framework:
(código sacado de la web www.desarrolloweb.com )
$ruta = /path/a/tu/directorio // abrir un directorio y listarlo recursivo if (is_dir($ruta)) { if ($dh = opendir($ruta)) { while (($file = readdir($dh)) !== false) { //esta línea la utilizaríamos si queremos listar todo lo que hay en el directorio //mostraría tanto archivos como directorios //echo "Nombre de archivo: $file : Es un: " . filetype($ruta . $file); if (is_dir($ruta . $file) && $file!="." && $file!=".."){ //solo si el archivo es un directorio, distinto que "." y ".." echo "Directorio: $ruta$file"; listar_directorios_ruta($ruta . $file . "/"); } } closedir($dh); } }else echo "No es ruta valida"; }
Como puedes ver, se comprueba manualmente si el directorio existe con la función is_dir(), esto ya lo lleva implementado el API de Joomla y no hace falta que lo volvamos a hacer si usamos el método folders.
Este es el código del método folders:
function folders($path, $filter = '.', $recurse = false, $fullpath = false, $exclude = array('.svn', 'CVS')) { // Initialize variables $arr = array (); // Check to make sure the path valid and clean $path = JPath::clean($path); // Is the path a folder? if (!is_dir($path)) { JError::raiseWarning(21, 'JFolder::folder: '.JText::_('Path is not a folder').' '.$path); return false; } // read the source directory $handle = opendir($path); while (($file = readdir($handle)) !== false) { $dir = $path.DS.$file; $isDir = is_dir($dir); if (($file != '.') && ($file != '..') && (!in_array($file, $exclude)) && $isDir) { // removes SVN directores from list if (preg_match("/$filter/", $file)) { if ($fullpath) { $arr[] = $dir; } else { $arr[] = $file; } } if ($recurse) { if (is_integer($recurse)) { $recurse--; } $arr2 = JFolder::folders($dir, $filter, $recurse, $fullpath); $arr = array_merge($arr, $arr2); } } } closedir($handle); asort($arr); return $arr; }
Como puedes comprobar se hacen todo tipo de comprobaciones y nos libra de realizarlas a mano.
Puedes ver más métodos interesantes en la documentación oficial del API de Joomla
Después de un largo tiempo sin escribir por motivos de trabajo, vuelvo al blog. Hoy voy a anotar un truco con jQuery que puede ahorrarnos mucho código: la función toogle.
La función toogle actúa como un interruptor, de manera que acepta dos parámetros, que serán dos funciones, una para cuando actives el interruptor y otra para cuando lo desactives.
Vamos a ver un ejemplo en el cual añadiremos una clase css a un div pulsando en un botón, de manera que cuando pinchemos en el botón , el div pasará a tener un color de fondo rojo y cuando volvamos a pulsar, el color de fondo desaparecerá.
Vamos a ver el ejemplo:
Primero creamos la clase css:
.rojo{ background:red; width:200px; height:300px; }
Después introducimos el siguiente código javascript en en el head de nuestro documento html:
<script type="text/javascript"> $(document).ready(function() { $('#conmutador').toggle(function() { $('#contenedor').addClass('rojo'); }, function() { $('#contenedor').removeClass('rojo'); }); }); </script>
Usamos los selectores de jQuery para obtener el objeto con id conmutador y le aplicacamos la función toogle.
Y este es el código html que va dentro del body:
<h1>Pruebas de jQuery</h1> <button id="conmutador">Conmutador</button> <div id="contenedor"></div>
Ya tenemos nuestro interruptor en javascript con unas pocas líneas de código.
Vamos a ver como subir un fichero al servidor usando el API de Joomla!.
La ventaja de usar el API de Joomla! es que internamente comprueba si se esta usando la capa FTP y si esta configurada se usará para subir el fichero.
Primero creamos una vista donde mostraremos un formulario con un input de tipo “file”. El formulario ha de tener enctype=”multipart/form-data” como atributo, de lo contrario, apache no sabrá interpretar los datos recogidos en la variable post como ficheros. El enctype multipart/form-data especifica que vamos a poder enviar tanto texto como ficheros.
Código de la vista
<form name="registro" id="registro" action="index.php" method="POST" enctype="multipart/form-data" >
Introduce el fichero :
<input type="file" name="fichero" />
<input type="submit" value="Subir Fichero" />
<input type="hidden" name="option" value="com_aplicacion" />
<input type="hidden" name="task" value="subirFichero" />
</form>La vista es enviada a un task, en este caso el task se llama subirFichero, así que creamos un método en el controlador con este nombre e introducimos el siguiente código :
(Si no entiendes lo que es un task, vista, etc… hay un tutorial bastante extenso sobre componentes donde se explica)
Código del task
$file = JRequest::getVar( 'fichero', null, 'files', 'array' ); jimport('joomla.filesystem.file'); if(!is_array($file)){ $mensaje .= "NoSeHaSubido"; } if($file['error'] || $file['size'] < 1 ){ $mensaje .= " NoExisteFichero"; } if( $file['size'] > 100 ){ $mensaje .=" FicheroDemasiadoGrande"; } if(!JFile::upload($file['tmp_name'],"/directorioLocal".DS. $file['name'])){ $mensaje .= " ErrorAlSubirElFichero"; }
En la primera línea obtenemos el fichero de la petición proveniente del formulario. Investiga más sobre los métodos de JRequest , te será muy útil!!.
La segunda línea sirve para importar el objeto JFile que usaremos para introducir el fichero en nuestro sistema de ficheros local.
Por último llevamos a cabo algunas comprobaciones para ver si el fichero es demasiado grande ,demasiado pequeño o si no se ha subido ningún fichero y vamos guardando en una variable el mensaje de error correspondiente, para que después solo haya que invocar el método upload del objeto JFile al cual le pasamos como primer parámetro el fichero temporal que aún se encuentra en la petición y como segundo parámetro la ruta completa en el disco local (incluyendo el nombre del fichero) donde queremos guardar el fichero.
Ya debería de estar fichero correctamente subido en el disco duro del servidor ;-)
PHP va evolucionando, y se va haciendo cada vez mas orientado a objetos.
La versión 6 será un gran paso para su consolidación como lenguaje orientado a objetos, pero hasta que salga se van implementando cada vez mas funcionalidades de programación orientada a objetos en la versión 5.
Leyendo programanía me entero que en php 5.3 se implementarán namespaces, al estilo java y c#, de esta forma se podrán usar clases con el mismo nombre siempre y cuando se encuentren en diferentes namespaces.
Se mejorarán los métodos estáticos, y ahora también se heredarán.
También se introducirá un nuevo driver nativo para MySql y muchas otras cosas más… Todas mas mejoras están comentadas en Sitepoint.
Gracias a todas estas mejoras de POO , sistemas gestores de contenidos como Joomla! 1.5 pueden crear potentes y extensibles frameworks, además de facilitar la velocidad y mantenibilidad en el desarrollo.
Es recomendable tener conocimientos de AJAX para seguir.
Mucha gente se pregunta como se puede utilizar AJAX en Joomla. A primera vista parece complicado ya que cuando hacemos un componente este siempre aparece dentro de un template, y nosotros no queremos que aparezca ese template, ya que queremos enviar documentos XML o JSON, y el template nos molesta.
Para evitar que aparezca el template tenemos las vistas Raw, que son vista que se muestran sin la envoltura del template y también podemos enviar el resultado directamente desde el task del controlador AJAX. De esta forma podemos enviar JSON o XML sin problemas.
Índice de la serie: desarrollo de extensiones con Joomla
- Hacer componentes en Joomla!
- Patrón MVC
- Concepto de Front-End y Back-End
- Primer componente MVC simple con Joomla!
- Segundo componente, Back-End y acceso a datos.
- Crear el xml del componente de joomla y generar instalable.
Ya hemos visto como hacer componentes y como hacer módulos en Joomla! 1.5 y hemos visto que no es nada complicado, y simplemente hay que entender la mecánica de trabajo .
Lo ultimo que nos queda son los plugins, con ellos podremos modificar el comportamiento estándar de Joomla!, pudiendo interceptar ciertos eventos prefijados para ejecutar nuestro código antes o después del evento.
Los plugins pueden llegar a ser muy utiles y potentes.
Por ejemplo, se puede interceptar el evento de publicar un articulo y hacer que joomla imprima un mensaje personalizado antes de cada articulo, o lo que a ti se te ocurra, simplemente tienes que tener a mano la lista de eventos (hooks) definidos y tu imaginación para hacer con joomla! lo que quieras.
Me llamo David Noguera, tengo 23 años y soy Desarrollador/Administrador web.
Puedes encontrar algo más de información en la página