El blog de Zarovich

Se que llega bastante tarde, pero continúo con el tutorial para crear componentes Joomla. La parte positiva de todo esto es que ahora acumulo más experiencia construyendo componentes para Joomla y podré notificar determinados detalles que valga la pena comentar con especial detalle.

El objetivo ahora es construir una vista para el panel de administración que nos permita gestionar una pequeña tabla dentro de parte de la base de datos de Joomla. Para ello crearemos los scripts para instalación y desinstalación SQL que estarán indicados en el fichero de especificación del componente (el cual, cómo se comentó en el primer artículo, es un fichero que tenga el mismo nombre del componente en el raiz del componente).

        
            install.nombrecomponente.mysql.sql
    

    
        
            uninstall.nombrecomponente.mysql.sql
    

A continuación hay que crear estos dos ficheros en el raiz de la zona de administración del componente. Debereis crearlos con el mismo nombre que indicasteis en el xml de especificación.

administrator/components/com_nombrecomponente/

Para gestionar los nombres y los cumpleaños crearemos una sola tabla, en donde se almacene una id que facilite su gestión, el nombre, los apellidos (esto es buena idea para poder ordenar por apellidos en lugar de ordenar por nombre en caso de necesidad) y la fecha de cumpleaños. De esta manera la instrucción SQL debería de quedar de la siguiente manera.

CREATE TABLE IF NOT EXISTS `#__nombrecomponente_cumple` (
    `id` INT NOT NULL AUTO_INCREMENT,
    `nombre` VARCHAR(120) NOT NULL,
    `apellidos` VARCHAR(240) NOT NULL,
    `cumple` DATE NOT NULL,
    PRIMARY KEY (`id`)
)
ENGINE = InnoDB;

Para el fichero de desinstalación de la base de datos, simplemente se introducirá la instrucción para eliminar la tabla que se crea en el fichero de instalación.

DROP TABLE IF EXISTS `#__nombrecomponente_cumple`;

Es interesante comentar el detalle de que los nombres de la tabla comiencen por “#__”. Esto en realidad, es por que las instrucciones se ejecutan a través de la implementación de acceso a datos de Joomla. Joomla cuando ejecuta instrucciones SQL lo que hace es reemplazar el “#_” por el prefijo configurado para las tablas de la base de datos. Es decir que al ejecutarla Joomla lo reemplazará por “jos” o el que esté configurado.

Creando el modelo y la tabla en Joomla

Ahora viene el siguiente paso, es construir una clase que gestione esta tabla. Primero vamos a ver cómo se crea una clase JTable. Antes de nada se deberá de ir al nombrecomponente.php que hay en el raíz del componente en el lado del administrador, para añadir el include de las tablas y asegurarse de que está marcado cómo carpeta que deberá de instalar en el lado del administrador.

JTable::addIncludePath(JPATH_COMPONENT_ADMINISTRATOR.DS.'tables');

Ahora veamos el código de la clase JTable.

Ahora a continuación detallaré cómo funciona la clase modelo que implementa la gestión de esta tabla.

setId((int)$array[0]);
        } catch (Exception $e) {
            // do nothing
        }

        // Aquí se carga el soporte de configuración.
        // Tratar de dejarlo tal y cómo está aquí, es cómo funciona.
        $limit = $mainframe->getUserStateFromRequest('global.list.limit',
                                                     'limit',
                                                     $mainframe->getCfg('list_limit'),
                                                     'int');
        $limitstart = JRequest::getVar('limitstart', 0, '', 'int');
        $limitstart = ($limit != 0 ? (floor($limitstart / $limit) * $limit) : 0);
        $this->setState('limit', $limit);
        $this->setState('limitstart', $limitstart);
    }

    /**
    * Creais un método privado que permita facilitar la construcción de la parte base de la consulta
    */
    function _buildQuery() {
        $query = 'SELECT * FROM #__nombrecomponente_cumple';
        return $query;
    }

    /**
    * Método para definir el elemento actualmente seleccionado.
    * La id recibida logicamente será la id correspondiente al
    * elemento de la tabla de la base de datos.
    function setId($id)
    {
        $this->_id = $id;
        $this->_variable = null;
    }

    /**
    * Aquí se realiza una consulta básica, aplicando los elementos básicos para soportar
    * paginación.
    */
    function getData()
    {
        if (empty($this->_data)) { // Se trata de no repetir consultas ya realizadas.
            $query = $this->_buildQuery(); // Se crea la consulta base.
            if (empty($this->_pagination)) { // Se comprueba si se va a trabajar con paginación.
                /** En caso de no usar paginación, se usará la consulta directamente */
                $this->_data = $this->_getList($query);
            } else {
                /** En caso de usar paginación, se pasarán los límites.
                * El método getState recupera los límites de la sesión
                */
                $this->_data = $this->_getList($query,
                                               $this->getState('limitstart'),
                                               $this->getState('limit'));
            }
            /**
            * Esto es posible que no lo veais en el tutorial oficial de Joomla, pero
            * recomiendo hacerlo. Simplemente si tras hacer toda la consulta,
            * los resultados están vacios, en lugar de tener un _data a null, mejor
            * tener un array vacío. Esto os facilitará su gestión en las capas superiores
            * del componente (controlador y vista).
            */
            if (empty($this->_data)) $this->_data = array();
        }

        return $this->_data;
    }

    /**
    * Este método permitirá recuperar un helper que generará el código
    * HTML necesario para empotrar en la vista para el uso de páginas.
    * Es recomendable montarlo así, para tratar de que la interfaz del
    * panel de administración se mantenga homogénea.
    */
    function getPagination()
    {
        if (empty($this->_pagination)) {
            jimport('joomla.html.pagination');
            $this->_pagination = new JPagination($this->getTotal(),
                                                 $this->getState('limitstart'),
                                                 $this->getState('limit'));
        }

        return $this->_pagination;
    }

    /** Este método permitirá recuperar el total de elementos que se
    * devolvería en la consulta definida. En este caso está buildQuery,
    * pero generalmente lo que hago es tener _buildQuery que trate
    * filtros y todo (sin aplicar orden, paginación, etc) y _buildBaseQuery
    * que si sería el equivalente al _buildQuery que teneis aquí implementado.
    */
    function getTotal()
    {
        if (empty($this->_total)) {
            $query = $this->_buildQuery();
            $this->_total = $this->_getListCount($query);
        }
        return $this->_total;
    }

    /**
    * Permite recuperar la instancia del cumple seleccionado.
    */
    function getCumple()
    {
        if ($this->_loadFood()) { // Si el cumple existe, será el que devuelva.
        } else $this->_initFood(); // En caso de no existir devolverá una instancia inicializada con valores por defecto

        return $this->_food;
    }

    /** Método que en realidad realizará la carga del cumple, se define como privado
    * ya que lo normal sería acceder por getCumple, que automatizará el proceso
    * de decidir si es un nuevo elemento o no.
    */
    function _loadCumple()
    {
        if (empty($this->_cumple))
        {
            $query = 'SELECT * FROM #__nombrecomponente_cumple WHERE id='.$this->_id;
            $this->_db->setQuery($query);
            $this->_food = $this->_db->loadObject();

            return (boolean) $this->_cumple;
        }
    }

    /**
    * Inicializa un nuevo componente, lo mismo, la idea es acceder a través
    * de getCumple
    */
    function _initCumple()
    {
        if (empty($this->_cumple)) {
            $cumple = new stdClass();
            $cumple->id = 0;
            $cumple->nombre = null;
            $cumple->apellidos = null;
            $cumple->cumple = null;

            $this->_cumple = $cumple;
            return (boolean) $this->_cumple;
        }

        return true;
    }

    /** Este método será el encargado de almacenar un elemento.
    * Lo genial de esto es que al trabajar con la clase table, esto quedará
    * realmente sencillo.
    */
    function store()
    {
        $row =& JTable::getInstance('cumple', 'Table'); // Se carga la tabla en cuestión.

        /** Se realiza la vinculación con los campos del post que tengan
        * el mismo nombre que las columnas. Esto es importante tenerlo
        * en cuenta a la hora de implementar la vista que implementa el
        * formulario que maneja esto.
        */
        if (!$row->bind(JRequest::get('post')))
            return JError::raiseWarning(500, $row->getError() ); // es educado devolver errores.

        if (!$row->store())
            JError::raiseError(500, $row->getError() );
    }

    /** Ocurre lo mismo que en el caso de store(), esto nos permitirá
    * realizar la implementación del borrado en muy pocas líneas.
    */
    function delete() {
        $row =& $this->getTable('cumple', 'Table');
        if (!$row->delete($this->_id)) { // Se ordena el borrado de la id seleccionada.
            $this->_error = $row->getError();
            return false;
        } else return true;
    }
}
?>

El código anterior advierto que es un copy paste alterado de un modelo de un componente ya realizado. Se que lo normal para realizar el tutorial sería coger y hacer el componente, y basar su código en él. Pero creo que las ideas fundamentales se plasman bastante bien y espero que os sean de ayuda. De todas formas cuando acabe con la serie de tutoriales montaré el componente que estamos de usando de ejemplo, para que podais analizarlo con detalle, juguetear con sus tripas y lo tendré completamente poblado de comentarios para que os ayude en vuestro proceso de aprendizaje.

Se que en la primera parte digo que en la parte 2 iba a mostrar la implementación de un controlador, un modelo y vista… Pero creo que mejor fragmentar más el tutorial, ya que si no me van a quedar posts gargantuescos.

Creación de componentes para Joomla: parte 1