Joomla! 1.5CMS a mani tese verso gli sviluppatori

A cura di Nadalin Alessandro

Joomla 1.5 per gli sviluppatori

Joomla! a grandi linee

obiettivi del talk

architettura MVC

template parameters

layout overrides

analisi pratica del framework

Overview dell'intervento

La versione 1.0 vedrà terminare il supporto a Luglio.

Spariranno dalla JED le estensioni non native per la versione 1.5 così come le board di supporto del

forum ufficiale.

I plugin per la migrazione ( ETL ) stanno aumentando in questi primi mesi del 2009

( http://extensions.joomla.org/extensions/extension-specific/migrator-extensions ).

Il passato di Joomla!

La versione 1.5 è la branch da utilizzare: stabile, sicura, ottimizzata.

Essa è arrivata alla release di mantenimento 1.5.10, attualmente l'ultima versione stabile del CMS e

l'unica consigliata per siti di produzione.

Attualmente la branch 1.5 non prevede implementazioni, ma solo security updates e bug

fixing.

Nuove release vengono rese pubbliche ogni 8 settimane circa.

Il presente di Joomla!

La prossima versione minore del CMS, la 1.6, ha giunto lo stadio di Alpha ( pubblica via SVN ).

Principali e attese novità saranno l'implementazione di un ACL/ACS nativo potente, MOOtools 1.2, una

classe JForm e una tassonomia meglio organizzata.

Non si hanno ancora notizie certe sulla data probabile del rilascio, quel che è certo è che dovremo

aspettare alcuni/parecchi mesi prima di vedere Joomla! 1.6 stabile.

Il futuro di Joomla!

Joomla! 1.5 ha dato un forte segnale riguardo le policies di OSM, ovvero la volontà di sacrificare parte

dell'immediatezza e della semplicità del CMS in favore di un core più robuste, che abbia potenzialità

maggiori.

Comprendere la direzione del CMS

Joomla! è notoriamente visto come un giocattolo adatto per le persone che non hanno conoscenze sui linguaggi di programmazione web-based: la versione 1.5 unisce le opportunità verso essi con quelle offerte

ai developers professionisti.

Il nuovo framework ha fatto si che moltissime aziende si siano specializzate nella realizzazione o di

templates o di estensioni specifiche.

L'introduzione del pattern MVC è stata la vera rivoluzione per il CMS.

Rivalutare il CMS

La versione 1.0 non era altro che un fork/evoluzione di mambo open source, e si basava quindi sul

framework originario di quel cms.

L'introduzione del pattern nel nuovo framework ha significato quindi enormi vantaggi in termini di

risparmio temporale nello sviluppo, soprattutto, delle nuove estensioni.

Utilizzare un'estensione sviluppate da terze parti significava quindi esporre il proprio sito a mini-

framework a loro stanti ( Es Virtuemart ).

Joomla! prima dell'MVC

L'introduzione del pattern ha significato un aumento significativo della portabilità del codice per le future versioni minori ( Es. 1.6 ), cosa non garantita prima

( com'è avvenuto nella migrazione dalla 1.0 ).

L'MVC introduce maggiore stabilità a livello di sicurezza, nonché maggiore facilità in termini di

debugging e di customizzazione delle estensioni.

I layout overrides si basano proprio sull'MVC.

Joomla! con l'MVC

I template di Joomla! si basano su XHTML generato dal file PHP ( index.php ) degli stessi.

Esiste la possibilità di inserire, per il cliente finale, dei parametri che lui può gestire per customizzare in un attimo il layout del sito: un esempio lampante sono i

CSS stagionali.

Tali parametri sono definiti nel file XML relativo al template e salvati nel file params.ini dello stesso.

Template parameters

I parametri dei template vengono definiti nel file templateDetails.xml come segue:

<param name="templatecolor" type="list" default="autunno" label="templatecolor" description="choose the Color of the Template">

<option value="autunno">Autunno</option><option value="inverno">Inverno</option><option value="primavera">Primavera</option><option value="estate">Estate</option>

</param>

e producono un output similare a:

Template parameters (2)

I parametri vengono poi invocati tramite la sintassi:

$this->params->get('param_name');

ovvero nel nostro caso:

$this->params->get('templatecolor');

per essere riutilizzati in situazioni quali:

<link rel="stylesheet" href="templates/template/css/<?php echo $this->params->get('templatecolor'); ?>

.css" type="text/css" />

Template parameters (3)

Una volta implementato il parametro relativo alla scelta del CSS, sarà semplicissimo utilizzare CSS diversi, scelti

direttamente dall'utilizzatore finale del sito.

Template parameters (4)

Allo stesso modo si possono implementare simpatiche funzioni come l'utilizzo, ad ogni refresh, di

un header variabile.

Questo viene fatto modificando direttamente il file in:

/templates/template_attivo/index.php

Utiliziammo una funzione quale getHeader() per recuperare un'immagine da una cartella del template

( /headers/ ).

Header variabile

Utilizzando il metodo countModules() possiamo rendere un container qualsiasi collassabile in

base alla presenza di determinati moduli.

Una porzione di codice che rende una zona collassabile è tipicamente delineata da questa

sintassi:

if ( $this->countModules('top' ) ){

?><jdoc:include type=”modules” name=”top” />

<?php}

Colonne collassabili

L'override è una caratteristica che è stata aggiunta a partire da Joomla! 1.5.0, grazie all'introduzione del

framework MVC.

Esso agisce unicamente sulle view dei componenti scritti seguendo il framework.

L'override è alla base di JoomlaFAP.

Layout override

Un piccolo esempio di override:

Layout override (2)

Essi appartengono al singolo template e sono costituiti da una cartella che recita il nome

dell'estensione, contenente una cartella con il nome della view contenente i file di override.

Per esempio:

/templates/miotemplate/html/com_content/article/default.php

che sostituirà il file

/components/com_content/views/article/tmpl/default.php

Layout override (3)

L'override non è applicabile a qualsiasi estensione per Joomla! 1.5: solo quelle che fanno uso in todo del framework MVC del CMS stesso possono utilizzare

questa feature.

Esso è importante poiché ci consente di considerare come due entità separate il core del CMS ed la

nostra personalizzazione.

Layout override (4)

Analizziamo alcuni degli aspetti del framework di Joomla!.

Non analizzeremo il modello MVC ora ma semplicemente alcune classi e metodi che ci

facilitano in fase di sviluppo.

Framework

E' una classe che provvede a dare i riferimenti per ottenere le informazioni maggiormente

interessanti a livello di sviluppo.

Fa riferimento alle classi Singleton più importanti del framework.

Framework – JFactory

Si basano sulla libreria PHPmailer.

$mail =& Jfactory::getMailer();$mail->addRecipient( 'spam@odino.org' );$mail->setSubject( 'Test' );$mail->setBody( 'Una nuova mail di SPAM!' );

if ($mail->Send()) { echo "Mail sent successfully.";} else { echo "An error occurred. Mail was not sent.";}

Framework – mail

Per accedere al dettaglio dell'utente occorre ricorrere alla fattorizzazione:

$user =& JFactory::getUser();

ed è possibile ricorrere anche al dettaglio di utenti differenti, ovviamente, da colui che sta visionando la

pagina:

$user =& JFactory::getUser('62');$user =& JFactory::getUser('odino');

Framework – l'utente

Le informazioni sull'utente, che comprendono:idnameusernamepasswordusertypegid e molte altre

corrispondono alle stesse variabili dell'oggetto.

Per ottenere, quindi, lo username dell'utente:

$user->username;

Framework – l'utente (2)

Ogni web application ha, di norma, delle variabili di configurazione immagazzinate in una classe.

L'accesso ad esse viene garantito, in Joomla!, sempre dalla fattorizzazione:

$config_vars = JFactory::getApplication();

e possono essere richiamate tramite:

$config_vars->getCfg('variabile');

Framework – variabili di configurazione

I metodi più semplici per gestire la sessione:

$session =& Jfactory::getSession();

$session->set('mia_variabile', 'valore');

$session->get('mia_variabile', 'predefined');

Framework – sessione

Quando sviluppiamo includiamo, ovviamente, anche del codice che deve essere interpretato dall'utente.

Joomla! fornisce un metodo ( _) della classe JText per tradurre automaticamente in accordo alla lingua

definita dal sito.

Esso si basa sul parsing dei file INI relativi all'estensione che contiene le parole da tradurre.

echo JText::_('HI_USER');

Framework – gestore delle traduzioni

E' possibile gestire il buffer per tutti gli headers attraverso la classe astratta JDocument e la

fattorizzazione:

$head =& JFactory::getDocument();

che crea un istanza di JDocumentHTML ( che eredita da JDocument ).

Non è possibile, ovviamente, creare istanze simili per documenti che non siano pagine web.

Framework – il buffer per gli headers

Per gestire elementi generici possiamo ricorrere ai metodi getHeadData() e addCustomTag().

print_r ($page->getHeadData());

ritornerà un array con tutti gli elementi che costituiscono la sezione <head> della nostra pagina.

$page->addCustomTag(“<!-- commento -->”);

ci permette invece di inserire qualsiasi codice tra gli header

Framework – il buffer per gli headers (2)

I metatag invece possono essere gestiti tramite getMetaData() e setMetaData().

Agiscono come i metodi precedentemente menzionati.

$page->setMetaData(“author”, “odino”);

creerà quindi un metatag quale:

<meta name=”author” value=”odino” />

I metatag godono di un buffer a loro stante.

Framework – il buffer per gli headers (3)

Per gestire con facilità l'implementazione di JavaScript possiamo utilizzare due metodi.

addScript() aggiunge un JavaScript sito su un file esterno:

$page->addScript(“http://www.example.com/greateJS.js”);

mentre addScriptDeclaration() direttamente una porzione di codice:

$page->addScriptDeclaration(“alert('hello world!')”);

Framework – il buffer per gli headers (4)

Per quanto riguarda i CSS il discorso è similare a quanto detto per JavaScript.

Utilizziamo i due metodi:

$page->addStyleSheet(“http://www.example.com/greatCSS.css”);

$page->addStyleDeclaration(“body { border:1px solid black }”);

Framework – il buffer per gli headers (5)

Esistono metodi per gestire anche favicon e link del documento.

Metatag, JavaScript, CSS godono di 3 buffer separati, per mantenere in ordine gli headers.

Framework – il buffer per gli headers (6)

Si basa su JDocument, classe astratta che estende JObject.

JDocument identifica un documento.

La classe JDocumentHTML è quella utilizzata effettivamente nei nostri script.

Un oggetto di tipo JDocumentHTML include i metodi per settare la favicon del documento e gli headers

descritti precedentemente.

Framework – il documento HTML

Possiamo accedere al contenuto del documento attraverso getBuffer().

Per applicare l'override del buffer, invece, possiamo usare setBuffer().

Questi metodi non sono altro che l'attuale chiamata di:

<jdoc:include type=”modules” name=”top” />

Framework – il documento HTML (2)

L'ACL nativo di Joomla! 1.5 non permette di creare nuovi gruppi di utenti né di assegnare a singoli utenti determinati permessi, senza ricorrere alla riscrittura

del codice.

Per ottenere un riferimento globale riguordante l'ACL occorre effettuare due fattorizzazioni, una relativa

all'utente ed una all'ACL:

$user =& Jfactory::getUser();

$acl =& JFactory::getACL();

Framework – ACS/ACL

Il metodo authorize() di oggetti JUser ci consente di effettuare un check sui permessi nell'effettuare

un'operazione da parte dell'utente.

Restituisce true se, ovviamente, l'utente ha quel determinato permesso.

$user = Jfactory::getUser();

if ( $user->authorize('com_content', 'edit') ){

…}

Framework – ACS/ACL (2)

Sempre riferito agli stessi oggetti, la variabile guest è utilizzato, principalmente, per escludere la

visualizzazione e/o l'accesso agli utenti non registrati.

if ( !$user->guest ){

…}

Framework – ACS/ACL (3)

Per aggiungere regole sull'ACL nativo possiamo applicare i metodi della classe JAuthorization, che

invochiamo tramite fattorizzazione.

$acl =& JFactory::getACL();

$acl->addACL('com_content','edit','users','administrator');

Mentre per impedire l'accesso a certe tipologie di utenti registrati possiamo semplicemente ricorrere alle variabili di Juser:

if ( $user->usertype === 'manager' ){

…}

Framework – ACS/ACL (4)

Joomla! 1.5 supporta solo MySQL.

Viene supportata anche l'estensione MySQLi.

Per lanciare una query di scrittura o lettura sul database ricorriamo a:

$db =& Jfactory::getDBO();

$query = 'codice SQL valido';

$db->setQuery($query);

Framework – database

I metodi maggiormente usati:

$result = $db->loadResult();

$result = $db->loadRow();

$result = $db->loadAssoc();

$result = $db->loadObject();

$result = $db->loadResultArray();

$result = $db->loadRowList();

$result = $db->loadAssocList();

Framework – database (2)

Informazioni di base sulle URI

$uri =& Jfactory::getURI();

JURI::base → /

JURI::root → http://www.mysite.tld/

JURI::current → http://www.mysite.tld/index.php?option=com_photo

$URI = JURI::current(); $uri =& JURI::getInstance($URI); $action = $uri->getVar('option', 'com_frontpage'); $add_uri = $uri->setVar('task', 'view');

Framework – URI

Joomla! può invocare diversi tipi di parser XML, tramite:

$xml =& Jfactory::getXMLParser();

Tra le opzioni

dom → domit & domit lite

simple → JSimpleXML

rss/atom → SimplePie

Framework – parser XML

JSimpleXML è un parser che estende SimpleXML

$xml =& JFactory::getXMLParser( 'simple' ); $xml->loadFile( 'templates/template/templateDetails.xml' );$positions =& $xml->document->getElementByPath( 'positions' );foreach ($positions->children() as $position) { echo $position->data() . "\n";}

Framework – parser XML (2)

Le estensioni si dividono in componenti, moduli e plugin.

Componenti → sono il corpo del sito, associabili ad articoli, fotogallery e a tutto ciò su cui è primariamente

focalizzata la pagina.

Moduli → sono frammenti di codice visibili e pubblicati sulle pagine, associabili a widget e piccole apps che

fungono in simbiosi coi componenti.

Plugin → sono frammenti di codice generalmente non visibili e utilizzati in determinati contesti/azioni.

Framework – un nostro modulo

Framework – un nostro modulo (2)

Scopo del modulo:

settare gli headers

riconoscere l'utente

agire in base ai suoi permessi

redirezionarlo in base ai risultati di una query

Framework – un nostro modulo (3)

Creiamo la cartella mod_phpday

Creiamo, suo interno, la cartella tmp e i file:

mod_phpday.xml

mod_phpday.php

helper.php

Framework – un nostro modulo (4)

mod_phpday.xml

<?xml version="1.0" encoding="utf-8"?><install type="module" version="1.5"> <name>phpday</name> <author>Odino</author> <version>1.0</version> <description>Modulo for dummies</description> <languages>

<language tag="it-IT">it-IT.mod_phpday.ini</language> </languages> <files> <filename module="mod_phpday">mod_phpday.php</filename> <filename>helper.php</filename> <filename>tmpl/default.php</filename>

<filename>tmpl/default.css</filename> </files> <params> <param name="greeting" type="radio" default="0" >

<option value="0">No</option><option value="1">Yes</option>

</param> </params></install>

Framework – un nostro modulo (5)

mod_phpday.php

<?php

defined( '_JEXEC' ) or die( 'Restricted access' );

require_once( dirname(__FILE__).DS.'helper.php' );

$phpday = modphpdayHelper::getphpday( $params );

require( JModuleHelper::getLayoutPath( 'mod_phpday' ) );

Framework – un nostro modulo (6)

helper.php

<?php

class modphpdayHelper{ function getphpday( $params ) { return 'phpday'; }}

?>

Framework – un nostro modulo (7)

it-IT.mod_phpday.ini

HI = CiaoMUST_LOGIN = You must be logged in in order to have full access to this moduleACCESS_PRESENCE = Eri al PHPday?

SEE_TALK = Guarda i talk che hai tenuto

Framework – un nostro modulo (8)

tmpl/default.php<?phpdefined( '_JEXEC' ) or die( 'Restricted access' ); $header =& JFactory::getDocument();$header->addStyleSheet(JURI::root()."mod_phpday".DS."tmpl".DS."default.css");$user =& JFactory::getUser();if ( $user->guest ){

echo JText::_('MUST_LOGIN');}else{

if ( $params->get( 'greeting' ) == 1 ){

echo "<h1>".JText::_('HI').$user->name."</h1>";}echo "<p>".JText::_('ACCESS_PRESENCE')."</p>";$db =& JFactory::getDBO();$query = "SELECT presence, talk FROM #__phpday WHERE id = '".$user->id."'";$db->setQuery($query);$result = $db->loadAssoc();if ( $result[presence] == 1 ){

echo "<p>".JText::_('YES')."</p>";if ( $result[talk] == 1 ){

echo "<p><a href='";echo JURI::root()."index.php?option=com_phpday_vids&source=talks&relator=".$user->id."'>";echo JText::_('SEE_TALK');echo "</a></p>";

}}elseif ( $result[presence] == 1 ){

echo "<p>".JText::_('NO')."</p>";}

}

Framework – un nostro modulo (9)

Ecco il nostro modulo come appare, dopo averlo installato, in backend:

Framework – un nostro modulo (10)

Ecco come appare appena ci colleghiamo al sito:

Framework – un nostro modulo (11)

Ecco come compare non appena ci autentichiamo:

Framework – un nostro modulo (12)

Domande?

Termine della presentazione