Mundo Geek » joomla

Creación de componentes para Joomla (II)

Zootropo — Mon, 15 Feb 2010 08:50:42 +0000

Si en el artículo anterior vimos cómo desarrollar la interfaz pública de un componente para Joomla, en esta ocasión veremos cómo crear la interfaz de administración, extendiendo nuestro pequeño componente de ejemplo, que mostraba citas aleatorias de entre las introducidas por los usuarios, y añadiendo opciones para editar y eliminar las citas.

Lo primero que tendremos que hacer es editar el archivo XML que contiene la información del componente. Recordaréis que la sección referente a la interfaz de administración (administration) estaba vacía en el ejemplo anterior.

Necesitamos añadir una sección files, en la que indicar los archivos que compondrán la parte de administración, y una etiqueta menu, especificando el nombre a mostrar en el menú de Componentes y la página que se cargará al hacer clic sobre él. Algo a tener en cuenta es que file tiene un argumento folder indicando que todos los archivos a los que hacemos referencia se encuentran en una nueva carpeta admin dentro del directorio de nuestro componente.



  Ejemplo
  Raul Gonzalez
  Febrero 2010
  (C) Raul Gonzalez
  GPL
  http://mundogeek.net/
  zootropo en gmail
  0.1
  Componente de ejemplo que muestra mensajes aleatorios escritos por los lectores
  
    
      CREATE TABLE IF NOT EXISTS jos_mensajes(
          id int NOT NULL auto_increment,
          mensaje varchar(300) NOT NULL, PRIMARY KEY(id));
      INSERT INTO jos_mensajes(mensaje) VALUES
          ('At your command'),
          ('Hay 10 tipos de personas en el mundo: los que entienden binario y los que no'),
          ('Es mio, solo mio. Miii.... tessssssooooroo'),
          ('Hasta luego, y gracias por el pescado');
    
  
  
    ejemplo.php
    ejemplo.xml
    controllers
    models
    views
  
  
    Ejemplo
    
      ejemplo.php
      controller.php
      views

En el tutorial anterior ya comentamos que el punto de entrada al componente, tanto en el caso de la interfaz pública como el de la administración, es un archivo PHP con el nombre del componente, y que este, normalmente, no hará más que cargar el controlador adecuado. En este caso sólo vamos a utilizar un controlador, por lo que el código es mucho más sencillo. Creemos un nuevo archivo ejemplo.php dentro de nuestra nueva carpeta admin, con el siguiente contenido:

execute($task);
$controller->redirect();

Como vemos lo único que hace es cargar el código de nuestro único controlador, instanciar la clase, y ejecutar el método adecuado en el objeto dependiendo del parámetro task de la petición.

Creemos ahora el archivo controller.php en la carpeta admin:

addModelPath(JPATH_COMPONENT_SITE.DS.'models');
  }

  function display() {
    $vista = $this->getView('ejemplo', 'html');
    $modelo = $this->getModel('mensaje', 'EjemploModel');
    $vista->setModel($modelo, true);

    parent::display();
  }

  function edit() {
    $vista = $this->getView('ejemplo', 'html');
    $modelo = $this->getModel('mensaje', 'EjemploModel');
    $vista->setModel($modelo, true);

    $vista->edit();
  }

  function save() {
    $modelo = $this->getModel('mensaje', 'EjemploModel');
    $id = JRequest::getVar('id');
    $mensaje = JRequest::getVar('mensaje');

    $correcto = $modelo->actualizarMensaje($id, $mensaje);

    if($correcto)
      $this->setRedirect('index.php?option=com_ejemplo', 'Mensaje actualizado con éxito');
    else
      $this->setRedirect('index.php?option=com_ejemplo', 'Ocurrió un error al actualizar el mensaje', 'error');
  }

  function remove() {
    $modelo = $this->getModel('mensaje', 'EjemploModel');
    $cid = JRequest::getVar('cid', 0, '', 'array');
    $correcto = true;
    foreach($cid as $id) {
      $resultado = $modelo->eliminarMensaje($id);
      if(!$resultado)
        $correcto = false;
    }

    if($correcto)
      $this->setRedirect('index.php?option=com_ejemplo', 'Mensajes eliminados con éxito');
    else
      $this->setRedirect('index.php?option=com_ejemplo', 'Ocurrió un error al eliminar los mensajes', 'error');
  }
}

En esta ocasión sobreescribimos el constructor del controlador para añadir una llamada al método addModelPath. Hacemos uso de este método para que el controlador tenga en cuenta también la carpeta en la que almacenamos el modelo en la interfaz pública. Editaremos ese archivo para añadir los nuevos métodos que necesitemos, en lugar de crear otro archivo de modelo. También podríamos haber almacenado el archivo en la carpeta de la parte de administración y hacer uso del método addModelPath en el controlador de la parte pública.

Si quisiéramos hacer uso de una vista de la parte pública, aunque es algo menos común, podríamos haber hecho uso del método addViewPath.

El resto del código no tiene mayor misterio.

Sólo nos queda crear la vista y las plantillas que vamos a utilizar. Creamos una carpeta views, dentro una carpeta ejemplo, y en ella un archivo view.html.php.

get('Mensajes');
    $this->assignRef('mensajes', $mensajes);

    parent::display($tpl);
  }

  function edit() {
    JToolBarHelper::title('Editar mensaje');
    JToolBarHelper::save();
    JToolBarHelper::cancel();

    $modelo = $this->getModel();
    $cid = JRequest::getVar('cid', 0, '', 'array');

    $mensaje = $modelo->getMensajePorId($cid[0]);
    $this->assignRef('mensaje', $mensaje);

    parent::display('editar');
  }
}

En esta ocasión para generar nuestra vista hacemos uso de la clase JToolBarHelper, que contiene métodos para facilitarnos la creación de la barra de herramientas de nuestro componente. Tiene métodos para añadir títulos (title), divisores (divider), espaciadores (spacer), … botones de ayuda (help), para guardar elementos (save), borrar (trash), publicar (publish), … Este es el motivo de que haya utilizado palabras inglesas para nombrar los métodos del controlador: al pulsar el botón generado por editList, por ejemplo, se intentará ejecutar por defecto una tarea edit.

Este es el aspecto que tendrá ahora nuestro modelo, una vez editado el archivo correspondiente en la carpeta de la interfaz pública:

setQuery($query);
    return $db->loadResult();
  }

  function getMensajePorId($id) {
    $db =& JFactory::getDBO();
    $query = "SELECT id, mensaje FROM #__mensajes WHERE id='{$id}'";
    $db->setQuery($query);
    return $db->loadObject();
  }

  function eliminarMensaje($id) {
    $db =& JFactory::getDBO();
    $query = "DELETE FROM #__mensajes WHERE id='{$id}'";
    $db->setQuery($query);
    $db->query();

    if ($db->getErrorNum())
      return false;

    return true;
  }

  function actualizarMensaje($id, $mensaje) {
    $db =& JFactory::getDBO();
    $query = "UPDATE #__mensajes SET mensaje='{$mensaje}' WHERE id='{$id}'";
    $db->setQuery($query);
    $db->query();

    if ($db->getErrorNum())
      return false;

    return true;
  }

  function getMensajes() {
    $query = 'SELECT id, mensaje FROM #__mensajes ORDER BY id ASC';
    return $this->_getList($query);
  }

  function anyadirMensaje($mensaje) {
    $db =& JFactory::getDBO();
    $query = "INSERT INTO #__mensajes(mensaje) VALUES('{$mensaje}')";
    $db->setQuery($query);
    $db->query();

    if ($db->getErrorNum())
      return false;

    return true;
  }
}

Lo único destacable es el uso del método _getList, que toma una consulta SQL y devuelve una lista con los resultados.

Vamos por último con las plantillas. Creamos la carpeta tmpl en views/ejemplo y en esta un archivo default.php, que será la plantilla que mostrará la lista de los mensajes almacenados en la base de datos.




  mensajes as $mensaje) {
  ?>
    
  
    
      ID
      
      Mensaje
    
  
  
      id; ?>
      id); ?>
      id}'>{$mensaje->mensaje}"; ?>

ID		Mensaje
id; ?>	id); ?>	id}'>{$mensaje->mensaje}"; ?>

Aquí hay que tener en cuenta varias convenciones. Por ejemplo, el formulario tiene que tener como valor para el atributo name “adminForm“, para que funcione el script que marca todos los checkboxes al marcar el primero, y la tabla tiene que tener como valor para el atributo class “adminlist“, si queremos que esta tenga el aspecto definido en la hoja de estilo.

A parte de eso lo único interesante es el uso del método JHTML::_(), que se utiliza para generar código HTML de uso común. Toma como primer parámetro una cadena con formato “clase.metodo”, lo que indica que queremos ejecutar el método indicando de la clase JHTMLClase. Si no se especifica ninguna clase, se llamará al metodo con ese nombre de la clase JHTML, si existe. Cualquier otro parámetro extra que se le pase a JHTML::_() se pasará como parámetro al método que queremos ejecutar.

Estas clases que agrupan código HTML de uso común son JHTMLBehavior, JHTMLContent, JHTMLEmail, JHTMLForm, JHTMLGrid, JHTMLImage, JHTMLList, JHTMLMenu y JHTMLSelect.

El método id de JHtmlGrid, concretamente, genera un widget de tipo checkbox que sigue las convenciones necesarias para que se utilice para seleccionar un elemento por su identificador.

Por último veamos la plantilla que se encargará de crear el formulario con el que editar el mensaje, default_editar.php. Este formulario es incluso más sencillo, y no requiere de mayores explicaciones.




  
    
      Mensaje:

Creación de componentes para Joomla

Zootropo — Fri, 12 Feb 2010 09:50:30 +0000

Siguiendo con nuestra serie de tutoriales sobre Joomla, esta vez hablaremos sobre el desarrollo de componentes, otro de los tipos de extensiones disponibles para este CMS, junto con los plugins, los temas, las traducciones o los módulos.

Componentes en Joomla

Los componentes son extensiones más complejas que los módulos, y suelen contar con una parte pública o frontend y otra de administración o backend.

Sólo puede haber un componente activo por página, y este se determina mediante un argumento option en la petición HTTP, que contendrá el nombre del componente a cargar. Para un componente con nombre com_componente, por ejemplo, la URL para ejecutar el backend sería http://servidor.com/administrator/index.php?option=com_componente y la del frontend, http://servidor.com/index.php?option=com_componente.

Cuando Joomla! se encuentra con una URL de este tipo, con un parámetro option indicando el nombre de un cierto componente, el engine busca y ejecuta el archivo components/com_nombre/nombre.php si se trata del frontend y administrator/components/com_nombre/nombre.php si vamos a cargar el backend.

Aunque podríamos escribir todo el código del componente en estos dos archivos, es conveniente que nuestro código esté algo más estructurado.

De un tiempo a esta parte, afortunadamente, se está tendiendo a utilizar el patrón MVC a la hora de crear componentes para Joomla, por lo que el contenido de estos dos archivos suele consistir simplemente en la instanciación y ejecución de un controlador.

El patrón MVC en los componentes Joomla

¿Que qué es un controlador, o el patrón MVC, ya que estamos? MVC es un viejo conocido de los desarrolladores web que propone usar una arquitectura dividida en 3 capas diferenciadas, en pos de reducir el acoplamiento. Estas capas, cuyas siglas dan nombre al patrón son:

Modelo: los datos que maneja la aplicación y las reglas de negocio que operan sobre ellos
Vista: genera la interfaz con la que la aplicación interacciona con el usuario
Controlador: comunica la vista y el modelo respondiendo a eventos generados por el usuario en la vista, invocando cambios en el modelo, y proporcionando a la vista la información del modelo necesaria para que pueda generar la respuesta adecuada para el usuario

El patrón MVC se implementa en Joomla utilizando 3 clases distintas, una por cada componente del patrón: JModel para el modelo, JView para la vista y JController para el controlador.

Un controlador en Joomla es una clase que extiende JController, con un método para cada tarea con la que el controlador tenga que tratar: mostrar un elemento, crear un elemento, borrar un elemento, etc. En estos métodos el controlador analiza la entrada del usuario y lleva a cabo los pasos necesarios para generar la respuesta (seleccionar el modelo o modelos necesarios y la vista a utilizar y asociarlos, hacer una redirección, generar un error…)

Un modelo en Joomla es una clase que extiende JModel, con distintos métodos para realizar distintas acciones sobre los datos. No importa la forma que tomen estos datos o la forma en la que trabajemos con ellos: podríamos utilizar JTable, JDatabase, mysqli, las funciones para trabajar con ficheros…

Una vista en Joomla es una clase que extiende JView, con uno o más métodos para generarar la página HTML, el feed, el PDF, … que mostrar al usuario como respuesta. Cuando la respuesta es una página HTML, la vista suele hacer uso de plantillas.

Punto de entrada al componente

Ahora que ya hemos establecido en qué consiste el patrón MVC, veamos el aspecto que tendrá el archivo que actúa a modo de punto de entrada al componente, y que, como dijimos anteriormente, se ejecuta al cargar la URL http://servidor.com/index.php?option=com_nombre (vamos a centrarnos en este artículo en el frontend)

Recordaréis que este archivo debía instanciar el controlador y ejecutarlo. Eso es lo que hace este fragmento de código:

execute($task);
  $controller->redirect();
}

Es una práctica común el utilizar un controlador por cada tipo de entidad con el que vayamos a trabajar, y utilizar el parámetro controller para indicar el controlador a usar; ese es el motivo de que usemos JRequest para obtener su valor. En caso de que no se haya encontrado ningún parámetro controller en la petición, la variable $controller obtendrá como valor ‘default‘.

Una vez sabemos qué controlador cargar (uno especificado en la URL, o default) comprobaremos si realmente existe un archivo PHP con ese nombre en la carpeta controllers de nuestro componente.

Si es el caso, cargaremos el código del componente, instanciaremos la clase, llamaremos a su método execute pasándole como argumento el valor del parámetro task de la URL (que se guarda automáticamente en $task), y llamaremos a su método redirect.

El método execute del controlador es el encargado de llamar a uno u otro de los métodos del controlador para tratar la petición. Normalmente se ejecutará el método que tenga el nombre pasado como parámetro a execute, aunque se puede modificar el mapeo utilizando el método registerTask() (por ejemplo para que el mismo método se encargue de la tarea de editar y crear un nuevo elemento). Si la URL no tiene ningún parámetro task, y por lo tanto se le pasa una cadena vacía a execute, o si el valor no se encuentra en el mapeo, se ejecutará por defecto el método de nombre display.

El método redirect sirve para redirigir el navegador en caso de que en el método ejecutado en el controlador se estableciera una redirección (mediante el método setRedirect).

Controlador

Un controlador muy sencillo, que no hace más que ejecutar la vista asociada podría tener este aspecto:


De hecho, como nuestro método display, que, como ya hemos comentado, es el que se ejecuta si no se pasa ningún argumento a execute en el punto de entrada, sólo llama al método display del objeto padre, no tendríamos si quiera por qué sobre escribirlo:

Pero normalmente nuestros controladores no serán tan sencillos. Lo más habitual es encontrarse con 2 tipos de métodos: aquellos en los que sólo queremos mostrar una cierta información al usuario, y otros en los que realizaremos una acción sobre el modelo, y redirigiremos el navegador a otra URL para mostrar el resultado.
En el primer caso sólo tenemos que establecer la vista y la plantilla a utilizar, y ejecutarla.
function display() {
  JRequest::setVar('view', 'persona');
  JRequest::setVar('layout', 'default');

  parent::display();
}
o bien
function display() {
  JRequest::setVar('view', 'persona');

  parent::display('default');
}
dado que default es la plantilla que se carga por defecto, si sólo vamos a usar una plantilla, o bien, si vamos a utilizar la plantilla default, no será necesario indicarlo
function display() {
  JRequest::setVar('view', 'persona');

  parent::display();
}
En el segundo caso tendríamos algo así
function guardar() {
  $modelo = $this->getModel('persona');
  if($modelo->guardarPersona())
    $this->setRedirect('index.php?option=com_nombre', 'Persona guardada con exito');
  else
    $this->setRedirect('index.php?option=com_nombre', 'Error al guardar', 'error');
}
Vista
Como dijimos, las vistas consisten en clases que extienden JView. En estas clases nos interesará sobreescribir el método display, donde asignaremos las variables que la plantilla pueda necesitar con assign o assignRef (el primero asigna una copia del dato y el segundo una referencia) y llamaremos al método display de la clase padre para que renderice la plantilla.
class EjemploViewDefault extends JView {
  function display($tpl=null) {
    $this->assignRef('mensaje', 'Hola mundo');

    parent::display($tpl);
  }
}
Para obtener datos del modelo en la vista se puede hacer lo siguiente
class EjemploViewDefault extends JView {
  function display($tpl=null) {
    $modelo =& $this->getModel('MiModelo');
    $mensaje = $modelo->getMensaje();
    $this->assignRef('mensaje', $mensaje);

    parent::display($tpl);
  }
}
Si el modelo tiene el mismo nombre que la vista, lo cuál suele ser habitual, porque es práctica común usar una vista y un modelo por entidad, de la misma forma que hacíamos con los controladores, el modelo estará asociado automaticamente con la vista, y bastará con hacer algo así:
class EjemploViewDefault extends JView {
  function display($tpl=null) {
    $mensaje =& $this->get('Mensaje');
    $this->assignRef('mensaje', $mensaje);

    parent::display($tpl);
  }
}
Al llamar al método get la vista buscará en el modelo asociado un método con nombre get seguido de la cadena pasada como parámetro (getMensaje en el ejemplo) y lo ejecutará.
Por último, como dijimos, si vamos a usar la plantilla por defecto, default.php, no necesitaremos pasar a display ningún parámetro:
class EjemploViewDefault extends JView {
  function display($tpl=null) {
    $mensaje =& $this->get('Mensaje');
    $this->assignRef('mensaje', $mensaje);

    parent::display();
  }
}
Las plantillas son archivos PHP en los que casi todo es HTML, y se usan pequeños snipets PHP para imprimir los valores necesarios en las posiciones adecuadas. Se podría crear el código HTML de la respuesta en la clase de la vista utilizando echo, por ejemplo, pero el uso de plantillas facilitará la vida a los diseñadores, o, si no hay diseñadores, a nosotros, cuando tengamos que reutilizar código o mantener el componente.
En la plantilla se accede a los datos que se han asignado con assign y assignRef usando $this->dato
dato; ?>
En la plantilla también se puede usar $this->loadTemplate('plantilla'); para cargar otra plantilla y tener así un diseño más modular. En el siguiente código se cargaría una plantilla default_cabecera.php, por ejemplo:
loadTemplate('cabecera'); ?<

dato; ?>
Modelo
Por último tenemos el modelo. Estas son las clases más sencillas. Basta extender JModel y crear tantos métodos como queramos, que realizarán las operaciones sobre los datos que necesitemos. Un ejemplo podría ser
setQuery($query);
    return $db->loadResult();
  }
}
Crear un componente de ejemplo
Para continuar, vamos a crear un pequeño componente de ejemplo, basado en el típico hola mundo, que mostrará un mensaje aleatorio de entre los almacenados en una tabla de la base de datos.
Lo primero que tenemos que hacer es crear una carpeta en nuestra máquina, com_ejemplo, digamos, en la que almacenaremos los archivos de nuestro nuevo componente. Dentro de esta carpeta crearemos un archivo ejemplo.xml con la información del componente e información de la instalación (puede tener un nombre cualquiera, pero lo habitual es utilizar el nombre del componente, o install.xml):


  Ejemplo
  Raul Gonzalez
  Febrero 2010
  (C) Raul Gonzalez
  GPL
  http://mundogeek.net/
  zootropo en gmail
  0.1
  Componente de ejemplo que muestra mensajes aleatorios escritos por los lectores
  
    
      CREATE TABLE IF NOT EXISTS jos_mensajes(
              id int NOT NULL auto_increment,
              mensaje varchar(300) NOT NULL, PRIMARY KEY(id));
      INSERT INTO jos_mensajes(mensaje) VALUES
              ('At your command'),
              ('Hay 10 tipos de personas en el mundo: los que entienden binario y los que no'),
              ('Es mio, solo mio. Miii.... tessssssooooroo'),
              ('Hasta luego, y gracias por el pescado');
    
  
  
    ejemplo.php
    ejemplo.xml
    controllers
    models
    views
  
  

como véis no es muy distinto del archivo de instalación que utilizamos al crear nuestro primer módulo, a excepción de la sección administration, que en este ejemplo está vacía, pero normalmente listará los archivos de la parte de administración, y la sección install, que utilizamos en este caso para crear la tabla que usaremos para almacenar los mensajes, e introducir algunos mensajes iniciales.
El siguiente paso es crear el archivo que sirve de punto de entrada al componente, que, como ya comentamos, tendrá como nombre el mismo del componente sin el com_; es decir, en este caso, ejemplo.php. El contenido del mismo ya lo explicamos anteriormente:
execute($task);
  $controller->redirect();
}
En este ejemplo, que es tan sencillo, no tiene mucho sentido tener más de un controlador, pero utilizaremos este código igualmente para que nuestro componente sea más fácil de extender y para que el ejemplo sea más instructivo.
Ahora tenemos que crear una carpeta controllers (fíjate en el valor de $path en el código anterior) en la que crearemos el archivo de nuestro controlador por defecto, que en este caso, como habréis supuesto por el segundo argumento de JRequest::getWord, será mensaje.php. Como dijimos, es habitual utilizar un controlador por entidad con la que vayamos a tratar, y el nombre del archivo suele ser el de la entidad. El nombre de la clase suele ser el nombre del componente, seguido de ‘Controller‘ y el nombre de la entidad (EjemploControllerMensaje en este caso).
En este ejemplo sólo necesitamos un método display (mostrar), que, como comentamos, es el que se ejecuta por defecto de no pasarse ningún otro valor al método execute.

Listo. Con algo tan simple ya tenemos nuestro primer controlador. Vayamos con la vista.
Creamos una carpeta views en el directorio del componente. En esta carpeta, para cada vista que vayamos a utilizar tendremos un directorio con el nombre de la vista, que contendrá a su vez un archivo view.html.php si vamos a generar una página HTML, view.feed.php si vamos a generar un feed, view.pdf.php si la salida será un PDF, o view.raw.php para cualquier otra cosa (el CMS sabe qué tipo de salida se debe mostrar al usuario gracias al parámetro format de la URL).
En nuestro ejemplo utilizaremos una vista para la única entidad con la que vamos a trabajar, aunque hay personas que prefieren tener una vista por cada página que vayamos a utilizar en el componente.
Crearemos, por lo tanto, una carpeta ‘mensaje’ en views, y un archivo view.html.php en mensaje. El archivo view.html.php contendrá, como dijimos, una clase que extiende JView, y cuyo nombre estará compuesto por el nombre del componente, la palabra View, y el nombre de la vista (el nombre de la entidad). Como vamos a seguir las convenciones de nombres habituales, la vista tendrá asociado el modelo correspondiente, y sólo tenemos que llamar a $this->get('Mensaje') para que se busque y ejecute el método getMensaje en el modelo, y obtener de esta forma el mensaje a mostrar. Una vez hecho esto basta asignar este valor para que esté disponible para la plantilla.
get('Mensaje');
    $this->assign('mensaje', $mensaje);

    parent::display();
  }
}
Sigamos con la plantilla. En el mismo directorio en que se encuentra view.html.php crearemos una nueva carpeta tmpl para contener las plantillas o templates. Como sólo necesitaremos una plantilla, vamos a llamar a este archivo default.php, que es la plantilla que se carga por defecto de no indicarse otra cosa. Este archivo sólo tiene que hacer una cosa, y es mostrar el mensaje que se ha asignado en la clase de la vista.
mensaje; ?>
Por último veamos el modelo. Crearemos una nueva carpeta models en el directorio del componente, con un archivo mensaje.php que contendrá una clase cuyo nombre estará formado por el nombre del componente, la palabra ‘Model‘ y el nombre de la entidad. En este ejemplo sólo utilizamos un método getMensaje para obtener un mensaje aleatorio de la base de datos.
setQuery($query);
    return $db->loadResult();
  }
}
Con esto ya tendríamos preparado nuestro componente. Sólo resta comprimir los archivos que lo componen e instalarlo desde Extensiones -> Instalar/Desinstalar. Para ver el resultado, tendremos que introducir en el navegador la URL http://servidor.com/index.php?option=com_ejemplo
Complicando el componente
Como puede que el ejemplo anterior os haya sabido a poco, vamos a añadir también la posibilidad de que los usuarios puedan introducir sus propios mensajes, para afianzar conceptos.
Lo primero que tenemos que hacer es editar el controlador, y crear un par de nuevos métodos que traten las nuevas tareas ‘anyadir‘, que mostará un formulario con el que introducir el mensaje, y ‘anyadido‘, que intentará guardar el mensaje y mostrará un texto u otro dependiendo del resultado.
getView('mensaje', 'html');

    $vista->anyadir('anyadir');
  }

  function anyadido() {
    $mensaje = JRequest::getVar('mensaje');
    $modelo = $this->getModel('mensaje');

    if($modelo->anyadirMensaje($mensaje))
      $this->setRedirect('index.php?option=com_ejemplo', 'Mensaje añadido con éxito');
    else
      $this->setRedirect('index.php?option=com_ejemplo', 'Se produjo un error al guardar el mensaje', 'error');
  }
}
Lo único destacable respecto de la versión anterior es que ahora necesitamos obtener una instancia de la vista, con el método getView(vista, formato) del controlador, para poder ejecutar un método distinto de display en la vista. Otra alternativa habría sido tener una vista distinta por página.
Un apunte interesante es que con JRequest::get('post') podemos obtener todos los datos de una petición POST, de forma que podríamos haber hecho algo así para guardar todos los datos de un formulario en la base de datos usando JTable:
$persona =& JTable::getInstance('persona', 'Table');
if ($persona->save(JRequest::get('post'))
  $mensaje = 'Guardado';
else
  $mensaje = 'Error: ', $empleado->getError();  

$this->setRedirect('index.php?option=com_componente', $mensaje);
La nueva versión de la vista, con el nuevo método anyadir, tendrá el siguiente aspecto:
get('Mensaje');
    $this->assign('mensaje', $mensaje);

    parent::display();
  }

  function anyadir($tpl) {
    parent::display($tpl);
  }
}
Como vemos lo único que hace es mostrar la plantilla que indicó el controlador como parámetro. En este caso no necesitamos ningún dato del modelo, por lo que no se utiliza assign ni assignRef.
La nueva plantilla, default_anyadir.php, también es muy sencilla. Sólo muestra el formulario que el usuario utilizará para añadir el mensaje.

  

  
  

  

Fíjate en que hacemos uso de un par de campos ocultos para establecer el valor del parámetro option y el parámetro task, y que la petición va a ser tratada, como siempre, por index.php
Por último sólo nos queda ver la nueva versión del modelo, con el método anyadirMensaje que guardará el mensaje introducido por el usuario
setQuery($query);
    return $db->loadResult();
  }

  function anyadirMensaje($mensaje) {
    $db =& JFactory::getDBO();
    $query = "INSERT INTO #__mensajes(mensaje) VALUES('{$mensaje}')";
    $db->setQuery($query);
    $db->query();

    if ($db->getErrorNum())
      return false;

      return true;
  }
}
Desinstalamos la versión anterior del componente, comprimimos los archivos, e instalamos la nueva versión desde Extensiones -> Instalar/Desinstalar. Y listo, hemos terminado de crear nuestro primer componente. En artículos posteriores veremos cómo añadir una interfaz de administración a nuestro componente.

Bases de datos en Joomla!

Zootropo — Sun, 17 Jan 2010 18:34:27 +0000

Siguiendo con nuestro último tutorial en el que vimos cómo desarrollar módulos para Joomla veremos ahora cómo trabajar con bases de datos al programar para este CMS, bien utilizando sentencias SQL, a través de la clase JDatabase, o bien mediante la clase JTable, haciendo uso de una especie de pequeño ORM (mapeo objeto-relacional) basado en el patrón active record.

JDatabase

Lo primero que debemos hacer a la hora de usar JDatabase, la clase que representa una conexión a la base de datos en Joomla, es obtener una instancia de la clase. Para ello haremos uso de JFactory, una clase que ofrece varios métodos estáticos para obtener instancias de distintos singleton del framework, como pueden ser el objeto sesión (getSession), el objeto usuario (getUser) o el propio objeto JDatabase (getDBO).

$db =& JFactory::getDBO();

Para preparar una consulta se utiliza setQuery. Algo a tener en cuenta a la hora de escribir nuestras consultas es que debemos sustituir el prefijo de las tablas de Joomla (jos_ normalmente) por #__. De esta forma el usuario podrá utilizar el prefijo que prefiera para las tablas de Joomla, ya que el framework se encargará de sustituir este prefijo por el adecuado antes de ejecutar la consulta.

$query = 'CREATE TABLE #__empleado(id INT NOT NULL AUTO_INCREMENT, nombre VARCHAR(20), departamento VARCHAR(20), PRIMARY KEY(id))';
$db->setQuery($query);

Para ejecutar la consulta se utiliza el método query()

$db =& JFactory::getDBO();
$query = 'CREATE TABLE #__empleado(id INT NOT NULL AUTO_INCREMENT, nombre VARCHAR(20), departamento VARCHAR(20), PRIMARY KEY(id))';
$db->setQuery($query);
$db->query();

Si la consulta que vamos a ejecutar es un SELECT, podemos sustituir el método query por uno de los siguientes métodos, dependiendo del tipo de resultado que necesitemos obtener:

loadResult: un único valor

$db =& JFactory::getDBO();
$query = 'SELECT nombre FROM #__empleado LIMIT 1';
$db->setQuery($query);
$nombre = $db->loadResult();
echo $nombre;

loadResultArray: un array con los valores de las distintas tuplas para un cierto campo

$db =& JFactory::getDBO();
$query = 'SELECT nombre FROM #__empleado';
$db->setQuery($query);
$nombres = $db->loadResultArray();

foreach($nombres as $nombre)
  echo $nombre, '
';

loadAssoc: un array asociativo en el que las claves son los campos de la tupla

$db =& JFactory::getDBO();
$query = 'SELECT * FROM #__empleado';
$db->setQuery($query);
$empleado = $db->loadAssoc();

foreach($empleado as $campo => $valor)
  echo $campo, ': ', $valor, '
';

loadAssocList: una lista con un array asociativo para cada tupla

$db =& JFactory::getDBO();
$query = 'SELECT * FROM #__empleado';
$db->setQuery($query);
$empleados = $db->loadAssocList();

foreach($empleados as $empleado) {
  foreach($empleado as $campo => $valor)
    echo $campo, ': ', $valor, '
';
  echo '';
}

loadObject: un objeto en el que las propiedades son los atributos de la tupla

$db =& JFactory::getDBO();
$query = 'SELECT * FROM #__empleado LIMIT 1';
$db->setQuery($query);
$empleado = $db->loadObject();

echo 'Nombre: ', $empleado->nombre, '
';
echo 'Departamento: ', $empleado->departamento, '
';

loadObjectList: una lista de objetos, uno por cada tupla

$db =& JFactory::getDBO();
$query = 'SELECT * FROM #__empleado';
$db->setQuery($query);
$empleados = $db->loadObjectList();

foreach($empleados as $empleado) {
  echo 'Nombre: ', $empleado->nombre, '
';
  echo 'Departamento: ', $empleado->departamento, '
';
  echo '';
}

loadRow: devuelve un array con todos los campos de una tupla

$db =& JFactory::getDBO();
$query = 'SELECT * FROM #__empleado LIMIT 1';
$db->setQuery($query);
print_r($db->loadRow());

loadRowList: devuelve una lista en la que cada posición es un array con todos los campos de una tupla

$db =& JFactory::getDBO();
$query = 'SELECT * FROM #__empleado';
$db->setQuery($query);
print_r($db->loadRowList());

Por último para tratar los errores podemos hacer uso de los métodos getErrorNum y getErrorMsg. Supongamos que nos hubieramos equivocado al escribir el SELECT, por ejemplo:

$db =& JFactory::getDBO();
$query = 'SELEC * FROM #__empleado';
$db->setQuery($query);
$empleados = $db->loadAssocList();

if ($db->getErrorNum()) {
	echo $db->getErrorMsg();
	return;
}

JTable

Para cada tabla para la que queramos utilizar JTable para llevar a cabo las operaciones de creación, lectura, actualización o borrado tendremos que crear un archivo que contenga una clase que extienda JTable, con un atributo por cada columna de la tabla y un constructor que llamará al de la clase padre pasando como argumentos el nombre de la tabla, la clave primaria y el objeto que representa la conexión con la BBDD. El nombre de la nueva clase será, por convención, Table seguido del nombre de la entidad (TableUsuario, TableEdificio, etc) y el nombre del archivo, el mismo nombre sin el prefijo Table (usuario.php, edificio.php, etc).

Una vez creada esta clase podemos instanciarla a partir de JTable. Primero le indicaremos dónde buscar las clases de las tablas (en este ejemplo utilizamos las constantes JPATH_BASE, el directorio en el que se instaló Joomla, y DS, el separador de directorios en este sistema operativo) y luego qué clase instanciar:

JTable::addIncludePath(JPATH_BASE.DS.'modules'.DS.'mod_ejemplo'.DS.'tables');
$empleado =& JTable::getInstance('empleado', 'Table');

Una vez hecho esto ya podremos utilizar los métodos de nuestro nuevo objeto. Para traer una tupla de la base de datos usaríamos el método load, al que se le pasa la clave a buscar:

$empleado->load(1);
echo $empleado->nombre, ': ', $empleado->departamento;

Para crear una nueva tupla en la base de datos establecemos los valores para los campos con set, comprobamos que sean válidos con check y los almacenamos con store.

$empleado->set('nombre', 'Samuel');
$empleado->set('departamento', 'Recursos humanos');

if (!$empleado->check() or !$empleado->store()) {
  echo 'Ocurrio un error: ', $empleado->getError();
}

También podemos establecer los valores para los campos mediante un array, con el método bind:

$datos = array('nombre' => 'Carlos', 'departamento' => 'Finanzas');

$empleado->bind($datos);

if (!$empleado->check() or !$empleado->store()) {
  echo 'Ocurrio un error: ', $empleado->getError();
}

O usar el método save, que llama a su vez a bind, check y store

$datos = array('nombre' => 'Juan', 'departamento' => 'Mantenimiento');

if (!$empleado->save($datos)) {
  echo 'Ocurrio un error: ', $empleado->getError();
}

Para actualizar una tupla podemos hacer uso de una combinación de load y store

$empleado->load(1);

$empleado->set('departamento', 'Finanzas');

if (!$empleado->check() or !$empleado->store()) {
  echo 'Ocurrio un error: ', $empleado->getError();
}

Por último, para borrar una tupla utilizaremos el método delete, al que se le pasa el identificador de la tupla que queremos eliminar:

$empleado->delete(1);

Tipos de parámetros para las extensiones de Joomla!

Zootropo — Thu, 14 Jan 2010 12:03:28 +0000

Además del tipo text del que ya hablamos en Creación de módulos para Joomla! existen muchos otros tipos de parámetros que podemos utilizar a la hora de desarrollar los distintos tipos de extensiones que existen en Joomla (no solo en los módulos). Estos son:

calendar

Muestra una caja de texto en la que introducir una fecha junto con un icono sobre el que se puede pulsar para mostrar un calendario de tipo pop-up con el que seleccionar la fecha de forma más cómoda. Las distintas opciones disponibles para este tipo son las siguientes:

name: nombre del parámetro. Es la cadena que se utiliza a la hora de recuperar el valor del parámetro
label: etiqueta. Es el texto que acompañará al widget en la página de opciones del parámetro
description: descripción del campo. Este texto se muestra al usuario cuando mantiene el cursor del ratón un cierto tiempo sobre el widget
default: valor por defecto
class: clase CSS a utilizar para la etiqueta
format: formato de fecha a utilizar (usando los especificadores de fecha de PHP)

editors

Muestra una lista con los distintos editores WYSIWYG instalados. Las únicas opciones para este parámetro son name, label, description y default.

filelist

Muestra una lista con los archivos contenidos en el directorio especificado. Además de name, label, description y default otras opciones útiles son:

directory: directorio para el cuál se listarán los archivos. Si no se especifica ningún valor se asume la raíz de Joomla!
filter: una expresión regular con la que filtrar los archivos mostrados en la lista.
exclude: una expresión regular que especifica archivos a excluir de la lista.
stripext: booleano que indica si deben ocultarse las extensiones de los archivos
hide_none: booleano con el que indicar que no queremos que se muestre la opción ‘- No utilizar -’
hide_default: booleano con el que indicar que no queremos que se muestre la opción ‘- Usar el predeterminado -’

folderlist

Muestra una lista con las distintas carpetas contenidas en el directorio especificado. Cuenta con las mismas opciones que filelist.

imagelist

Muestra una lista con las imágenes contenidas en un cierto directorio. Cuenta con las mismas opciones que filelist y folderlist.

helpsites

Muestra una lista con los distintos sitios de ayuda de Joomla.

hidden

Crea un campo oculto.

languages

Muestra una lista con los idiomas instalados para una cierta aplicación.

list

Muestra una lista con distintas opciones entre las que elegir. Esta etiqueta contendrá una o más etiquetas option con las opciones.

menuitem

Muestra una lista con las distintas entradas de menú disponibles en el sitio web.

password

Muestra una caja de texto en la que se puede introducir una contraseña.

radio

Muestra un grupo de botones de opción. Como list, esta etiqueta contendrá una o más etiquetas option con las opciones.

section

Muestra una lista con las secciones disponibles en el sitio web.

spacer

Muestra un separador. Por defecto esto se traducirá en un

. Si se da algún valor a default se mostrará este texto.

sql

Muestra una lista con los valores obtenidos al ejecutar una consulta SQL sobre la base de datos de Joomla. La consulta irá en la opción query y debe devolver un par de valores por tupla, uno con el texto a mostrar en la lista (con nombre title) y otro con el valor de la opción (con nombre value)

text

Muestra un campo de texto. Con la opción size se puede limitar el ancho del widget.

textarea

Muestra un área de texto. Las opciones cols y rows determinan, respectivamente, el número de columnas y filas de caracteres que ocupará el widget.

timezones

Muestra una lista de zonas horarias.

usergroup

Muestra una lista con los grupos de usuarios del sitio.

Creación de módulos en Joomla!

Zootropo — Thu, 14 Jan 2010 10:59:03 +0000

Existen 5 tipos de extensiones distintas en Joomla: módulos, componentes, plugins, plantillas y lenguajes. Los módulos, de cuya creación hablaremos en este pequeño tutorial, son uno de los tipos más sencillos: se trata de pequeñas aplicaciones cuya salida puede mostrarse en cualquier posición de entre las definidas en la plantilla, y de las cuales podemos tener un número cualquiera por página.

Un módulo en su forma más básica consiste sólo en un par de archivos, un archivo XML con información sobre el módulo y su instalación y un archivo PHP con el código del módulo en sí.

A modo de ejemplo vamos a ver cómo crear un pequeño módulo “Hola Mundo”.

Primero crearemos una carpeta mod_holamundo para contener nuestros archivos. En esta carpeta crearemos un archivo mod_holamundo.xml con el siguiente contenido



  Hola Mundo
  Raul Gonzalez
  Enero 2010
  (C) Raul Gonzalez
  GPL
  http://mundogeek.net/
  zootropo en gmail
  0.1
  Nuestro modulo de ejemplo
  
    mod_holamundo.php

como vemos en este archivo podemos indicar el nombre del módulo, el autor, la fecha de creación, la versión, la descripción de la funcionalidad del módulo, o los archivos que conforman el módulo, entre otros (he evitado el uso de acentos para ahorrarnos complicaciones con la codificación de caracteres).

Veamos ahora el código del archivo mod_holamundo.php. Este código podría ser tan sencillo como

Sin embargo, es una buena práctica evitar que se pueda ejecutar el módulo directamente, como si de un script independiente de Joomla! se tratase. Esto se hace comprobando si está definida la constante _JEXEC, y en caso contrario deteniendo la ejecución del script.

Ahora sí, ya tenemos listo nuestro módulo. Una vez hecho esto basta crear un archivo ZIP que contenga nuestro archivo XML y PHP usando, por ejemplo, WinZip o WinRAR, y ya podremos instalarlo desde la interfaz de administración de Joomla, dirigiéndonos a Extensiones -> Instalar/Desinstalar y seleccionando nuestro archivo .zip en la carpeta en la que se encuentre. Al instalar el módulo se habrá creado una nueva carpeta mod_holamundo en la carpeta modules de Joomla.

Si seleccionamos ahora Extensiones -> Administrador de módulos y ordenamos por ID veremos nuestro nuevo módulo Hola Mundo, listo para usarse. Basta marcarlo como Publicado y seleccionar la posición en la que queremos que se muestre en las opciones del módulo, a las que se puede acceder haciendo clic sobre su nombre.

Añadir opciones al módulo

Vamos a complicar un poco la cosa permitiendo al administrador del sitio elegir a quién quiere saludar. Es decir, vamos a modificar el módulo de forma que en esta ocasión se imprima “Hola” seguido de un texto que el administrador pueda especificar en las opciones del módulo.

Lo primero que tenemos que hacer es modificar el archivo XML y añadir una nueva etiqueta params. Dentro de esta etiqueta tendremos una etiqueta param por cada opción de configuración que requiera el módulo. En nuestro caso sólo necesitaremos un parámetro, de tipo text (una caja de texto) para más señas. Podéis consultar el resto de tipos disponibles en Parámetros para las extensiones de Joomla!.



  Hola Mundo
  Raul Gonzalez
  Enero 2010
  http://mundogeek.net/
  0.1
  Nuestro modulo de ejemplo
  
    mod_holamundo.php

El valor de esta opción de configuración se podrá obtener en el código del módulo haciendo uso del método get del objeto $params, al que se le pasa el nombre del parámetro y, opcionalmente, el valor a utilizar por defecto si el usuario no ha introducido ningún valor para este campo. De esta forma, el código de nuestro módulo quedaría tal que así:

get('quien', 'mundo');
?>

Y listo. Desinstala el módulo anterior, comprime ambos archivos, e instala la nueva versión del módulo para disfrutar de nuestra pequeña gran joya.

Dreamhost: Actualización de aplicaciones, WordPress 2.5 la semana que viene y consulta del estado vía Twitter, SMS, Jabber y AIM

Zootropo — Mon, 24 Mar 2008 09:50:31 +0000

En Dreamhost han actualizado su sistema de instalación de aplicaciones web con un solo clic con las últimas versiones de las siguientes aplicaciones:

ZenCart 1.3.8: aplicación para montar tiendas de comercio electrónico.
Pligg 9.9.0: CMS para montar clones de Digg / menéame.
Moodle 1.9: aplicación para crear comunidades de aprendizaje online.
Joomla 1.5.1: Uno de los CMS de código abierto más conocidos.
MediaWiki 1.12.0: Aplicación para la creación de Wikis. Es el sistema creado y utilizado por la Wikipedia.

También informan de que actualizarán su sistema de instalación con un solo clic con la versión 2.5 de WordPress tan pronto como esté disponible, en una semana más o menos.

Por último nos comentan que han creado una cuenta en Twitter mediante la que mantenerse informado de las novedades en Dreamhost y el estado de los servidores vía SMS, Jabber o AIM.