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 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 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 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

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, ... )

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 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

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 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

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

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 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

API Base de datos (core) 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

API Base de datos (core) 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

API Base de datos (core) 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

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

Joomla! e outros frameworks Instalación de Jake / Jake no menú de compoñentes

Joomla! e outros frameworks Resultado da integración de Cheesecake en Joomla!

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

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/

Dev con Joomla componentes modulos plugins

More Related Content

Viewers also liked (18)

More from ousli07 (20)

Dev con Joomla componentes modulos plugins