Joomla! 1.5: CMS a mani tese verso gli sviluppatori

57
Joomla! 1.5 CMS a mani tese verso gli sviluppatori A cura di Nadalin Alessandro Joomla 1.5 per gli sviluppatori

description

Un breve talk per introdurre ad alcune funzioni native di Joomla! ( e del suo framework ) che ci permettono di riconsiderare il CMS a liverllo di sviluppo.

Transcript of Joomla! 1.5: CMS a mani tese verso gli sviluppatori

Page 1: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

Joomla! 1.5CMS a mani tese verso gli sviluppatori

A cura di Nadalin Alessandro

Joomla 1.5 per gli sviluppatori

Page 2: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

Joomla! a grandi linee

obiettivi del talk

architettura MVC

template parameters

layout overrides

analisi pratica del framework

Overview dell'intervento

Page 3: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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!

Page 4: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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!

Page 5: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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!

Page 6: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 7: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 8: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 9: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 10: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 11: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 12: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 13: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 14: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 15: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 16: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 17: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

Un piccolo esempio di override:

Layout override (2)

Page 18: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 19: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 20: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 21: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 22: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

Si basano sulla libreria PHPmailer.

$mail =& Jfactory::getMailer();$mail->addRecipient( '[email protected]' );$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

Page 23: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 24: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 25: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 26: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

I metodi più semplici per gestire la sessione:

$session =& Jfactory::getSession();

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

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

Framework – sessione

Page 27: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 28: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 29: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 30: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 31: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 32: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 33: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 34: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 35: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 36: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 37: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 38: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 39: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 40: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 41: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 42: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 43: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 44: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 45: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Page 46: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

Framework – un nostro modulo (2)

Page 47: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 48: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 49: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 50: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 51: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

helper.php

<?php

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

?>

Framework – un nostro modulo (7)

Page 52: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 53: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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)

Page 54: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

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

Framework – un nostro modulo (10)

Page 55: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

Ecco come appare appena ci colleghiamo al sito:

Framework – un nostro modulo (11)

Page 56: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

Ecco come compare non appena ci autentichiamo:

Framework – un nostro modulo (12)

Page 57: Joomla! 1.5: CMS a mani tese verso gli sviluppatori

Domande?

Termine della presentazione