Joomla! Documentation™

Joomla! 

≥ 3.0

Tutorial

La sistema de plugin de autenticación para Joomla! ofrece una gran flexibilidad y potencia para el sistema. Utilizando el sistema, es posible autenticar a los usuarios de cualquier origen - la base de datos interna de Joomla!, un sistema de Identificación Abierto, un directorio LDAP o cualquier sistema de autenticación al que se pueda acceder usando PHP.

En este tutorial se presenta un ejemplo básico real de un plugin de autenticación que demuestra cómo crear plugins de autenticación personalizados para el CMS de Joomla!.

La clase plgAuthenticationMyauth

Los plugins de Joomla! son creados por la creación de una clase hija de la clase JPlugin. La clase JPlugin proporciona toda la infraestructura y la funcionalidad básica que se requiere. Todo lo que es necesario es proporcionar los métodos necesarios para manejar el evento deseado.

Para crear un plugin de autenticación, el nombre de la clase hija debe comenzar con plgAuthentication y debe terminar con el nombre del plugin que está siendo creado. En nuestro caso, el plugin se llama Myauth, por lo que la clase se llamará plgAuthenticationMyauth.

La clase dispone de un método único - el método onUserAuthenticate(). Este método es realmente muy simple, como se demostrará.

El Método onAuthenticate()

El método onAuthenticate() es el método que será llamado cuando el sistema este tratando de usar el plugin para autenticar al usuario. A este método serán pasados tres parámetros: las credenciales, algunas opciones extra, y una referencia a un objeto de tipo JAuthenticationResponse. Este método necesita determinar si el nombre de usuario y la contraseña son una combinación válida para la autenticación y devolver el resultado al objeto JAuthenticationResponse.

Para nuestro ejemplo, la comprobación de autenticación que vamos a hacer es muy simple. Simplemente asegurarnos que el nombre de usuario especificado existe en la tabla de usuarios, y si lo existe, vamos a comprobar si el nombre de usuario es el inverso de la contraseña. Nota puesto que en el objeto database se crea en el constructor, así se puede llamar con $db. Así que nuestra comprobación de autenticación se verá así:

$db = JFactory::getDbo();
$query	= $db->getQuery(true)
	->select('id')
	->from('#__users')
	->where('username=' . $db->quote($credentials['username']));

$db->setQuery($query);
$result = $db->loadResult();

/**
 * To authenticate, the username must exist in the database, and the password should be equal
 * to the reverse of the username (so user joeblow would have password wolbeoj)
 */
if($result && ($credentials['username'] == strrev( $credentials['password'] )))

Aunque en nuestro ejemplo esto es muy básico, este código puede ser reemplazado por cualquier código que sea necesario para realizar la comprobación de autenticación que consideremos oportuna para el plugin. La flexibilidad esta limitada solamente por lo que PHP puede hacer.

Ahora que hemos determinado si la autenticación se realiza correctamente o no, entonces podemos crear nuestra respuesta:

$db = JFactory::getDbo();
$query	= $db->getQuery(true)
	->select('id')
	->from('#__users')
	->where('username=' . $db->quote($credentials['username']));

$db->setQuery($query);
$result = $db->loadResult();

if (!$result) {
    $response->status = JAuthentication::STATUS_FAILURE;
    $response->error_message = 'User does not exist';
}
/**
 * To authenticate, the username must exist in the database, and the password should be equal
 * to the reverse of the username (so user joeblow would have password wolbeoj)
 */
if($result && ($credentials['username'] == strrev( $credentials['password'] )))
{
    $email = JUser::getInstance($result); // Bring this in line with the rest of the system
    $response->email = $email->email;
    $response->status = JAuthentication::STATUS_SUCCESS;
}
else
{
    $response->status = JAuthentication::STATUS_FAILURE;
    $response->error_message = 'Invalid username and password';
}

Para la respuestas fallidas, hemos establecido dos propiedades del objeto de respuesta: la propiedad status y la propiedad error_message. Actualmente hay reconocidos seis valores de respuesta de estado STATUS_SUCCESS, STATUS_FAILURE, STATUS_CANCEL, STATUS_EXPIRED, STATUS_DENIED y STATUS_UNKNOWN. Para más información sobre estos valores de estado, consulta el archivo libraries/joomla/user/authentication.php.

La propiedad error_message se establece en caso que la autenticación no es correcta. En nuestro plugin, podemos establecer dos valores posibles para esta propiedad: "El usuario no existe", lo que indica que la consulta no devuelve ningún resultado, y "No es válido el nombre de usuario y contraseña", lo que indica que la contraseña no era la inversa del nombre de usuario. Cabe señalar que estos valores no son devueltos al usuario. Por razones de seguridad, la única cosa que el usuario va a ver es un inicio de sesión exitoso o un mensaje que dice: "El nombre de Usuario y la contraseña no coinciden." El sistema de Joomla! puede ser configurado para que estos mensajes de error puedan ser almacenados en un archivo de registro para fines de depuración.

Si la autenticación es correcta, opcionalmente podemos agregar la información de nuestra fuente de autenticación en la respuesta. En este caso, estamos recuperando la información de usuario de la base de datos de Joomla! y almacenamos la dirección de correo electrónico en el objeto response. Para obtener más información sobre qué datos pueden ser almacenados en el objeto response, por favor, consulta el API de Joomla! . Estos datos pueden ser utilizados por el usuario de los plugins en el caso de que se desee crear automáticamente los usuarios o realizar otras tareas de inicio de sesión.

El Archivo myauth.php Completo

Ahora que hemos completado los dos métodos que son necesarios para nuestra clase, hemos puesto nuestra clase en un archivo PHP que tiene el mismo nombre de nuestro plugin. Desde nuestro plugin se llama Myauth, llamamos a nuestro archivo myauth.php. Aquí está el listado completo de este archivo:

<?php
/**
 * @version    $Id: myauth.php 7180 2007-04-23 16:51:53Z jinx $
 * @package    Joomla.Tutorials
 * @subpackage Plugins
 * @license    GNU/GPL
 */

// Check to ensure this file is included in Joomla!
defined('_JEXEC') or die();

/**
 * Example Authentication Plugin.  Based on the example.php plugin in the Joomla! Core installation
 *
 * @package    Joomla.Tutorials
 * @subpackage Plugins
 * @license    GNU/GPL
 */
class plgAuthenticationMyauth extends JPlugin
{
    /**
     * This method should handle any authentication and report back to the subject
     * This example uses simple authentication - it checks if the password is the reverse
     * of the username (and the user exists in the database).
     *
     * @access    public
     * @param     array     $credentials    Array holding the user credentials ('username' and 'password')
     * @param     array     $options        Array of extra options
     * @param     object    $response       Authentication response object
     * @return    boolean
     * @since 1.5
     */
    function onUserAuthenticate( $credentials, $options, &$response )
    {
        /*
         * Here you would do whatever you need for an authentication routine with the credentials
         *
         * In this example the mixed variable $return would be set to false
         * if the authentication routine fails or an integer userid of the authenticated
         * user if the routine passes
         */
        $db = JFactory::getDbo();
	$query	= $db->getQuery(true)
		->select('id')
		->from('#__users')
		->where('username=' . $db->quote($credentials['username']));

	$db->setQuery($query);
	$result = $db->loadResult();

	if (!$result) {
	    $response->status = STATUS_FAILURE;
	    $response->error_message = 'User does not exist';
	}

	/**
	 * To authenticate, the username must exist in the database, and the password should be equal
	 * to the reverse of the username (so user joeblow would have password wolbeoj)
	 */
	if($result && ($credentials['username'] == strrev( $credentials['password'] )))
	{
	    $email = JUser::getInstance($result); // Bring this in line with the rest of the system
	    $response->email = $email->email;
	    $response->status = JAuthentication::STATUS_SUCCESS;
	}
	else
	{
	    $response->status = JAuthentication::STATUS_FAILURE;
	    $response->error_message = 'Invalid username and password';
	}
    }
}
?>

El Manifiesto XML de Instalación

Ahora que hemos creado nuestra clase JPlugin, todo lo que debemos hacer es crear nuestro archivo XML de instalación que le dirá al instalador de Joomla! cómo instalar nuestro plugin. Este archivo es simple:

<?xml version="1.0" encoding="utf-8"?>
<extension version="3.1" type="plugin" group="authentication">
    <name>Authentication - Myauth</name>
    <author>Joomla! Documentation Project</author>
    <creationDate>May 30, 2007</creationDate>
    <copyright>(C) 2005 - 2013 Open Source Matters. All rights reserved.</copyright>
    <license>http://www.gnu.org/copyleft/gpl.html GNU/GPL</license>
    <authorEmail>ian.maclennan@help.joomla.org</authorEmail>
    <authorUrl>www.joomla.org</authorUrl>
    <version>1.0</version>
    <description>An sample authentication plugin</description>
    <files>
        <filename plugin="myauth">myauth.php</filename>
    </files>
    <config/>
</extension>

Te darás cuenta que este archivo es muy similar a cualquier otro archivo de manifiesto XMl de instalación de Joomla!. Hay un par de cosas importantes a notar.

La primera cosa a notar es el atributo group en el elemento raíz. Para la autenticación de los plugins, el atributo group debe tener el valor 'authentication'. Esto le dice al sistema de Joomla! que trate al plugin, como un plugin de autenticación.

También es importante tener en cuenta que el atributo version del elemento raíz (extensión) debe ser de 3.0. Esto le dirá a Joomla! que el plugin está escrito para Joomla! .

Entramos el nombre 'Authentication - Myauth' en el campo nombre. El plugin no TIENE que seguir este convenio, pero se ve mejor, porque entonces va a coincidir con el estándar de plugins de autenticación que aparecen en el administrador de plugins.

Por último, observa que el atributo filename, que contiene nuestro archivo de complemento tiene un atributo llamado plugin. El valor de este debe ser el nombre de nuestro plugin. En este caso, es myauth.

Empaquetando Todo y a Usarlo

Ahora que hemos creado nuestros dos archivos, todo lo que tenemos que hacer es un paquete con ellos en un archivo que pueda ser leído por la el sistema de instalación de Joomla!.

Una vez que los empaquetamos e instalamos nuestro plugin, está listo para ser utilizado. El plugin se publica mediante el Gestor de plugins. Todos los plugins de autenticación se agrupan. Los Plugins están habilitados con 'su publicación'. Puedes publicar la cantidad de plugins de autenticación que desees. En orden del éxito de la autenticación, de ocurrir, sólo uno de los plugins necesita devolver a un resultado JAUTHENTICATE_STATUS_SUCCESS.

Conclusión

Ahora hemos creado un plugin de autenticación simple. Hemos mostrado el proceso básico de hacer una comprobación de autenticación y devolver los resultados al sistema de Joomla!.

También puede probar fácilmente este plugin empaquetándolo tu mismo.