Dev con Joomla componentes modulos plugins

Desenvolvemento en Joomla! 1.5 Tomás Vilariño Fidalgo II Xornadas de Programación Web en Software Libre Ourense, 24 de Xuño de 2008

Contidos
Introdución
Instalación, configuración e posta en funcionamento
Arquitectura de Joomla! 1.5
Languages
Templates
Modules
Plugins
Components
API Base de datos
Integración con outros frameworks
Referencias e conclusións

Introdución

Introdución
Joomla! é un CMS desenvolvido en PHP baixo GNU/GPL. É o resultado dunha bifurcación e mellora de Mambo (Mambo 4.5.2.3).
O nome de Joomla! vén da palabra suajili jumla que significa " todos xuntos " ou " como un todo ".
A primeira versión de Joomla! (Joomla! 1.0.0) publicouse 16 de setembro de 2005.
Actualmente está dispoñible a versión Joomla! 1.5.3 construída baixo PHP 5.2

Introdución
Joomla é un CMS moi flexible, en parte grazas ao fácil que resulta desenvolver extensións (compoñentes, plugins, modules) .
As extensións serán o mecanismo co que conta Joomla! 1.5 para dotarse de maiores funcionalidades e contrarrestar as súas deficiencias (multi idioma, multi sitio, xestión de usuarios limitadas, ...).
Isto propicia a aparición dunha gran comunidade de desenvolvedores que xera unha gran cantidade de extensións.

Introdución
A tendencia de Joomla! comparada con Drupal e TYPO3 en Google Trends
Joomla! 1.0 publicouse o 16 de setembro 2005

O desenvolvemento de extensións de Joomla! evolucionou coa aparición da nova versión 1.5
Creouse un potente framework e potenciouse o aspecto de POO aproveitando as vantaxes de PHP 5.
Olvidémonos de PHP4:
http://gophp5.org/
Introdución

Instalación

Instalación
Requisitos (recomendados):
GNU/Linux
Apache 2.x
PHP 5.x
MySQL 5.x
http://joomlacode.org/gf/project/joomla/frs/?action=FrsReleaseBrowse&frs_package_id=3587
Descargar Joomla! 1.5 dende:

Instalación
Antes de comezar a instalación é recomendable crear a base de datos:
$ mysqladmin –u db_user –p create joomla dende liña de comandos
ou dende phpmyadmin

Instalación
O asistente de instalación de Joomla componse de sete pasos:
Escoller o idioma do instalador
Chequeo de pre-instalación
Licenza
Configuración da base de datos
Configuración do FTP
Outras configuracións
Finalizar

Instalación
Paso 1: selección do idioma

Instalación
Paso 2: revisión previa

Instalación
Paso 3: licenza

Instalación
Paso 4: configuración da base de datos

Instalación
Paso 5: configuración do servidor FTP

Instalación
Paso 6: configuración principal

Instalación
Ao finalizar a instalación recoméndase obrígannos a eliminar o directorio de instalación para poder comezar a traballar
Despois de eliminar o directorio de instalación xa podemos traballar co Site ou Admin

Arquitectura

O site de Joomla 1.5 (Frontend/Principal/Sitio)
Arquitectura

O administrator de Joomla 1.5 (Backend/Administración)
Arquitectura

Estrutura de directorios separadas
parte de administración (Administrator, Backend, administración, ...)
parte pública (Site, Frontend, frontal, ...)
Parte de administración e pública teñen similitudes
Comparten o cartafol /libraries/
O funcionamento interno da administración é similar ao da parte pública
http://localhost/joomla/administrator/index.php?option= com_conten t&task= add Arquitectura

Arquitectura
Joomla 1.5 esta composto de módulos, compoñentes e plugins. ( Tamén poderíamos considerar aos templates e aos ficheiros de idioma extensións de Joomla!)
Os módulo s son pequenos anacos de contido como pode ser un menú, isto é un modulo:
O compoñente é onde se mostra o contido principal en Joomla! (miniaplicación) -> só se executa un por petición, o que se especifica no parámetro option
Os plugin s responden a eventos do sistema (login de usuarios, ao mostrar contidos, cando se autentican, ... )

Arquitectura

A parte das extensións incluídas en Joomla! é posible extender as funcionalidades por medio de novas extensións
As extensións instalaranse dende o administrador de extensións (no backend, obvio :-)
Arquitectura

Component
Module
Plugin
Language
Tool : aplicacións externas que permiten xestionar ou facilitar o traballo dun sitio Joomla!
Special : extensión específicas que requiren doutras extensións para o seu funcionamento.
http://extensions.joomla.org
Arquitectura Onde atopar extensións para Joomla! ?

Arquitectura Joomla! está deseñado a partires dun framework (agora todo son frameworks: CakePHP, Django, Ruby on Rails, FLOW3, ... ;-)

Languages

Languages
Joomla! permite importar paquetes de idioma tendo traducida a interface do sitio ( site ) e/ou administración ( administrator ).
Entre as configuracións de Joomla! é posible activar a depuración de cadeas de idioma (Configuración global | Sistema) .
Paquetes de idioma galego:
https://forxa.mancomun.org/projects/joomlagalego/
En castelán:
http://www.todosjuntos.org/content/view/55/1/

No xestor de idiomas establécese o idioma por defecto. Para ter un sitio con soporte multi idioma hai que botar man da extensión JoomFish: http://www.joomfish.net/ Languages

Na configuración global habilítase a depuración da lingua Languages

Na configuración global habilitando o modo de depuración obtemos información dos ficheiros de idioma cargados, cadeas sen tradución, consultas realizadas a base de datos, ... Languages

Formato dun ficheiro de idioma INI (p.e.: <path_joomla>/language/gl-ES/gl-ES.com_content.ini)
ACCESS LEVEL=Nivel de Acceso
ADD=Agregar
ALIGN=Aliñar
ALL PAGES=Todas as páxinas
ALT TEXT=Texto alternativo
ALREADY EXISTS=Xa existe
...
API para empregar a tradución
<?php echo Jtext::_('ADD'); ?>
Languages

$ mv en-GB.ini en-GB.properties
$ prop2po -P en-GB.properties en-GB.pot
processing 1 files...
[###########################################] 100%
$ cp en-GB.pot gl-ES.po
$ po2prop -t en-GB.pot gl-ES.po gl-ES.properties
$ mv gl-ES.properties gl-ES.ini
http://translate.sourceforge.net/wiki/toolkit/prop2po
Xerar o ficheiro PO para utilizar ferramentas de tradución de software: poEdit, Kbabel, gTranslator, ... Despois de traducir o ficheiro gl-ES.po convertilo a formato INI Languages

PoEdit facilita a edición de ficheiros PO Languages

Templates

O sistema de templates da versión 1.5 de Joomla sufriu cambios destacables durante o proceso de desenvolvemento.
Inicialmente íase botar man do motor de plantillas patTemplate e por cuestións de rendemento desbotouse a idea.
A biblioteca inda está no cartafos /libraries/ inclúese por razóns de compatibilidade.
http://trac.php-tools.net/patTemplate
Templates

Novidades no motor de plantillas en J! 1.5:
Accesibilidade nas plantillas por defecto
Compatibilidade cara atrás, versións 1.0.x (legacy mode).
$this->countModules('user1 + user2').
Sentencias condicionais.
<jdoc :include ... />
Detección automática do uso do editor WYSIWYG.
Parametrización.
Soporte para múltiples follas de estilo (CSS).
Overrides, sobrescriben a saída por defecto das extensións.
http://www.joomla.org/component/option,com_jd-wp/Itemid,33/p,210/
Templates

Instalación de temas creados para Joomla!
Descargamos un tema p.e.- “Go Vista Plain” e instalámolo empregando o xestor de extensións do administrador de Joomla!
http://www.augs-burg.de/joomla/joomla1.5-templates.php
Templates

Deseñamos unha plantilla de Joomla! propia
Partimos do seguinte deseño: http://www.intensivstation.ch/files/en_templates/2/template-3.html
Templates

Definimos as nosas posicións (positions) onde situaremos os módulos e o compoñente (left, right, user1, ...)
Templates

Empregamos <jdoc:include ... /> para definir as posicións
< html xmlns= " http://www.w3.org/1999/xhtml " xml: lang = "en" lang = "en" >
< head >
< jdoc :include type = "head" />
</ head >
< body >
< div id = "container" >
< jdoc :include type = "message" />
< div id = "outer" >
< div id = "inner" >
< div id = "left" >< h2 > Esquerda </ h2 >
< jdoc :include type = "modules" name = "left" />
</ div >
< div id = "content" >
< h2 > Contido </ h2 >
< jdoc :include type = "component" />
</ div > 
...
Templates

<? xml version = "1.0" encoding = "utf-8" ?> <install version = "1.5" type = "template" > <name> Template Fortune </name> <version> 1.0 </version> <creationDate> 09/04/07 </creationDate> <authorEmail> [email_address] </authorEmail> <authorUrl> http://vifito.es </authorUrl> <license> GNU/GPL </license> <description> Template de exemplo </description> <files> <filename> index.php </filename> <filename> templateDetails.xml </filename> <filename> template.png </filename> <filename> template_thumbnail.png </filename> <filename> media/3.css </filename> ... <filename> media/xhtml10.gif </filename> </files> <positions> <position> left </position> <position> right </position> <position> top </position> <position> fortune </position> </positions> <params> </params> </install> Templates templateDetails.xml

Construímos un ficheiro .zip e instalamos a plantilla dende o administrador de extensións.
Resultado
Templates

Referencias:
Titorial sobre plantillas para a versión 1.5
http://www.joomla.org/component/option,com_jd-wp/Itemid,33/p,210/
O titorial de referencia obrigatoria (imprescindible)
http://dev.joomla.org/downloads/Joomla15TemplateTutorial.zip
Templates

Modules

Modules
Imos desenvolver un módulo simple que amose unha frase recuperada do programa fortune ( http://fortune-gui.sourceforge.net/ )
Por motivos de tempo vanse a quedar moitas cousas sen explicar, como o uso de parámetros, etc.

Os módulos atópanse situados no directorio /modules/ dentro do directorio de instalación de Joomla e por cada módulo hai un cartafol con nome mod_nomeModulo .
O noso módulo vaise a chamar fortune .
o cartafol do módulo chamarase / mod_fortune/ .
Vemos a continuación a estrutura do módulo .
Modules

Estrutura do módulo “mod_fortune” Modules

Modules - mod_fortune.php : ficheiro php co mesmo nome co módulo, tomará o control do módulo cando sexa chamado - helper.php : clase helper, serve para separar a lóxica da presentación. - directorio / tmpl/ : aquí gardaremos as plantillas que usaremos para a presentación -Por defecto, úsase o template default.php - mod_fortune.xml : ficheiro xml necesario para xerar un instalable e onde especificaremos os parámetros do módulo.

Código do punto de entrada mod_fortune.php Modules <?php // Non permitir o acceso directo defined ( '_JEXEC' ) or die( 'Acceso restrinxido' ); require_once( dirname ( __FILE__ ). DS . 'helper.php' ); $mensaxe = modFortuneHelper :: getMensaxe ( $params ); require( JModuleHelper :: getLayoutPath ( 'mod_fortune' , 'default' ) ); mod_fortune/mod_fortune.php

Modules <?php // Non permitir o acceso directo defined ( '_JEXEC' ) or die( 'Acceso restrinxido' ); class modFortuneHelper { function getMensaxe ( $params ) { $linhas = array(); $mensaxe = exec ( '/usr/games/fortune' , $linhas ); return( htmlentities ( implode ( '' , $linhas )) ); } } Helper.php é o ficheiro que contén a lóxica do módulo. A clase helper debe chamarse co nome do módulo sen “_” seguido de helper (modFortuneHelper) : mod_fortune/helper.php

Modules <?php // Non permitir o acceso directo defined ( '_JEXEC' ) or die( 'Acceso restrinxido' ); echo $mensaxe ; ?> mod_fortune/tmpl/default.php

<? xml version = "1.0" ?> <install type = "module" version = "1.5.0" > <name> Fortune </name> <author> vifito </author> <version> 1.0 </version> <creationDate> 18-06-2008 </creationDate> <description> Módulo que amosa unha mensaxe fortune aleatoria. </description> <authorEmail> [email_address] </authorEmail> <files> <filename module = "mod_fortune" > mod_fortune.php </filename> <filename> helper.php </filename> <filename> mod_fortune.xml </filename> <filename> tmpl/default.php </filename> </files> </install> Ficheiro XML utilizado polo instalador de Joomla! Modules

Resultado: Modules

Plugins

Que son os plugins?
Son extensións que permiten modificar o comportamento do programa
Que fan os plugins?
Interceptan certos eventos prefijados para executar o noso código antes ou despois do evento.
Existen varios tipos de plugins
Por cada tipo de plugin existe un directorio dentro do directorio plugins
Polo tanto temos o directorio plugins/content para os plugins de tipo content e así con todos os tipos.
Plugins

Plugins
authentication : autenticación dos usuarios no proceso de login ( LDAP , openid, contas de google, ...)
content : procesar os ítems de contidos
editors : editores WYSIWYG que poden ser utilizados para a edición de contidos.
editors-xtd : extensións do editor (creación de botóns adicionais)
search : personalización das procuras realizadas nun sitio (incluír nas buscas resultados de novos compoñentes)
system : escoita eventos do sistema
user : procesa as accións dun usuario
xmlrpc : crea respostas XML-RPC (APIs blogger, SITEMan, ...)

Implementación do plugin
Un plugin é un obxecto que deriva da clase JPlugin .
Esta clase ten uns métodos definidos que responden aos eventos do sistema (hooks)
Polo tanto teremos que sobrescribir o hook preciso para que reaccione a acción que desexemos.
Plugins

Obxectivo do plugin: Amosar unha mensaxe antes do cada artigo
Estrutura do plugin Fortune
Plugins

<? xml version = "1.0" encoding = "utf-8" ?> <install version = "1.5" type = "plugin" group = "content" > <name> Fortune Content </name> <author> vifito </author> <creationDate> Xuño 2008 </creationDate> <license> http://www.gnu.org/licenses/gpl-2.0.html </license> <authorEmail> [email_address] </authorEmail> <authorUrl> vifito.es </authorUrl> <version> 1.0 </version> <description> Insertar fortune antes do contido </description> <files> <filename plugin = "fortune" > fortune.php </filename> </files> <params/> </install> Plugins plugins/content/fortune.xml

Plugins <?php defined ( '_JEXEC' ) or die( 'Acceso Restrinxido' ); jimport ( 'joomla.plugin.plugin' ); // Convención : Nome da clase (plg + tipo plugin + nome do plugin) class plgContentFortune extends JPlugin { function plgContentFortune ( & $subject ) { parent :: __construct ( $subject ); } function onBeforeDisplayContent (& $article , & $params , $limitstart = 0 ) { $linhas = array(); $mensaxe = exec ( '/usr/games/fortune' , $linhas ); return( htmlentities ( implode ( ' ' , $linhas )) ); } } plugins/content/fortune.php

Resultado:
Plugins

Components

O compoñente é a mini-aplicación que executa Joomla! (http://.../index.php?option=com_...)
Os compoñentes pódense implementar empregando o patrón MVC (recomendable para aproveitar as vantaxes do framework)
MVC é un patrón de arquitectura de software que separa os datos dunha aplicación, a interfaz de usuario, e a lóxica de control en tres compoñentes distintos.
http://es.wikipedia.org/wiki/Modelo_Vista_Controlador
Component

Por que é tan importante?
Seguindo este patrón crearemos código máis ordenado.
Será máis fácil entender o código de terceiros (e o noso), xa que segue un patrón coñecido.
Aumenta a produtividade.
En Joomla! as clases que implementan o patrón son: JModel – JView - JController
Component

Component
Estrutura dun compoñente en Joomla! simplificada (imos ver só a parte do frontend con varias vistas para soportar Ajax).

O controlador: o controlador é o punto de entrada da aplicación, mantense a escoita de todas as peticións, executa a lóxica da aplicación, e amosa a vista apropiada para cada caso.
O modelo: o modelo contén todo o código relacionado co acceso a datos . É importante que sexa un código o máis xenérico posible e se poida reutilizar. Nunca incluiremos lóxica no modelo, soamente consultas á base de datos e validacións de entrada de datos.
A vista : a vista contén o código que representará o que vemos por pantalla , neste caso trátase de código html (tamén feed RSS, PDF, ...)
Component

Existen dúas formas de traballar:
-Usando un ficheiro XML onde se especifica que é cada cousa (Struts).
-Usando convencións (Joomla!).
Paradigma de diseño “Convention over Configuration” (CoC)
Component
http://en.wikipedia.org/wiki/Convention_over_Configuration

Que son as convencións?
Son normas a seguir para crear as vistas (JView), os modelos (JModel) e os controladores (JController).
Usar convencións adoita resultar máis rápido que usar ficheiros XML.
Os ficheiros XML poden crecer desorbitadamente ata o punto de facerse pouco mantenibles.
Component

Obxecto Controlador (JController):
NomeCompoñente + Controller
Obxecto Vistas (JView):
nomeCompoñente + View + nomeVista
Obxecto Modelo (JModel):
nomeCompoñente + Model + Nome do modelo
Component

Component Punto de Entrada <?php // Non permitir o acceso directo defined ( '_JEXEC' ) or die( 'Acceso restrinxido' ); // Controlador base require_once( JPATH_COMPONENT . DS . 'controller.php' ); // Procurar o controlador si se pide na petición if( $controller = JRequest :: getWord ( 'controller' ) ){ $path = JPATH_COMPONENT . DS . 'controllers' . DS . $controller . '.php' ; if ( file_exists ( $path )) { require_once $path ; } else { $controller = '' ; } } // Instanciar o controlador $classname = 'FortuneAjaxController' . $controller ; $controller = new $classname (); // Executar a tarefa que vén da petición $controller -> execute ( JRequest :: getVar ( 'task' ) ); // Redirixir $controller -> redirect (); com_fortuneajax/fortuneajax.php

Compróbase se vén un parámetro na query string que estableza un controlador, e se vén impórtase o ficheiro co controlador.
Instanciase o controlador.
Execútase o método execute do controlador.
Execútase o método redirect do controlador.
Component

Component Controlador <?php /** * @package vifito.joomla * @subpackage component * @link http://vifito.es/ * @license GNU/GPL */ defined ( '_JEXEC' ) or die( 'Acceso restrinxido' ); jimport ( 'joomla.application.component.controller' ); class FortuneAjaxController extends JController { function display () { parent :: display (); } } com_fortuneajax/controller.php

Component Vista <?php defined ( '_JEXEC' ) or die( 'Acceso restrinxido' ); jimport ( 'joomla.application.component.view' ); class FortuneajaxViewFortuneajax extends JView { function display ( $tpl = null ) { $model =& $this -> getModel ( 'Fortuneajax' ); $mensaxe = $model -> getFortune (); $this -> assignRef ( 'mensaxe' , $mensaxe ); parent :: display ( $tpl ); } } com_fortuneajax/views/fortuneajax/view.html.php

Component Template <?php // Non permitir o acceso directo defined ( '_JEXEC' ) or die( 'Acceso restrinxido' ); echo $mensaxe ; ?> com_fortuneajax/views/fortuneajax/tmpl/view.html.php

Component Modelo <?php defined ( '_JEXEC' ) or die( 'Acceso restrinxido' ); jimport ( 'joomla.application.component.model' ); class FortuneajaxModelFortuneajax extends JModel { function getFortune () { $linhas = array(); $mensaxe = exec ( '/usr/games/fortune' , $linhas ); $str = htmlentities ( implode ( ' ' , $linhas )); return( $str ); } }

Component <? 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" > <name> Fortune Ajax </name> <creationDate> Xuño 2008 </creationDate> <author> vifito </author> <authorEmail> [email_address] </authorEmail> <authorUrl> http://vifito.es </authorUrl> <copyright> Copyleft </copyright> <license> GNU/GPL </license> <version> 0.1 </version> <description> Componente Fortune Ajax </description> <files> <filename> fortuneajax.xml </filename> <filename> fortuneajax.php </filename> <filename> controller.php </filename> <filename> models/fortuneajax.php </filename> <filename> views/fortuneajax/view.html.php </filename> <filename> views/fortuneajax/view.raw.php </filename> <filename> views/fortuneajax/tmpl/default.php </filename> </files> <administration /> <install /> <unistall /> </install>

Component Resultado:

Component
Grazas a vista “raw” é posible facer peticións Ajax. Agora un módulo podería facer peticións HTTP vía Ajax. (ver módulo mod_fortuneajax)
Joomla! integra a librería javascript MooTools. OLLO: a última versión de MooTools é a 1.12 e en Joomla! inclúese a 1.11

mod_fortuneajax fai peticións Ajax ao componente com_fortuneajax, pedindo a vista “raw” para que devolva só o contido e non todo o layout do sistema.

Quedaría pendente toda a parte da administración:
http://dev.joomla.org/component/option,com_jd-wiki/Itemid,/ id,components:hello_world_mvc4/
Component

API Base de datos (core)
Para aproveitar as funcionalidades do framework de Joomla! usar convencións :
Nome das táboas, recomendable en minúsculas e coa seguinte sintaxe:
#__ <nome_componente> _ <nome_táboa> p.e. jos_fortune_frases. ( #__ prefixo definido na instalación, por defecto jos_)
Nome da clave primaria “ id ”, (integer auto_increment not null)
Nomes dos campos en minúscula, palabras separadas por “_”. p.e. email_secundario

Nomes de campos comúns con funcionalidades extra:
published : 0 -> no publicado 1 -> publicado
hits : enteiro que garda os accesos dende o frontend dos visitantes (estatísticas)
Bloqueo da edición:
checking_out , garda o id de usuario (0 por defecto)
checking_out_time , o datetime
ordering : garda a orde na que se amosan
parameters : garda parámetros en formato INI (variable=valor). Clase de utilidade JParameter

Código básico para acceso a base de datos:
// Recuperar instancia da base de datos $db =& JFactory :: getDBO (); // Consulta $query = 'SELECT * FROM #__fortune_frases' ; // Recoller o resultado da consulta $result = $db -> setQuery ( $query );
Estase traballando para emular as funcións do API de ADOdb. OLLO! non hai intención de integrar a librería ADOdb

Métodos API: $db =& JFactory::getDBO();
$db->loadResult()
$db->loadResultArray([$key])
$db->loadAssoc()
$db->loadAssocList([$key])
$db->loadObject()
$db->loadObjectList([$key])
$db->loadRow()
$db->loadRowList([$key])
...

API Base de datos (JTable)
JTable proporciona un conxunto de funcionalides (CRUD) abstraendo cuestións internas coma SQL, ...

Clase “TableFortuneFrases” herda de JTable funcionalidades ORM. As clases JTable gárdanse no cartafol /tables/ do compoñente: JPATH_COMPONENT_ADMINISTRATOR.DS.'tables'.DS.'fortunefrases.php'
class TableFortuneFrases extends JTable { var $id = null ; var $content = null ; var $published = null ; var $hits = 0 ; var $checking_out = 0 ; var $checking_out_time = null ; var $ordering = null ; var $params = null ; function __construct ( & $db ){ parent :: __construct ( '#__fortune_frases' , 'id' , $db ); } } API Base de datos (JTable)

CRUD ( C reate, R ead, U pdate e D elete)
// Obter unha instancia de JTable JTable :: addIncludePath ( JPATH_COMPONENT_ADMINISTRATOR . DS . 'tables' ); $table = JTable :: getInstance ( 'FortuneFrases' , 'Table' ); // Create $table -> reset (); // Vaciar buffer evita problemas $table -> set ( 'content' , "Lorem ipsum dolor sit amet" ); $table -> set ( 'ordering' , $table -> getNextOrder ()); if ( $table -> check ()) { // Método check para comprobar o buffer if (! $table -> store ()) { die( $table -> getError () ); } } else { die( $table -> getError () ); } API Base de datos (JTable)

// Read if (! $table -> load ( $id )) { die( $table -> getError () ); } // Update $table -> reset (); // Vaciar buffer evita problemas $table -> set ( 'id' , $id ); $table -> set ( 'content' , JRequest :: getString ( 'content' )); if ( $table -> check ()) { // ... } // Delete if (! $table -> delete ( $id )) { die( $table -> getError () ); } API Base de datos (JTable)

Métodos de JTable para aproveitar as funcionalidades dos campos comúns:
// Published, publicar (=1) ou despublicar (=0) contidos $table -> publish ( $array_ids , 1 , $user -> get ( 'id' )); // Aumentar un máis as visitas do contido $table -> hit (); // Comprobar si esta checked out $table -> isCheckedOut ( $user -> get ( 'id' ) ); // Bloquea o rexistro para o usuario $table -> checkout ( $user -> get ( 'id' ) ); // Desbloquea o rexistro $table -> checkin (); // Reordear os contidos $table -> reorder (); API Base de datos (JTable)

Manexo do campo params, útil para personalizar propiedades dun contido. Os parámetros defínense no ficheiro XML que contén os detalles da extensión:
// Manexo dos parámetros (clase JParameter) $params = new JParameter ( $table -> params ); $parametro = $params -> get ( 'nome_parametro' ); $params -> set ( 'nome_parametro' , $valor ); $table -> params = $params -> toString (); API Base de datos (JTable)

Integración de Joomla! con outros frameworks

Joomla! pódese integrar con outros proxectos coma phpBB por medio de compoñentes, plugins, módulos, ...
Por medio dunha interface XML-RPC garántese a interoperabilidade .
Tamén se pode integrar dentro de Joomla! proxectos desenvolvidos con frameworks web: p.e.- CakePHP e Symfony
Joomla! + CakePHP = Jake http://cakeforge.org/frs/?group_id=76&release_id=314
Joomla! + Symfony = sfJoomla15Bridge, inspirado en Jake http://trac.symfony-project.com/wiki/sfJoomla15BridgePlugin
Joomla! e outros frameworks

Instalamos unha aplicación CakePHP existente (Cheesecake Photoblog) en Joomla!. Pasos:
1) Instalar o componente Jake:
http://cakeforge.org/frs/download.php/354/jake_1.0.3.38b-joomla_1.5.zip
2) Instalar Cheesecake:
http://cakeforge.org/frs/download.php/510/cheesecake_cake.tar.gz
3) Configuramos a aplicación en Joomla! com_jake/jake.ini
[settings]
default = "cheesecake"
[cheesecake]
path = "/var/www/cheesecake/app/webroot"
url = "/cheesecake"
4) Obter URL de Jake a aplicación

Instalación de Jake / Jake no menú de compoñentes

Resultado da integración de Cheesecake en Joomla!

SITEman, aplicación de escritorio implementada en Java que permite aos usuarios administrar un sitio Joomla! 1.5 dende un ambiente de escritorio.

Referencias e conclusións

Referencia e conclusións
Gracias a David Noguera Cifuentes Parte desta presentación inspirada no seu material http://www.nosolocodigo.com/tag/joomla
Páxina oficial de Joomla! http://joomla.org
Directorio de extensións de Joomla! http://extensions.joomla.org
Tradución Joomla! ao galego https://forxa.mancomun.org/projects/joomlagalego/

Dúbidas?

http://vifito.eu	14
http://www.vifito.eu	14
http://www.vifito.es	5
http://vifito.es	5
http://www.slideshare.net	5
http://webcache.googleusercontent.com	1

Dev con Joomla componentes modulos plugins

by ousli07 on Jun 30, 2008

Accessibility

Categories

Tags

Upload Details

Usage Rights

6 Embeds 44

Statistics

Dev con Joomla componentes modulos plugins — Presentation Transcript