Dev con Joomla componentes modulos plugins
Upcoming SlideShare
Loading in...5
×
 

Dev con Joomla componentes modulos plugins

on

  • 5,270 views

Como crear modulos e plugins para joomla

Como crear modulos e plugins para joomla

Statistics

Views

Total Views
5,270
Views on SlideShare
5,219
Embed Views
51

Actions

Likes
1
Downloads
69
Comments
2

8 Embeds 51

http://vifito.eu 19
http://www.vifito.eu 14
http://www.vifito.es 5
http://vifito.es 5
http://www.slideshare.net 5
http://webcache.googleusercontent.com 1
http://localhost 1
http://web.archive.org 1
More...

Accessibility

Categories

Upload Details

Uploaded via as OpenOffice

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Dev con Joomla componentes modulos plugins Dev con Joomla componentes modulos plugins Presentation Transcript

  • 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= &quot; http://www.w3.org/1999/xhtml &quot; xml: lang = &quot;en&quot; lang = &quot;en&quot; >
    • < head >
    • < jdoc :include type = &quot;head&quot; />
    • </ head >
    • < body >
    • < div id = &quot;container&quot; >
    • < jdoc :include type = &quot;message&quot; />
    • < div id = &quot;outer&quot; >
    • < div id = &quot;inner&quot; >
    • < div id = &quot;left&quot; >< h2 > Esquerda </ h2 >
    • < jdoc :include type = &quot;modules&quot; name = &quot;left&quot; />
    • </ div >
    • < div id = &quot;content&quot; >
    • < h2 > Contido </ h2 >
    • < jdoc :include type = &quot;component&quot; />
    • </ div > <!-- end content -->
    • ...
    Templates
  • <? xml version = &quot;1.0&quot; encoding = &quot;utf-8&quot; ?> <install version = &quot;1.5&quot; type = &quot;template&quot; > <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 = &quot;1.0&quot; ?> <install type = &quot;module&quot; version = &quot;1.5.0&quot; > <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 = &quot;mod_fortune&quot; > 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 = &quot;1.0&quot;   encoding = &quot;utf-8&quot; ?> <install  version = &quot;1.5&quot;   type = &quot;plugin&quot;   group = &quot;content&quot; >          <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 = &quot;fortune&quot; > 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 = &quot;1.0&quot; encoding = &quot;UTF-8&quot; ?> <! DOCTYPE install SYSTEM &quot; http://dev.joomla.org/xml/1.5/component-install.dtd &quot; > <install type = &quot;component&quot; version = &quot;1.5&quot; > <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
  • 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' ,  &quot;Lorem ipsum dolor sit amet&quot; ); $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 = &quot;cheesecake&quot;
    • [cheesecake]
    • path = &quot;/var/www/cheesecake/app/webroot&quot;
    • url = &quot;/cheesecake&quot;
    • 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.
  • 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?