Indice
1. El componente más sencillo
2. El modelo MVC
3. El fichero de instalación del componente
4. Incorporar un modelo al componente
1. El componente más sencillo
Como sabemos, un componente Joomla es el software responsable de generar contenido con una determinada funcionalidad para la parte central de la página.
En este artículo vamos a comentar cómo se desarrolla un componente para Joomla 1.5, al estilo del clásico Hola Mundo ! que se utiliza como ejemplo en todos los manuales de programación.
Cada componente en una instalación Jommla se encuentra bajo un directorio de la forma components/com_nombre_del_componente, y el punto de entrada al componente es un fichero php contenido en dicho directorio, llamado nombre_del componente.php
Para acceder a un componente de Joomla desde un navegador, siempre se utiliza una URL de la forma:
index.php?option=com_nombre_del_componente
Además, a la url se le pueden añadir otros argumentos como &task=tarea (que indica la tarea que se desea: por ejemplo, visualizar, editar, guardar, cancelar,...) o &controller=controlador que comentaremos más adelante.
Nosotros vamos a crear un directorio components/com_hola, y el el mismo crearemos el fichero hola.php, con el siguiente contenido:
<?php
echo "Hola, como estás";
?>
Si ahora, desde un navegador, llamamos a la url index.php?option=com_hola, veremos que la parte cental de la página que obtenemos contiene el texto "Hola, como estás". Ya hemos creado nuestro primer componente Joomla !
Para crear el backend de administración del componente, la estructura es muy similar, excepto que el directorio en donde se encuentra la parte de administración es administrator/components/com_nombre_del_componente, y el punto de entrada se denomina admin.nombre_del_componente.php. En nuestro caso tendríamos que crear administrator/components/com_hola/admin.hola.php, pero seguiremos hablando del backend del componente más adelante.
2. El modelo MVC
Con lo que hemos visto hasta ahora, estaríamos en condiciones de crear un componente cualquiera, limitado sólamente por nuestra habilidad para la programación en php, y ajenos a la funcionalidad que pone a nuestra disposición el marco de Joomla 1.5. Pero vamos a ver cómo podemos utilizar esta funcionalidad existente para reducir el tiempo de desarrollo y obtener un resultado más fácil de mantener y acorde a las buenas prácticas de programación.
En Joomla 1.5 se utiliza el paradigma MVC (Model-View-Controller) para el desarrollo de los componentes. Este paradigma está implementado por medio de tres clases: JModel, JView y JController.
En el modelo MVC:
- El punto de entrada selecciona un Controller y le pasa la petición del usuario.
- El Controller selecciona un View para la visuallización de la información solicitada.
- El View llama a un Model, que obtiene la información de base de datos y se la entrega. El View transforma la información si es necesario, y se la entrega a una plantilla, que realiza la transformación final a formato HTML para su visualización en un navegador.
Inicialmente, no vamos a hacer uso de una base de datos, por lo que el componente que vamos a desarrollar constará de los siguientes ficheros:
- components/com_hola/hola.php – el punto de entrada a nuestro componente
- components/com_hola/controller.php – el controlador
- components/com_hola/views/hola/view.html.php – el view. recoge los datos y se los entrega a la plantilla
- components/com_hola/views/hola/tmpl/default.php – la plantilla para generar la página resultante
2.1. El punto de entrada al componente
El código del punto de entrada hola.php, es casi siempre el mismo para cualquier componente con ligeras variaciones, y es el siguiente:
<?php
// no permitir el acceso directo
defined( '_JEXEC' ) or die( 'Acceso restringido' ); // Nota 1
// Requerir el controlador base (en nuestro caso,
// el controller.php, que contiene la clase HolaController)
require_once( JPATH_COMPONENT.DS.'controller.php' ); // Nota 2
// Requerir un controlador específico, si se ha solicitado
if($controller = JRequest::getVar('controller')) { // Nota 3
$path = JPATH_COMPONENT.DS.'controllers'.DS.$controller.'.php';
if (file_exists($path)) {
require_once $path;
} else {
$controller = '';
}
}
// Crear el controlador
$classname = 'HolaController'.$controller; // Nota 4
$controller = new $classname( );
// Realizar la tarea solicitada
$controller->execute( JRequest::getVar( 'task' ) ); // Nota 5
// Redirigir, si el controlador lo indica
$controller->redirect();
?>
Nota 1 - Esta línea es una medida de seguridad para impedir la ejecución directa del código, de modo que sólo puede ser ejecutado si es llamado por index.php
Nota 2 - JPATH_COMPONENT contiene el path absoluto al punto de entrada del componente, y DS es el carácter separador utilizado por un path, según el sistema operativo ('/' para Unix, '\' para Windows).
Nota 3 - Aunque nosotros no vamos a hacer uso de ello, este código determina si se ha solicitado el uso de un controlador específico mediante el argumento '&controller=controlador' en la URL.
Nota 4 - Si se hubiera especificado un argumento controller en la URL, el fichero controller.php debería contener la definición de la clase correspondiente, que se debería llamar <nombre_del_componente>Controller<nombre_del_controlador>. Por ejemplo,si se ha pasado el argumento &controller=Hola2, debería existir una clase llamada HolaControllerHola2. Si no se especifica controlador, la clase que debe existir se llama HolaController.
Nota 5 - La URL también puede contener un argumento &task=tarea. En este caso la clase definida en controller.php debe contener una función llamada igual que la tarea especificada. Si no se especifica tarea, se utiliza la funcion por denominada "display"", que debe estar definida en la clase.
2.2. El Controlador
A continuación creamos el fichero controller.php. con el siguiente código:
<?php
// no permitir el acceso directo
defined( '_JEXEC' ) or die( 'Restricted access' );
jimport('joomla.application.component.controller');
class HolaController extends JController{
function display() {
parent::display();
}
}
?>
2.3. La vista y la plantilla
Después, creamos view/hola/view.html.php:
<?php
// no permitir el acceso directo
defined( '_JEXEC' ) or die( 'Restricted access' );
jimport( 'joomla.application.component.view');
class HolaViewHola extends JView{
function display($tpl = null) {
$saludo = "Hola, Como estás!";
$this->assignRef( 'saludo', $saludo );
parent::display($tpl);
}
}
?>
Y por último, creamos la plantilla view/hola/tmpl/default.php:
<?php
// no permitir el acceso directo
defined( '_JEXEC' ) or die( 'Restricted access' );
?>
<h1><?php echo $this->saludo; ?></h1>
3. El fichero de instalación del componente
Los ficheros que hemos visto en el anterior apartado pueden ser creados directamente en la ruta correspondiente bajo el directorio de instalación de Joomla.
Pero si tenemos intención de poner nuestro componente a disposición de otras personas para que lo puedan incorporar en sus instalaciones, lo adecuado es hacer un paquete de instalación, para lo cual debemos crear un fichero XML llamado 'nombre_de_componente.xml', que especifique las características de nuestro componente, los ficheros de que consta, los procedimientos de instalación y desinstalación, etc.
Para el ejemplo del apartado 2, el fichero de instalación se debe llamar hola.xml, y su contenido es el siguiente:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE install SYSTEM "http://dev.joomla.org/xml/1.5/component-install.dtd">
<install type="component" version="1.5.0">
<name>Hola</name>
<!—Los elementos a continuación son opcionales y de formato libre -->
<creationDate>2007 02 22</creationDate>
<author>John Doe</author>
<authorEmail> Esta dirección electrónica esta protegida contra spam bots. Necesita activar JavaScript para visualizarla </authorEmail>
<authorUrl>http://www.example.org</authorUrl>
<copyright>Copyright Info</copyright>
<license>License Info</license>
<!-- The version string is recorded in the components table -->
<version>Component Version String</version>
<!-- The description is optional and defaults to the name -->
<description>Description of the component ...</description>
<!-- Site Main File Copy Section -->
<!-- Note the folder attribute: This attribute describes the folder
to copy FROM in the package to install therefore files copied
in this section are copied from /site/ in the package -->
<files folder="site">
<filename>index.html</filename>
<filename>hola.php</filename>
<filename>controller.php</filename>
<filename>views/index.html</filename>
<filename>views/hola/index.html</filename>
<filename>views/hola/view.html.php</filename>
<filename>views/hola/tmpl/index.html</filename>
<filename>views/hola/tmpl/default.php</filename>
</files>
<administration>
<!-- Administration Menu Section -->
<menu>Hola Mundo!</menu>
<!-- Administration Main File Copy Section -->
<files folder="admin">
<filename>index.html</filename>
<filename>admin.hola.php</filename>
</files>
</administration>
</install>
En el fichero de instalación vemos que se hace referencia a unos ficheros 'index.html' que aparecen en cada subdirectorio del componente. Se trata simplemente de ficheros vacíos, y es una medida de seguridad para impedir que un usuario pueda acceder a un listado del contenido de un directorio especificando una URL que acaba en el nombre del directorio. El comportamiento habitual de un servidor web en estos casos es presentar el contenido de un fichero index.html, si existe en el directorio solicitado.
Por otra parte, vemos que en el fichero de instalación hay una sección de administración que hace referencia al fichero 'admin.hola.php' que habíamos citado brevemente en el apartado 1. Más adelante hablaremos en detalle del desarrollo del backend de nuestro componente.
4. Incorporar un modelo al componente
El modelo, es el encargado de obtener la información solicitada de la base de datos, o del origen en donde reside.
Vamos a comenzar escribiendo para nuestro ejemplo el modelo más sencillo, que simplemente devuelve siempre una misma cadena "Hola mundo!". El fichero se debe llamar models/hola.php:
<?php
// Check to ensure this file is included in Joomla!
defined('_JEXEC') or die();
jimport( 'joomla.application.component.model' );
class HolaModelHola extends JModel{
function getSaludo() {
return 'Hola mundo!';
}
}
Como se ve, el modelo debe contener una clase denominada <nombre_del_modelo>Model<nombre_del_modelo>. En su interior hay una función getSaludo, a la que debe hacer referencia la vista, para obtener la información del modelo. Por lo tanto, debemos sustituir, en el fichero view.html.php, la línea:
$saludo = "Hola, Como estás!";
por:
$model =& $this->getModel();
$saludo = $model->getSaludo();
Y en el fichero xml de instalación debemos añadir la línea:
<filename>models/hola.php</filename>
4.1. Acceder a la base de datos
Y ahora, vamos a añadir a la función getSaludo del modelo el código para recuperar la información de la base de datos:
Sustituimos la función getSaludo del modelo por:function getSaludo(){
$db =& JFactory::getDBO(); // Nota 1
$consulta = 'SELECT saludo FROM #__hola'; // Nota 2
$db->setQuery( $consulta );
$saludo = $db->loadResult(); // Nota 3
return $saludo;
}Nota 1 - Como la instalación de Joomla ya tiene acceso a una base de datos, para obtener una conexión a la misma utilizamos la función getDBO (get DataBase Object) de JFactory, que es una clase estática proporcionada por Joomla para obtener referencias a muchos objetos del sistema.
Nota 2 - en la sentencia SQL, se utiliza la sintaxis '#__hola' para el nombre de la tabla. La expresión '#__' es sustituida por Joomla por el prefijo definido durante su instalación. El prefijo por defecto de una instalación de Joomla es 'jos_', por lo cual el nombre real de la tabla en la base de datos será 'jos_hola'. El uso de un prefijo permite que en una misma base de datos coexistan varias instalaciones de Joomla, junto con tablas de otras aplicaciones, sin interferirse.
Nota 3 - El método loadResult devuelve el primer campo del primer registro obtenido como resultado de la consulta. Los otros métodos disponibles se pueden consultar en la documentación de la clase JDatabase disponible online.
4.2. Actualización del fichero de instalación para incorporar la tabla
Puesto que ahora utilizamos una tabla, para realizar una instalación del componente debemos escribir en un fichero 'install.sql' el código que crea la tabla, y que la carga con datos iniciales. Del mismo modo hay que contemplar la posibilidad de que el componente sea desinstalado, para lo que hay que escribir en un fichero 'uninstall.sql' el código que elimina la tabla.
Fichero install.sql:
DROP TABLE IF EXISTS '#__hola';
CREATE TABLE '#__hola' (
'id' int(11) NOT NULL auto_increment,
'saludo' varchar(25) NOT NULL,
PRIMARY KEY ('id')
) ENGINE=MyISAM AUTO_INCREMENT DEFAULT CHARSET=utf8;
INSERT INTO '#__hola' ('saludo')
VALUES ('Hola, Mundo!'),('Hello, World!'),('Bonjour, Monde!'),('Ciao, Mondo!');
Fichero uninstall.sql:
DROP TABLE IF EXISTS `#__hola`;
Y finalmente, hay que hacer referencia a estos ficheros en el fichero de instalación hola.xml. Para ello, incluimos el siguiente código, a continuación del bloque <files></files>:
<install>
<sql>
<file charset="utf8" driver="mysql">install.sql</file>
</sql>
</install>
<uninstall>
<sql>
<file charset="utf8" driver="mysql">uninstall.sql</file>
</sql>
</uninstall>
