Joomla 1.7

Joomla 1.7, rilasciato il 19/07/2011 a sei mesi di distanza da Joomla 1.6, propone una interessante novità per gli sviluppatori: la separazione della Joomla Platform dal resto del CMS. La Joomla Platform non è altro che un PHP Application Framework che potrà essere utilizzato indipendentemente dal Content Manager e dal suo core: ciò significa che anche applicazioni di terze parti potranno basarsi su Joomla.
Nella versione Joomla 1.7 è stata inoltre aggiunta la possibilità di tradurre in lingue diverse le varie voci di menù senza dover ricorrere a estensioni esterne.
Joomla 1.7, al pari di Joomla 1.6, è una versione di passaggio verso Joomla 1.8 che diventerà la prossima versione a lungo termine ed andrà a sostituire definitivamente la vecchia e collaudata versione 1.5.

Scrivere plugin per Joomla (II parte)

Nell'articolo Scrivere plugin per joomla (I parte) abbiamo visto i vari tipi di plugin presenti in Joomla e i relativi eventi che possono essere utilizzati in ogni classe di plugin. Oggi andremo a scrivere un plugin di prova che chiameremo MyString.

File necessari in un plugin

Il plugin in questione appartiene alla tipologia "content" e ci permetterà di inserire una stringa a piacere ogni volta che inseriremo il segnaposto {mystring} in un contenuto di Joomla.
Il numero di files minimi necessari per la creazione di un plugin sono due:

1. mystring.php
2. mystring.xml

Nel nostro caso ci limiteremo a questi due soli file. Ricordiamo che in caso di bisogno, possiamo creare una cartella (nel nostro esempio "mystring") in cui collocare altri file (php, immagini o javascript), specificando la cartella aggiuntiva nel file mystring.xml.

Il cuore del Plugin mystring.php

Nel file mystring.php inseriremo il codice che verrà eseguito all'evento "onPrepareContent", ossia prima che il contenuto di un articolo (o di un modulo) venga stampato. Questo ci permetterà di trovare eventuali occorrenze della stringa {mystring} e di sostiturila con del codice html.

<?php
// impediamo l'accesso diretto allo script
defined( '_JEXEC' ) or die( 'Restricted access' );
jimport( 'joomla.plugin.plugin' );

class plgContentMystring extends JPlugin
{
    /**
    * Costruttore
    * Chiamiamo il costruttore della classe genitrice per inizializzare il plugin
    */
    function plgContentMystring( &$subject, $params )
    {
        parent::__construct( $subject, $params );
    }

    /**
    * MyString prepare content method
    *
    * Questo metodo viene chiamato da Joomla prima che il contenuto viene visualizzato
    *
    * @param oggetto contenente l'articolo The article object. Note $article->text is also available
    * @param oggetto contenente i parametri del plugin
    * @limitstart il numero di pagina, a noi questo non interessa qui
    */
    function onPrepareContent( &$article, &$params, $limitstart )
    {
        global $mainframe;
        // Se il plugin è attivato e se viene trovata la stringa {mystring} all'interno del contenuto
        if ($this->params->get( 'enabled', 1 ) && strripos($article->text, "{mystring}") !== false) 
        {
            // Recupero il testo da inserire
            $about_text = $this->params->get('about_text', NULL);
            // Controllo HTML
            if(intval($this->params->get('htmlentities', NULL)) == 1) $about_text = htmlentities($about_text, ENT_QUOTES);
            // Recupero il tag selezionato
            $tag = $this->params->get('tag', 'blockquote');
            // Recupero la classe css
            $class = $this->params->get('css_class', NULL);
            // Se la classe è vuota non ho bisogno di inserire l'attributo class
            $output = ($class != '') ? ' class="'. $class .'"' : "" ;
            // Inserisco il testo dentro il tag con la relativa classe
            $about_text = '<' . $tag . $output .'>' . $about_text . '';
            // Rimuovo eventuale tag inseriti automaticamente dall'editor
            $article->text = str_replace("{mystring}", "{mystring}", $article->text);
            // Effettuo la sostituzione finale
            $article->text = str_replace("{mystring}", $about_text, $article->text);
            return true;
        }
        else return false;
    }
}
?>

Anche se i commenti nel codice sono abbastanza espliciti, è necessario fare delle precisazioni:
per convenzione il nome della classe deve essere: plg + Tipologia plugin (prima lettera maiuscola) + Nome plugin (prima lettera maiuscola), quindi nel nostro caso plgContentMystring.
La prima funzione della classe è il costruttore che per retrocompatibilità con php4 deve avere lo stesso nome della classe. Se avessimo voluto scrivere un plugin non retrocompatibile e quindi disegnato per php 5 (o superiore) avremmo potuto semplicemente utilizzare "__constructor"
In questo caso il costruttore è stato inserito solo come esempio teorico: noterete infatti che non esegue nessuna operazione e può essere cancellato.
Se avessimo voluto effettuare alcune operazioni anche nel caso la stringa {mystring} non fosse stata trovata avremmo potuto inserire le istruzioni nella funzione costruttore ed in quel caso il codice sarebbe stato eseguito ad ogni caricamento della pagina.
Avremmo potuto utilizzare anche un tipo di programmazione procedurale evitando di scrivere una classe, ma dato che gli sviluppatori del framework di Joomla raccomandano di seguire questo paradigma è bene seguire il loro consiglio. Inoltre giocare con questo tipo di codice ci abitua al design strutturato a oggetti di tutte le moderne applicazioni web (e non solo web).

Il file mystring.xml

Il file mystring.xml è necessario per l'installazione del plugin e per la gestione dei parametri.

<install group="content" type="plugin" version="1.5">
<name>My String</name>
<author>Autore</author>
<creationdate>....</creationdate>
<license>http://www.gnu.org/copyleft/gpl.html GNU/GPL</license>
<authoremail>...</authoremail>
<authorurl>....</authorurl>
<version>1</version>
<description>Visualizza dele informazioni ad ogni occorrenza della stringa {mystring}</description>
<files>
<filename plugin="mystring">mystring.php</filename>
</files>
</install>

Scrivere plugin per Joomla (I parte)

E' necessario sviluppare un plugin per Joomla ogni volta che si vuole cambiare il comportamento di Joomla al verificarsi di un determinato evento: i plugin di Joomla infatti, sono parti di codice che vengono eseguite in un dato momento del caricamento della pagina o ad una determinata azione dell'utente.

La possibilità di eseguire del codice a seconda che certe condizioni si verifichino o meno, ci da la possibilità di estendere le funzionalità di Joomla con semplicità ed eleganza rendendo il comportamento del nostro sito personalizzabile.

Tipologie di plugin in Joomla

Joomla possiede di default un certo numero di tipologie di plugin definite core.
Queste tipologie sono presenti nella cartella /plugins/ di ogni installazione Joomla e sono:

1. authentication: per estendere l'autenticazione
2. content: per effettuare controlli o inserire funzionalità nei contenuti
3. editors: per realizzare editor
4. editors-xtd: per le estensioni degli editor
5. search: per estendere le funzionalità di ricerca
6. system: per far eseguire codice in vari momenti del caricamento del framework
7. user: per estendere le funzionalità degli utenti
8. xmlrpc: per estendere l'interattività con altri servizi web (ad es: Desktop remoti)

Ogni tipologia di plugin serve quindi a svolgere delle funzionalità diverse: per permettere ciò Joomla mette a disposizione per ogni tipo di plugin una serie di eventi. Gli eventi non sono altro che diversi momenti (appunto eventi) che si susseguono nel caricamento del framework di Joomla. È possibile quindi eseguire del codice in ognuno degli eventi che Joomla mette a disposizione per una determinata tipologia di plugin.

Prima di vedere i tipi di eventi a disposizione, osserviamo che qualora se ne presentasse la necessità è possibile creare una nuova tipologia di plugin. Solitamente questo accade quando si sviluppa un componente che ha degli eventi personalizzati e che ha bisogno di effettuare certe operazioni all'esecuzione di questi eventi.

Eventi per ogni tipo di plugin

Authentication:

1. onAuthenticate

Content:

1. onPrepareContent
2. onAfterDisplayTitle
3. onBeforeDisplayContent
4. onBeforeContentSave (aggiunto nella versione 1.5.4)
5. onAfterContentSave (aggiunto nella versione 1.5.4)

Editors:

1. onInit
2. onGetContent
3. onSetContent
4. onSave
5. onDisplay
6. onGetInsertMethod

Editors XTD (Extended):

1. onDisplay

Search:

1. onSearch
2. onSearchAreas

System:

1. onAfterInitialise
2. onAfterRoute
3. onAfterDispatch
4. onAfterRender

User:

1. onLoginUser
2. onLoginFailure
3. onLogoutUser
4. onLogoutFailure
5. onBeforeStoreUser
6. onAfterStoreUser
7. onBeforeDeleteUser
8. onAfterDeleteUser

XML-RPC:

1. onGetWebServices

Nel prossimo articolo vedremo il codice di esempio di un plugin.

Il pattern MVC

Il pattern MVC è un architectural pattern il cui scopo è quello di separare la rappresentazione del modello di dominio (model) dall'interfaccia utente (view) e dal controllo dell'interazione uomo-macchina (controller). Il pattern MVC è utilizzato ad esempio da Joomla e da molti altri framework come Ruby on Rails, Apache Struts etc...

Il pattern MVC è basato sulla suddivisione dei compiti fra i componenti che interpretano i tre ruoli principali:

1. il model fornisce i metodi per accedere ai dati utili dell'applicazione e agli algoritmi del programma.
2. la view visualizza i dati elaborati dal model e li mostra agli utenti.
3. il controller riceve i comandi dell'utente (in genere attraverso la view) e li attua modificando lo stato degli altri due componenti: in particolare recupera i dati dal model e li restituisce alla view stessa.

Questo schema, fra l'altro, implica anche la tradizionale separazione fra la logica applicativa (in questo contesto spesso chiamata "logica di business"), a carico del model, e l'interfaccia utente a carico della view.

Promozione siti web

Nuova promozione siti web valida per tutto l'anno: al prezzo di

300 € (tutto incluso)

offriamo siti web completi sviluppati con Joomla

La nostra promozione comprende per un sito web:

1. registrazione dominio e hosting per un anno 
2. installazione di Joomla e configurazione iniziale
3. creazione di un template personalizzato
4. home page più pagina dei contatti
5. pagina descrizione (dell'azienda, associazione, persona ...)

Se sei interessato contattami per il tuo nuovo sito web

Joomla 1.6: creare un modulo (III parte)

Nel post joomla 1.6: creare un modulo (II parte) abbiamo analizzato il codice necessario per creare un modulo in Joomla 1.6: in quest'ultimo articolo vedremo come leggere i parametri dei moduli in modo da rendere più interessanti le nostre applicazioni.

Inserire i parametri nel file xml del modulo

Per prima cosa dobbiamo dire a Joomla quali parametri vogliamo usare nel nostro modulo: prendiamo il nostro mod_ciao_mondo.xml e aggiungiamo subito dopo il tag <files> i nostri parametri:

<config> 
  <fields name="params">
    <fieldset name="basic">
      <field
        name="par1"
        type="text"
        default="ciao mondo"
        label="Scrivi il tuo saluto"
        description="Questo è il saluto che comparirà nel modulo" />
      <field
        name="par2"
        type="radio"
        default="1"
        label="Mostra il saluto"
        description="Decidi se mostrare il saluto oppure no">
        <option value="1">JSHOW</option>
        <option value="0">JHIDE</option>
      </field>
    </fieldset>
  </fields> 
</config>

In pratica abbiamo due parametri: uno conterrà il nostro saluto (par1) e l'altro ci permetterà di disabilitare oppure no il nostro messaggio attraverso una radio button (par2). 
Joomla mette automaticamente a disposizione nell'entry point del modulo la variabile $params che conterrà i valori che l'utente ha salvato nel backend del sito. Come forse avrete notato, la variabile $params veniva passata come argomento al metodo getSaluto dell'helper proprio per poter utilizzare i parametri del modulo.

Passare i parametri all'helper del modulo

<?php
class modCiaoMondoHelper
{
    public static function getSaluto(&$params)
    {
        if ($params->get("par2") == 1)
        {
            return $params->get("par1");
        }
        return false;
    }
}
?>

Il codice è molto semplice: se il secondo parametro è uguale a 1 (equivale a selezionare 'Mostra' nella radio button) viene usato come saluto il valore del primo parametro.

Modifichiamo il template

<?php
defined('_JEXEC') or die;
if ($saluto)
{ 
    echo $saluto;
}
?>

Dopo aver generato lo zip dei file siamo pronti ad utilizzare il modulo nel nostro sito web.

Joomla 1.6: creare un modulo (II parte)

Nell'articolo joomla 1.6: creare un modulo (I parte) abbiamo indicato quali sono i file necessari per creare un modulo in Joomla 1.6 e dove devono essere posizionati. In questo secondo articolo vedremo il codice necessario per realizzare il nostro modulo "Ciao mondo".

Punto di entrata del modulo

In mod_ciao_mondo.php si trova l'entry point del modulo ciao_mondo (il nome del file deve essere lo stesso della cartella che lo contiene):

<?php

// impediamo l'accesso diretto alla pagina

defined('_JEXEC') or die;

// richiesta del file helper.php

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

// chiamata al metodo statico getSaluto presente nell'helper

$saluto = modCiaoMondoHelper::getSaluto($params);

require JModuleHelper::getLayoutPath('mod_ciao_mondo', $params->get('layout', 'default'));

?>

Il codice è molto semplice ed i commenti dovrebbero essere sufficienti per capirne il funzionamento.

Il file helper del modulo

Nel nostro esempio il file helper.php sarà molto semplice:

<?php

// classe del modulo

class modCiaoMondoHelper

{

    // metodo statico

    public static function getSaluto(&$params)

    {

        // valore di ritorno

        return 'Ciao Mondo!';

    }

}

?>

Osserviamo soltanto che il nome della classe è composto da mod + CiaoMondo (nome del modulo senza underscore) + Helper.

Template del Modulo

Il file del template "tmpl/default.php" si limita semplicemente a visualizzare il contenuto della variabile $saluto:

<?php

defined('_JEXEC') or die;

echo $saluto;

?>

Notiamo come la variabile $saluto creata nello script mod_ciao_mondo.php sia automaticamente presente nel template grazie al framework di Joomla.

File xml del modulo

Infine vediamo il file mod_ciao_mondo.xml: esso servirà a Joomla per poter caricare correttamente il modulo:

<extension client="site" method="upgrade" type="module" version="1.6.2">

    <name>Ciao Mondo!</name>

    <author>Paolo Mosca</author>

    <version>1.6.2</version>

    <description>Modulo Ciao Mondo</description>

    <files>

        <filename module="mod_ciao_mondo">mod_ciao_mondo.php</filename>

        <filename>mod_ciao_mondo.xml</filename>

        <filename>index.html</filename>

        <filename>helper.php</filename>

        <filename>tmpl/default.php</filename>

        <filename>tmpl/index.html</filename>

    </files>

</extension>

Per poter utilizzare questo semplice modulo basterà creare uno zip (mod_ciao_mondo.zip) di tutti i file visti nei due tutorial e utilizzare la procedura di installazione di Joomla.