Microsoft Word - Programmare JOOMLA guida pratica con pubblicita.doc
PROGRAMMARE JOOMLA
GUIDA PRATICA
( Testato per versioni dalla 1.7 alla 2.5 )
Programmare JOOMLA guida pratica
Pag. 2
Autore: Gianpiero Fasulo
Ad ELISA ................... langelo in cielo
E a mia moglie.. angelo in terra
3
COPYRIGHT
Tutti i diritti riservati. Nessuna parte di questo libro pu essere riprodotta, memorizzata in un sistema di
recupero, o trasmessa in qualsiasi forma o con qualsiasi mezzo, senza la previa autorizzazione scritta della
editore, eccetto nel caso di brevi citazioni incorporate in articoli di critica o recensioni.
Ogni sforzo stato fatto per la preparazione di questo libro per assicurare l'accuratezza delle informazioni
presentate. Tuttavia, le informazioni contenute in questo libro viene venduto senza garanzia, espressa o
implicita. N l'autore, n i suoi concessionari e distributori saranno ritenuti responsabili per eventuali danni
causati o presumibilmente causati, direttamente o indirettamente da questo libro.
Programmare JOOMLA guida pratica
Pag. 4
Autore: Gianpiero Fasulo
Sommario
Breve .. introduzione .......................................................................................................................... 7
LA STRUTTURA DI JOOMLA ............................................................................................................ 8
LA CARTELLA CLI .......................................................................................................................................................... 8
I COMPONENTI .......................................................................................................................................................... 9
CARTELLA IMMAGINI ........................................................................................................................................... 10
CARTELLA INCLUDE ............................................................................................................................................. 11
CARTELLA LANGUAGE ........................................................................................................................................ 12
CARTELLA LIBRARIES ........................................................................................................................................... 12
CARTELLA LOGS ..................................................................................................................................................... 13
CARTELLA MEDIA .................................................................................................................................................. 13
CARTELLA MODULES ........................................................................................................................................... 14
CARTELLA PLUGINS .............................................................................................................................................. 17
CARTELLA TEMPLATES ....................................................................................................................................... 18
CARTELLA TMP ........................................................................................................................................................ 19
CARTELLA ADMINISTRATOR ............................................................................................................................ 19
CARTELLA ADMINISTRATOR/CACHE .......................................................................................................... 19
CARTELLA ADMINISTRATOR/COMPONENTS .......................................................................................... 20
CARTELLA ADMINISTRATOR/HELP .............................................................................................................. 21
CARTELLA ADMINISTRATOR/INCLUDES ................................................................................................... 22
CARTELLA ADMINISTRATOR/LANGUAGE ................................................................................................ 22
CARTELLA ADMINISTRATOR/MANIFESTS ................................................................................................. 22
CARTELLA ADMINISTRATOR/MODULES.................................................................................................... 23
CARTELLA ADMINISTRATOR/TEMPLATES ................................................................................................ 24
I FILES ................................................................................................................................................ 25
FILE ADMINISTRATOR/INDEX.PHP................................................................................................................... 26
FILE DEL TOP LEVEL DI JOOMLA ................................................................................................................... 26
LA PIATTAFORMA JOOMLA ........................................................................................................... 28
PROGRAMMAZIONE WEB E PROGRAMMAZIONE CLIENT (il ciclo di comando Joomla) ... 32
CONTROLLARE I COMANDI .............................................................................................................................. 34
JOOMLA IN PRATICA ............................................................................................................................................. 35
COME JOOMLA ESEGUE IL CODICE .............................................................................................................. 36
5
INSTALLIAMO UN MODULO E ANALIZZIAMOLO .............................................................................. 37
COMPRENDERE I PLUGIN .............................................................................................................................. 39
TRADURRE UN COMPONENTE .................................................................................................................... 43
IL MANIFEST ................................................................................................................................. 44
VISUALIZZARE INFORMAZIONI NEI MODULI ..................................................................... 47
CONFIGURARE NEI MODULI DEL BACK END I PARAMETRI ........................................... 49
GLI STILI ......................................................................................................................................... 51
FARE LOVERRIDING DEI LAYOUT ......................................................................................... 55
FUNZIONAMENTO DELLMVC ................................................................................................. 58
LE SCELTE DEL CONTROLLER IN JOOMLA ......................................................................... 61
ANALIZZIAMO LE VIEWS ........................................................................................................... 64
IL MODEL DATA ........................................................................................................................... 68
VISUALIZZARE UN SINGOLO RECORD .................................................................................. 71
VISUALIZZAZIONE COMPLESSA DI UN RECORD ................................................................ 75
VISUALIZZARE RECORD DA DVERSE TABELLE/DATASET............................................... 78
LINCARE TUTTE LE VIEW ......................................................................................................... 82
USIAMO I CSS PER IL LAYOUT DEL COMPONENTE............................................................ 86
OVERRIDING DELLE VIEWS ..................................................................................................... 91
IL BACKEND VISUALIZZARE I RECORD .............................................................................. 95
AGGIUNGERE LA TOOLBAR NEL BACK END ...................................................................... 101
GESTIAMO IL BACKEND TRAMITE IL CONTROLLER E IL MODEL .............................. 104
PAGINARE I RISULTATI ................................................................................................................ 107
FILTRARE I RECORD..................................................................................................................... 109
Programmare JOOMLA guida pratica
Pag. 6
Autore: Gianpiero Fasulo
AGIUNGERE UNA SEARCH BOX ................................................................................................. 113
ORDINARE LE COLONNE ............................................................................................................ 118
EDITARE I RECORD NEL BACKEND ......................................................................................... 121
UTILIZZARE LA CLASSE JFORM .................................................................................................. 126
LEGERE DATI CON JFORM .......................................................................................................... 130
DIVIDERE IL LAYOUT DEL FORM IN DUE PARTI CON JFORM ......................................... 131
Gli elementi di JFORMS ..................................................................................................................... 134
Aggiungere pannello di controllo al componente .............................................................................. 136
Leggere i valori del pannello di configurazione del componente ...................................................... 138
Configurare un pannello di controllo per un modulo ......................................................................... 142
Creare i link dei men per le nostre views .......................................................................................... 145
Configurare i men con link individuali alle nostre view ................................................................... 146
Usare MOOTOOLS in JOOMLA....................................................................................................... 148
Usare MOOTOOL e JQUERY insieme ............................................................................................. 150
LE BASI DELLA SICUREZZA IN JOOMLA .................................................................................. 153
FARE L'OVERRIDE DEL LINGUAGGIO...................................................................................... 156
CREIAMO IL NOSTRO PACKAGING ............................................................................................ 157
7
Breve.. introduzione
Non sar prolisso nella introduzione e nemmeno nella spiegazione di ogni paragrafo di questo libro, ho
cercato di essere diretto, semplice e chiaro, sono un tecnico e so che chi legger questo libro comunque un
tencico e vuole andare subito al dunque, capire, risolvere problemi e mettere in pratica quello che si letto.
Come sta scritto sulla home page del mio sito personale www.gfasulo.it so che richiederebbe una completa
rivisitazione.... non lo tocco dal 2008, ma si sa, il tempo danaro e il sito personale viene messo sempre
dopo il cliente. Come dicevo, sul mio sito c' scritto il seguente mio pensiero che da allora non cambiato
anzi si rafforzato e recita cos.
A volte e vero, si ha bisogno di far vedere cosa abbiamo realizzato
o forse di dimostrarlo a noi stessi o forse il sito ed in questo caso il libro loccasione per fare un po dordine in tanto
materiale accumulato.
Mi sento come tanti che da anni lavorano anche perche ci credono, perche provano ancora quella soddisfazione dentro
quando realizzano qualcosa da soli o insieme agli altri, quando, nonostante tutte le batoste e i problemi quotidiani vanno
avanti, perch lavorare bello perch si continua ad imparare e a confrontarsi.
Mettere in comune attivit, informare, offrire strumenti, far conoscere gli sforzi fatti per raggiungere un fine o uno scopo o la
creazione di un software aiuta ad un vero apprendimento attraverso luso delle nuove tecnologie.
Ecco, questo libro riflette quanto appena detto, anche il suo costo lo riflette pi che un vero e proprio
prezzo lo definirei un contributo per quanto fatto durante le notti di lavoro passate nel ricercare
documentazione, sperimentare, testare ed in fine condividere quanto si appreso. Spero che questo libro
sia di aiuto a tutti coloro che vorranno introdursi nel mondo della programmazione JOOMLA!
Ma mettiamoci subito al lavoro
Programmare JOOMLA guida pratica
Pag. 8
Autore: Gianpiero Fasulo
LA STRUTTURA DI JOOMLA
Proprio per dare senso a quanto avete appena letto, mettiamoci subito al lavoro e studiamoci in dettaglio
come strutturato JOOMLA dato che ci servir di base poi per capire come creare il nostro componente.
Ecco di seguito uno screen della struttura delle cartelle di una installazione tipica di JOOMLA
Vediamo adesso nel dettaglio le principali cartelle di una installazione cosa sono e a cosa servono in
JOOMLA.
La cartella CLI
La cartella cli stata aggiunta come standard per la memorizzazione dei comandi d'interfaccia di linea
applicazioni CLI. Una delle grandi caratteristiche della piattaforma Joomla la capacit di
creare facilmente applicazioni CLI che interagiscono con un sito Joomla. Le applicazioni CLI si
adattano bene per funzionare su piattaforme Linux come ad esempio il cron per automatizzare delle
operazioni
9
I COMPONENTI
Un componente normalmente la cosa principale di una determinata pagina e corrisponde di solito a una
voce di men. Quando si seleziona un elemento da un men, viene caricata la pagina contenente il
componente definita da quella voce di menu.
Se guardiamo le sottocartelle dei componenti, vediamo ciascuno dei componenti fondamentali di
Joomla: com_banners e com_contact e per gli articoli com_content, com_finder (per Smart
Search), com_mailto e com_media, com_newsfeeds, com_search, com_users,
com_weblinks e com_wrappers.
Come avrete probabilmente capito, le cartelle dei componenti iniziano tutte con le lettere com_ seguita
dal nome del componente. Questo un esempio di forti convenzioni di denominazioni di cartelle che
vengono utilizzate in tutto Joomla. Se guardiamo le opzioni quando si crea una nuova voce di menu per i
componenti di base, possiamo vedere le opzioni mostrate in figura.
La maggior parte di questi tipi di elementi di menu corrispondano esattamente a una delle cartelle
Joomla. Queste includono i contatti, articoli (che utilizza la cartella com_content), news feed, ricerca,
utenti, link, e wrapper
Programmare JOOMLA guida pratica
Pag. 10
Autore: Gianpiero Fasulo
Ad esempio invece, i componenti, com_banners com_mailto e com_media fanno eccezione e non
corrispondono ai tipi di voci di menu. I Banner sono dei componenti ma vengono inseriti in pagine interne
ai moduli. Come ad es. quando si fa clic sull icona E-mail per inviare una e-mail di un articolo a qualcuno,
il componente com_mailto viene richiamato. Anche il componente com_media fa eccezione e viene
chiamato quando si modifica un articolo del front-end e si preme il pulsante Immagine per caricare il Media
Manager.
Questi componenti non vengono visualizzati come la cosa principale in una pagina e quindi non inserite
nella semplice definizione di un componente. Questo ci porta alla pi dettagliata e tecnica definizione di un
componente, che questa: Un componente un'estensione che ha da compiere qualche azione e
che visualizza qualcosa. Ad esempio, quando si fa clic su di un banner, bisogna scrivere nel database
per registrare il click per poi magari reindirizzare lutente ad un altro URL. Allo stesso modo, quando si fa
clic sull'icona E-mail, deve essere visualizzato un modulo ( form ) da compilare e poi inviare il messaggio
tramite e-mail. Quando si desidera inserire un'immagine in un articolo, si eseguono azioni, come ad
esempio il caricamento di un'immagine al server web.
In tutti questi casi quindi, abbiamo bisogno di un componente per gestire queste azioni, anche se
questi componenti non faranno mai parte del contenuto centrale di una pagina del nostro sito.
CARTELLA IMMAGINI
La cartella immagini il luogo ottimale dove i file di immagini possono essere memorizzati. Per esempio,
nella distribuzione di base, abbiamo delle sottocartelle chiamate banner e sampleData. Come ci si
aspetterebbe, la cartella banner memorizza le immagini di esempio dei banner che sono inclusi nella
distribuzione standard di joomla. La cartella sampleData contiene le immagini utilizzate dei dati del
campione che possibile installare (facoltativamente) durante l'installazione di Joomla.
Nota sui file Index.html
Noterete che ogni sottocartella nella distribuzione Joomla ( ad eccezione di administrator e installation, che
contengono file index.php ) contiene un file chiamato index.html. Se si apre questo file con un editor, si
vedr il seguente contenuto:
Si tratta di un file HTML con un elemento e un elemento vuoto. Questo file non ha
contenuto e quando vengono visualizzati in un browser mostrer una pagina vuota. Perch in Joomla
abbiamo questi file ovunque? La risposta : per la sicurezza . Se un utente tenta per individuare una
cartella, il server web cerca un file chiamato index.php o in mancanza un file indice. html ( index.html ) da
caricare. Se non riesce a trovare uno di questi file, il browser mostra un elenco di file e le
sottocartelle presenti nella cartella padre ( a meno che il server non sia configurato diversamente ). Potete
provare quanto detto, rinominando temporaneamente nella cartella images/ il file index.html in
11
images/index1.html. Se poi puntate alla URL "/images ", vedrete qualcosa di
simile alla Figura sotto.
Se si rinomina nuovamente il file index.html, e ripuntate alla stessa URL vedrete solo una pagina vuota.
Consentire quindi ad un utente non autorizzato di visualizzare informazioni sui file e le cartelle sul vostro
server viene considerato un rischio per la sicurezza dello stesso sito. Qualcuno che voglia hackerare il
vostro sito web pu utilizzare queste informazioni per cercare un eventuale vulnerabilit del sito o del server
intero. Questo quindi il motivo principale per il quale esiste un file index.html in queste cartelle.
Le cartelle installation e administration sono le uniche che non contengono un file
index.html. Questo perch contengono un file index.php che funge da punto di ingresso per il processo di
installazione di joomla e del back-end amministrativo. In questo caso, il file index.html impedirebbe il
caricamento del file index.php.
CARTELLA INCLUDE
Abbiamo accennato in precedenza che la cartella administator, che controlla il back-end del sito, pu essere
pensata come un'applicazione del tutto separata dall' front-end del sito. Per questo motivo, quando si
inizia una sessione di front-end e back-end, abbiamo bisogno di caricare classi diverse e diverse costanti in
memoria.
La cartella include contiene i programmi specifici sia per il front-end che per il back-end. Cos il top-
level del sito contenente la cartella /include carica i file di cui abbiamo bisogno per ottenere una sessione
valida per il front-end, mentre la cartella administrator/includes contiene i file di cui abbiamo bisogno
per ottenere una sessione valida per il back-end.
La cartella include contiene i file indicati nella tabella sotto:
File Azione
application.php Crea le classi del sito Joomla
Programmare JOOMLA guida pratica
Pag. 12
Autore: Gianpiero Fasulo
defines.php Definisce le costanti per i path dei files
framework.php Carica delle porzioni di codice usati in diverse parti
del sito ( conosciuto anche come la piattaforma )
menu.php Carica lintero men del sito in memoria
pathway.php Carica la classe JPathwaySite, che viene utilizzata nel
mod_breadcrumbs che mostra il path del menu
attualmente selezionato
Router.php Carica la classe JrouterSite ( discussa in seguito )
CARTELLA LANGUAGE
Joomla stato progettato per essere eseguito in modo nativo in uno qualsiasi dei 68
linguaggi. Praticamente tutto il testo viene tradotto in Joomla prima di essere mostrato nel browser. Questo
viene fatto per mezzo dei pacchetti di lingua, che installano una serie di file di lingua. La
sottocartella language dove questi pacchetti di lingua vengono installati. Con una installazione
standard inglese, troveremo due sottocartelle: en-GB e overrides ( vedremo meglio lutilizzo di tutte e
due pi avanti nel libro ). La prima cartella contiene tutti i file linguistici necessari per tradurre il front-
end del sito in inglese. ( Il GB sta per Gran Bretagna. L'inglese ufficiale di Joomla lInglese ).
La seconda cartella relativa a una nuova funzionalit introdotta nella versione 1.6: le override di lingua.
Loverride di lingua consente di modificare il valore di qualsiasi stringa di testo, senza dover sostituire
l'intero file della lingua. Si noti che ci sono spesso due file di lingua con diverse estensioni, uno con
estensione .Sys.ini e uno con estensione .ini I file sys.ini sono letti per prendere il nome e la descrizione
delle estensioni, come quelle mostrate nel Module Manager di joomla. I file .ini invece vengono caricati,
quando in realt stiamo lavorando con l'estensione per visualizzare quindi tutte le stringhe di testo
utilizzate nella pagina dallestensione appena caricata.
CARTELLA LIBRARIES
Una libreria software un insieme di programmi che sono stati progettati per essere riutilizzati in contesti
diversi. Una libreria svolge normalmente un compito specifico o un insieme di attivit correlate, queste
librerie sono memorizzate in sottocartelle della cartella libraries. Nella versione 1.5, Joomla utilizzava 14
librerie. Di queste, 13 erano provenienti da librerie esterne di sviluppatori di terze parti e una era la
libreria Joomla. Nella versione 2.5, questo numero stato ridotto a quattro. Tre librerie esterne che sono:
phpmailer, utilizzata per l'invio di e-mail; phputf8, utilizzata per alcune operazioni sul testo UTF-
8 e SimplePie, utilizzata per i feed RSS. La cartella che ci interessa di pi della libraries da come si pu
intuire la cartella joomla. Questa cartella contiene le classi della piattaforma Joomla. A partire dalla
13
versione 2.5, abbiamo anche una cartella chiamata cms. Questa cartella contiene la libreria utilizzata per il
content management system Joomla (CMS), ma non applicabile al piattaforma quindi al framework.
CARTELLA LOGS
Questa cartella viene utilizzata per archiviare i file di log generati da Joomla e non solo, vedremo come far
generare a Joomla il Log solo per la nostra estensione. Gli eventi vengono registrati sulla base di determinate
condizioni. Ad esempio, una condizione di errore viene registrata in un file chiamato error.log. In pi,
attivando la modalit di debug si otterr la registrazione di ulteriori eventi utili a comprendere eventuali
errori di codice.
CARTELLA MEDIA
La cartella media contiene i CSS, Javascript, e file di immagine per alcuni dei componenti, moduli, e
editor. la sottocartella system contiene, tra le altre cose, la MooTools JavaScript framework , che viene
utilizzata in Joomla per la alcune funzionalit JavaScript.
Programmare JOOMLA guida pratica
Pag. 14
Autore: Gianpiero Fasulo
15
CARTELLA MODULES
La cartella modules contiene una sottocartella per ogni modulo del front-end disponibile. La tabella
seguente mostra le sottocartelle sulla sinistra e un elenco dei tipi di modulo che si vedono quando si crea un
nuovo modulo in Gestione moduli sulla destra. Ogni tipo di modulo ha una sua sottocartella. La Tabella
Moduli mostra i nomi dei moduli che corrispondono al nome delle sottocartelle. Quando si
installano delle estensioni dei moduli base, essi vengono aggiunti come sottocartelle alla cartella principale
modules e diventano completamente integrati nella vostra applicazione Joomla.
Nome sottocartella Tipo modulo/nome Descrizione
mod_articles_archive Articoli archiviati Chiamato mod_archive nella
versione 1.5
mod_articles_categories Categorie articoli Introdotto dalla versione 1.6
mod_articles_category Categoria articoli Introdotto dalla versione 1.6
sostituisce il vecchio
mod_sections
mod_articles_latest Ultime notizie Era mod_latestnews nella ver. 1.5
mod_articles_news Articoli news-flash Era mod_newsflash nella ver. 1.5
mod_articles_popular Contenuti pi letti Era mod_mostread nella ver. 1.5
mod_banners Banner
mod_breadcrumbs Sei qui ( visualizza posizione
men )
mod_custom Modulo HTML custom
mod_feed Modulo Feed
mod_finder Ricerca smart Introdotto nella versione 2.5
mod_footer Gestisce il footer
mod_languages Cambia linguaggio Introdotto dalla versione 1.6
mod_login Gestisce i login
mod_menu Gestisce i men Era mod_mainmenu nella ver. 1.5
mod_random_image Modulo immagini casuali
mod_related_items Modulo articoli correlati
mod_search Modulo cerca
mod_stats Modulo statistiche
mod_syndicate
mod_users_latest Modulo ultimi utenti Introdotto dalla versione 1.6
mod_weblinks Mofulo Link web Introdotto dalla versione 1.6
Programmare JOOMLA guida pratica
Pag. 16
Autore: Gianpiero Fasulo
mod_whosonline Modulo chi in linea
mod_wrapper Modulo wrapper di URL
Di seguito un immagine che spiega la struttura dei moduli
17
CARTELLA PLUGINS
La cartella plugins contiene le estensioni dei plugin. Nella versione 2.5, ci sono dieci tipi di plugins,
ognuno con la sua sottocartella, come indicato nella Tabella sotto. Ogni tipo di plugin espone un tipo
specifico di attivit sul sito e risponde agli eventi che vengono attivati durante queste attivit.
Nome cartella Utilizzato in quale parte del sito
Authentication Durante il login ed il controllo utente/passowrd
Captcha Visualizzato durante la visualizzazione dei captcha
Content Durante la creazione e lediting di contenuti
Editors Durante il caricamento delleditor standard ( tinymce
)
editors- xtd Crea i pulsanti di edit ( tipo: articoli, immagini,
interruzione di pagine, leggi tutto ) quando viene
caricato leditor
Extension Richiamato quando si installano, disinstallano o si
aggiornano le estensioni
Finder Richiamato durante lo smart search
Search Richiamato durante il search
System Richiamato in vari punti durante lesecuzione di cicli,
Programmare JOOMLA guida pratica
Pag. 18
Autore: Gianpiero Fasulo
CARTELLA TEMPLATES
In Joomla, il contenuto di ogni pagina web separato il pi possibile dal modo in cui la pagina stessa
viene presentata sullo schermo.
La presentazione della pagina controllata da estensioni chiamate modelli ( templates ). La
cartella templates contiene una sottocartella per ogni modello di front-end che installato nel sistema ( si
possono installare pi modelli/templates ma uno solo sar quello attivo ). In una installazione di
default, sono inclusi i template atomic,beez_20 e beez5. Questa cartella contiene anche una cartella di
sistema.
Il template di sistema ha alcune informazioni di layout che sono condivise da tutti gli altri template e
viene anche utilizzata dal sistema come fallback in caso di una classe CSS o un file non pu essere
trovato nel template utilizzato.
19
CARTELLA TMP
La cartella tmp, come si pu immaginare, la cartella di sistema dove vengono archiviati i file a
temporanei. Uno degli usi pi frequenti di questa cartella quando si installano le estensioni. Quando
una nuova estensione installata, una copia del file dellarchivio dell' estensione viene copiata nella la
cartella tmp e poi viene estratta nelle cartelle corrette di Joomla.
CARTELLA ADMINISTRATOR
Come discusso in precedenza, Joomla pu essere pensato come se fossero due applicazioni separate che
condividono parte dello stesso codice. Queste applicazioni sono il front-end del sito e il back-
end amministrativo del sito.
Ci evidente quando si accede alle sottocartelle della cartella administrator. La cartella administrator
contiene molte delle sottocartelle del di livello superiore ( root di joomla ), tra cui la cache, i componenti
(components) , aiuto (help), inclusioni (includes), il linguaggio (laguages), i moduli (modules), modelli
(templates) e il file index.php.
CARTELLA ADMINISTRATOR/CACHE
Questa cartella contiene i file di cache per il back-end del sito. Quando le pagine del back-end vengono
cached, i file di cache temporanei vengono memorizzati in questa cartella.
Programmare JOOMLA guida pratica
Pag. 20
Autore: Gianpiero Fasulo
CARTELLA ADMINISTRATOR/COMPONENTS
Questa cartella contiene tutti i componenti che sono disponibili nel back-end del sito. Ogni scelta di
menu nel back-end fornito da uno di questi componenti. La tabella seguente elenca ogni componente e le
opzioni del men del back-end alle quali suppliscono.
Nome Cartella Opzioni del men amministratore
com_admin Help Sito help di Joomla! Mio Profilo,e Sito
Info di Systema
com_banners Componenti Opzioni Banners
com_cache Sito Manutenzione Pulisci Cache, Sito
Manutenzione Cancella Cache scaduta
com_categories Contenuto Gestione categorie,
Componenti Banners Categorie,
Componenti Contatti Categorie,
Componenti Newsfeeds Categorie,
Componenti Weblinks Categorie
com_checkin Sito Manutenzione Controllo globale
com_config Sito Configurazione globale
com_contact Componenti Contatti opzioni
com_content Contenuti Gestione articoli,
Contenuti Articoli in evidenza
com_cpanel Sito Pannello di controllo
com_finder Componenti Motore di ricerca
com_installer Estensioni Gestione estensioni
com_languages Estensioni Gestione lingua
com_login Videata login amministrazione, Sito Logout
com_media Contenuti Gestione media
com_menus Menu Gestione Menu,
com_messages Componenti Messaggi
com_modules Estensioni Gestione moduli
com_newsfeeds Componenti Newsfeed
com_plugins Estensioni Gestione plugin
com_redirect Componenti Redirect
21
com_search Componenti Statistiche ricerche
com_templates Estensioni Gestione template
com_users Utenti Gestione utenti
com_weblinks Componenti Link Web
CARTELLA ADMINISTRATOR/HELP
Questa cartella contiene un file chiamato helpsites.xml. Questo file contiene l'elenco dei siti di Guida in
linea disponibili. Normalmente, quando si preme il pulsante Help nel back-end, si viene indirizzati alla guida
in linea di docs.joomla.org. C' anche una cartella chiamata en-GB che contiene un file HTML per ogni
argomento della Guida. Ci consente di avere i file di aiuto sul server locale. Come spiegato il file in questa
cartella serve semplicemente a reindirizzare l'utente alla guida in linea. Ma essi possono essere sostituiti se si
desidera fornire i file di aiuto a livello locale.
Programmare JOOMLA guida pratica
Pag. 22
Autore: Gianpiero Fasulo
CARTELLA ADMINISTRATOR/INCLUDES
Questa cartella serve allo stesso scopo della cartella includes del top-level come discusso in precedenza.
Questa cartella contiene i file di cui abbiamo bisogno per ottenere una sessione di back-end, come mostrato
in Tabella sotto.
File Azione
application.php Crea la classe JAdministrator
defines.php Definisce le costanti dei path per i files
framework.php Carica delle porzioni di codice usati in diverse parti
del sito ( conosciuto anche come la piattaforma )
helper.php Controlla se si loggati e ti direziona alla giusta
opzione del componente
menu.php Carica lintero men amministratore in memoria
router.php Carica la classe JRoutersiteSite
toolbar.php Mette a disposizione dei metodi per caricare la
toolbar nel back-end
CARTELLA ADMINISTRATOR/LANGUAGE
Questa cartella esattamente uguale a quella language che si trova al livello superiore del sito ( la root del
sito ) tranne che viene utilizzata per la traduzione del back-end amministrativo del sito stesso. Ogni
componente, modulo, plugin e template ha i suoi propri file di lingua.
Si noti che, come per il front-end i file di lingua, che normalmente hanno un file .Sys.ini e un file
.ini per ogni estensione. Come discusso in precedenza, il file .Sys.ini di solito include solo il nome e la
descrizione dell'estensione da visualizzare nellelenco di estensioni. Il file .Ini invece traduce tutte le
stringhe di testo utilizzate all'interno dellestensione.
CARTELLA ADMINISTRATOR/MANIFESTS
Si tratta di una nuova cartella inserita dalla versione 1.6 per supportare la nuova funzionalit di
aggiornamento one-click. Essa contiene tre sottocartelle ( files, libraries e packages ):
La cartella files contiene un file chiamato joomla.xml che elenca tutte le cartelle e i file del top-level di
in una installazione standard di Joomla.
Essa contiene anche un elenco di aggiornamento dei server ( le rispettive URL) da cui il software
pu cercare versioni aggiornate di questi file. Questo file XML informa il programma di aggiornamenti e di
quali file deve aggiornare per questa o quella applicazione.
23
La cartella libraries contiene un file XML per ogni libreria utilizzata in Joomla. Questi
file XML elencano tutte le cartelle e le sottocartelle nella libreria e, ancora, una URL da cui il programma
pu controllare gli aggiornamenti alla libreria stessa.
La cartella packages contiene anche essa un file chiamato joomla.xml. Ci permette di usare un metodo
per laggiornamento del installazione Joomla come se fosse un pacchetto, invece di scaricare una serie di file
da aggiornare a mano ( metodo valevole sino alla versione 1.5 ).
Questa funzione implementata anche per la versione 2.5. Essa supporta anche le relazioni di dipendenza
tra le estensioni. Per esempio, se si richiede di aggiornare o installare l'estensione A che richiede le
estensioni B e C, queste verranno automaticamente incluse nella installazione del pacchetto da aggiornare.
CARTELLA ADMINISTRATOR/MODULES
Questa cartella funziona allo stesso modo per il back-end, come la cartella di livello superiore dei moduli
che serve per il front-end. Essa contiene una sottocartella per ogni modulo di back-end. come mostrati in
figura sotto. Ogni tipo di modulo ha una sua sottocartella. La Tabella di seguito mostra i nomi dei moduli e
la loro corrispondenza ai nomi di sottocartella.
Programmare JOOMLA guida pratica
Pag. 24
Autore: Gianpiero Fasulo
Nome sottocartella Tipo di modulo
mod_custom HTML personalizzato
mod_feed Visualizza Feed
mod_latest Ultime notizie
mod_logged Utenti loggati
mod_login Form di login
mod_menu Men amministratore
mod_multilangstatus Stato multilinguaggio
mod_popular Articoli pi letti
mod_quickicon Icone veloci
mod_status Stato utente
mod_submenu Sottomen amministratore
mod_title Titolo
mod_toolbar Toolbar
CARTELLA ADMINISTRATOR/TEMPLATES
Questa cartella contiene i modelli/templates utilizzati per visualizzare le pagine di back-end.
Due modelli/templates sono inclusi nella implementazione standard: Bluestork e Hathor. Bluestork il
modello predefinito, Hathor un modello studiato appositamente per l'accessibilit. Per esempio, Hathor
progettato per funzionare bene con i lettori di schermo (usati da persone con problemi visivi e/o
menomazioni), senza usare il mouse (per coloro che potrebbero avere difficolt ad usare un mouse). Mentre
dalla versione 3.0 troverete solo Hathor. Come il front-end, anche qui viene incluso un template di
sistema che viene utilizzato per le visualizzazioni tipiche ed anche come ripiego se il template assegnato
mancante.
25
Programmare JOOMLA guida pratica
Pag. 26
Autore: Gianpiero Fasulo
I FILES
FILE ADMINISTRATOR/index.php
Questo file viene caricato automaticamente dal server web quando il browser punta al cartella
amministratore. E il punto di ingresso per il back-end di Joomla. Esso controlla nel back-end il ciclo dei
comandi da eseguire allo stesso modo del file index.php del front-end. Si noti che affinch il server carichi
questo file, non abbiamo bisogno di un file index.html in questa posizione.
FILE DEL TOP LEVEL DI JOOMLA
I files descritti nella tabella seguente sono quei files che si trovano nella root di Joomla.
Nome file Funzione svolta
configuration.php Questo file viene creato dopo una corretta
installazione e contiene le impostazioni che sono
specifiche del sito, come le informazioni
di connessione al database, e altre impostazioni. La
maggior parte, ma non tutti, di queste impostazioni
possono essere modificate nella schermata di
Configurazione Globale nel back-end.
htaccess.txt Questo un file che pu essere rinominato in
.htaccess e utilizzato con il mod_rewrite funzionalit
del server web Apache. Quando utilizzato, rimuove
la index.php da tutti gli URL Joomla e fornisce
alcune sicurezze supplementari.
index.php Questo il punto dingresso del front-end per
il caricamento della pagina di default di
Joomla. Viene caricato automaticamente dal
server web quando si carica un
URL che punta al sito (in altre parole, che
non punta alla cartella amministratore).
joomla.xml Si tratta di una copia di administrator / manifests /
files /
joomla.xml e viene utilizzato durante l'installazione
e quindi eliminato dal
la cartella principale dopo l'installazione.
27
LICENSE.txt Questo file contiene il testo del contratto di
licenza Joomla. Joomla
rilasciato sotto licenza GNU General
Public Versione 2,
del giugno 1991.
README.txt Contiene informazioni generagli su Joomla
robots.txt
Programmare JOOMLA guida pratica
Pag. 28
Autore: Gianpiero Fasulo
LA PIATTAFORMA JOOMLA
Dopo questo escursus sulla struttura di Joomla non di certo esaustivo ma quantomeno indicativo del come
bisogna muoversi tra le varie cartelle di una installazione di Joomla, possiamo passare al lavoro vero e
proprio.
Per prima cosa imparate a pensare a Joomla non come CMS ma come piattaforma per la creazione di
applicazioni web. Pensate quindi al CMS Joomla come un applicazione che si trova sulla cima di qualcosa di
ancora pi fondamentale, qualcosa che costituisce il fondamento su cui costruito tutto in Joomla. Quel
qualcosa la piattaforma Joomla.
Precedentemente veniva chiamato "il Framework di Joomla" Le librerie di Joomla", e probabilmente in
molti altri modi. Con Joomla 1.5, si deciso di pulire in modo pi gestibile e organizzabile il codice. Si
pensato di creare un qualcosa di familiare per chi proveniva dal mondo dello sviluppo professionale in cui
vengono invocati framework per fornire la logica di programmazione. Per esempio, si pensato che lo
sviluppo di Joomla sia pi comodo per quei programmatori provenienti da Java o da NET. Grazie a
questo, abbiamo deciso di costruire quello che oggi conosciuta come la piattaforma Joomla.
Quando si entra nella cartella libraries, si vedono cinque cartelle e quattro file PHP (insieme con il
file HTML obbligatorio). All'interno del file loader.php c' una classe importante e due
funzioni altrettanto importanti. La classe si chiama JLoader e questa la classe che gestisce anche i
programmi della piattaforma in modo da poterli utilizzare nei vostri progetti. Le due funzioni
sono jexit () e jimport ().
Il jexit () un wrapper per la funzione exit del PHP . Essa serve a rendere pi semplici i test e andrebbe
sempre usata negli script invece di utilizzare exit() direttamente. Jimport () invece una scorciatoia per
chiamare JLoader::import () ed destinato a fornire una sintassi simile alla istruzione import in
Java o l'istruzione using in C #. L'idea generale di dare al metodo jimport () un punto separato di percorso
alla libreria che si desidera utilizzare cos che la piattaforma si assicuri che a vostra disposizione quando la
si vuole utilizzare.
Le cartelle invece sono joomla, cms, phpmailer, phputf8 e SimplePie. Le tre che
non sono pacchetti Joomla sono librerie di terze parti che il CMS Joomla utilizza per fornire varie
funzionalit:
phpmailer un pacchetto per la gestione complessa di invio e-mail.
phputf8 un pacchetto per rendere in PHP lUTF8 pi semplice e viene utilizzato per aumentare
la funzionalit di PHP nativo per il trattamento di stringhe UTF-8.
SimplePie un pacchetto per gestire il parsing XML feed come RSS e ATOM.
29
La cartella joomla contiene tutte le librerie che compongono la piattaforma Joomla.
La cartella cms stata aggiunta nella versione 2.5. Essa contiene librerie di classi necessarie al CMS Joomla,
ma non applicabili alla piattaforma Joomla.
Ci sono due file PHP nella cartella libraries/joomla.
factory.php contiene una classe statica denominata JFactory e fornisce un modo semplice per
ottenere oggetti di sistema diversi da un'interfaccia comune.
methods.php n contiene alcune classi statiche di supporto per interagire con gli URL e traduzione
del testo.
Le cartelle che si trovano all'interno di libraries/joomla sono conosciute come packages di librerie e sono
raggruppate in modo logico in base al tipo di funzionalit che forniscono (vedi Tabella sotto).
Nome Packages di libreria Funzione
Access Funzionalit per il controllo di access list (ACL) del
sistema, che consente di controllare quali azioni i
diversi utenti possono compiere sui diversi
oggetti del sito web
Application
Base
Funzionalit per le estensioni, nonch per la classe
principale dellapplicazione sono classi di base a
basso livello che sono generalmente molto astratte e
implementano una sorta di struttura di design
pattern o dati
Cache Classi che gestiscono il caching dei dati di vario tipo
Client Classi client per connettersi a server diversi,
quali FTP o LDAP
Database Classe usata per connettersi ed interagire con il
database
Document Classe per creare e/o manipolare i documenti da
inviare eventualmente al browser
Environment Classi per interagire con le richieste di valori
(GET, POST, COOKIE) e le intestazioni di risposta
delle pagine
Error Classe che ci aiuta nella gestione degli errori
event
Classi che costituiscono il nostro sistema di eventi in
modo da poterli gestire
filesystem
Classi utilizzate per gestire il file system
Programmare JOOMLA guida pratica
Pag. 30
Autore: Gianpiero Fasulo
filter
Classi per controllare e filtrare i valori di input e di
output
form
Classi che ci aiutano a creare, manipolare e
processare i form web
github
Classi per interagire con il sistema di repository della
piattaforma di controllo di
versione http://github.com
html
Metodi di aiuto per la generazione di codice HTML,
caricamento di file CSS o Javascript
http
Classi per lavorare con tipi diversi di richieste HTTP
image
Classi per lavorare con le immagini
installer
Classi per linstallazione o laggiornamento di
estensioni
language
Classi per tradurre stringhe in diversi linguaggi
log
Classi per implementare funzionalit di logging
Metodi di aiuto per inviare e-mail
plugin
Classi relazionate ai plugins di sistema
registry
Classi per lavorare con complessi oggetti dei dati.
Come ad esempio, limport/export di file INI, JSON
e XML
session
Classi per manipolare, creare e registrare le sessioni
string
Classi per lavorare con le stringhe
updater
Classi per supportare lautoaggiornamento delle
estensioni
user
Classi per manipolare o interagire con gli oggetti
utente
utilities Classi di supporto che non rientrano in altri pacchetti
31
separati
Programmare JOOMLA guida pratica
Pag. 32
Autore: Gianpiero Fasulo
PROGRAMMAZIONE WEB E PROGRAMMAZIONE CLIENT
(il ciclo di comando Joomla)
E importante comprendere questa distinzione tra i due modi di programmare per poter comprendere
meglio il ciclo di vita dei comandi in Joomla. Due fattori importanti per poter distinguere tra
programmazione dinamica web, ( come quella che vediamo in Joomla ), da quella
che chiameremo, la programmazione "normale", come, una applicazione tipica desktop ad es. un foglio di
calcolo. Queste diversit hanno a che fare con il modo di manutenzione del programma e con che tipo di
validazione dei comandi necessaria.
La prima differenza da comprendere come lo stato del programma viene mantenuto durante l'esecuzione
del programma stesso. Per stato, si intende quello che il programma conosce di se stesso e del suo ambiente
sul quale viene eseguito e come memorizzato nella memoria di lavoro del computer. Mettiamo a
confronto come funziona un foglio di calcolo Desktop con il modo con cui funziona Joomla
con riguardo particolare al modo in cui entrambi mantengono lo stato del programma stesso.
Cercheremo di illustrare quanto sopra detto pensando ai nostri programmi software come opera
Aladino con la sua lampada magica.
Immaginate che quando si invia un comando software, all'interno del computer Aladino che in realt
impartisce un comando al genio software che esegue il lavoro. Al genio del foglio elettronico si
possono chiedere tanti desideri in una sola volta. Al contrario, al genio Joomla si pu chiedere solo un
desiderio ogni volta.
Con il nostro foglio di calcolo ad esempio, la prima cosa da fare caricare il software cliccando su un icona
sul desktop. Aladino strofina la lampada per fare apparire il genio. Il genio esce dalla lampada e Aladino gli
comanda "visualizza il software foglio di calcolo sullo schermo dell'utente!" Il genio fa questo e attende il
comando successivo di Aladino. Quindi, si prosegue dicendo al software di aprire ad esempio il file
"budget". Aladino trasmette questo comando al genio e il file viene aperto. Questo processo continua fino a
quando si chiude il programma. A questo punto, Aladino dice al genio, "Tu non sei pi necessario puoi
tornare nella lampada!" e il genio foglio rientra di nuovo nella lampada.
Ora vediamo come funziona tra Aladino e il genio Joomla. Iniziamo il processo caricando l'URL per la
nostra home page nel nostro browser. Aladino vede questo e strofina la lampada. Il genio Joomla appare
e risponde al comando di Aladdin, "Visualizza l URL! " Il genio esegue la sua magia e la nostra home page
compare nel browser. Tuttavia, dal momento che il genio Joomla fa un solo comando alla volta, scompare
immediatamente nella lampada! Ora clicchiamo una voce di menu in home page per visualizzare un articolo.
Aladino deve strofinare la lampada una seconda volta, e daccapo il genio appare. Aladino comanda di,
"Caricare lArticolo!" Il genio carica la nuova pagina nel browser e poi subito rientra nella lampada.
33
Questo processo continua fino alla fine fino a quando cio non chiudiamo il browser o terminiamo la
navigazione del sito Joomla. A quel punto quindi, Aladino quindi non deve fare nulla, dato che il genio
gi nella lampada. Questo fatto molto importante. Con la programmazione web, non possiamo fare
affidamento sull'utente affinch chiuda bene il programma. Fortunatamente, non ne abbiamo bisogno. Con
un programma web come Joomla, ogni volta che si fa clic su un link o un pulsante di invio di un form , si
avvia quello che noi chiamiamo un nuovo ciclo di richiesta o di comando.
Quindi la richiesta di un URL, i dati di un form ed ogni ulteriore azione/dato relazionati alla richiesta
dellutente vengono pacchettizati dal browser ed inviati al server web.
Con Joomla (o qualsiasi altro programma web), nulla memorizzato nella memoria del computer tra i vari
cicli di richiesta del client verso il server. Ogni ciclo deve ricominciare daccapo a creare tutti gli oggetti del
programma. Il genio Joomla inizia da zero ogni volta. Detto questo, come fa il genio Joomla a ricordare
le informazioni importanti da un ciclo di richiesta al successivo? Ad esempio, il genio ha bisogno di
sapere chi l'utente cos da poter controllare le azioni che lo stesso utente autorizzato a fare. Se la
memoria del genio parte ogni volta dall'inizio di ogni ciclo, come pu fare questo?
Abbiamo diversi modi per memorizzare i dati di tutti i cicli. Quello pi comune la variabile di
sessione. Questa mantenuta sul server ed specifica per l'utente per quella sessione. Viene memorizzata
sul disco del server ed disponibile a Joomla. Normalmente, il file di sessione viene
automaticamente cancellato o disattivato dopo un periodo di inattivit dellutente (per esempio, 15 minuti).
Dalla sessione, ad esempio, il genio Joomla pu identificare lutente corrente senza richiedere allo stesso
che si autentichi ad ogni click. Si pu anche "ricordare", dove l'utente era nel ciclo di comando e le
opzioni che l'utente potrebbe aver inserito in un form. Il database un altro modo per salvare le
informazioni tra un ciclo di comando ed il successivo. Esso viene aggiornato quando lutente apporta
modifiche al sito come per esempio, aggiungendo articoli o altri elementi, o cambiando il proprio
profilo utente. Quando si riaccede al database i cicli futuri, vedranno le informazioni aggiornate.
Utilizzando la sessione e il database si permette a Joomla di trovare le informazioni necessarie dai precedenti
cicli di comando. Tuttavia, importante tenere presente che ogni richiesta di ciclo deve avere una propria
vita.
Programmare JOOMLA guida pratica
Pag. 34
Autore: Gianpiero Fasulo
CONTROLLARE I COMANDI
C' un'altra differenza tra questi due tipi di programmazione che importante per la sicurezza. Con
un programma desktop, tutte i possibili comandi sono tipicamente predefiniti nel programma. I comandi
sono di solito inviati tramite un clic del mouse. Anche se i comandi possono essere digitati direttamente,
sono normalmente convalidati rispetto a un elenco fisso di comandi possibili e mostrano un messaggio di
errore se il comando non valido. Con un programma web come Joomla, abbiamo due problematiche
che un programma desktop normalmente non ha.
Prima di tutto, stiamo esponendo il nostro sito a tutto il mondo online, che comprende, purtroppo, anche
persone con cattive intenzioni. Dobbiamo quindi aspettarci che qualcuno cercher di introdursi nel nostro
sito web, per cercare ad es. di rubare la nostra password di amministrazione, per deturpare il sito (
magari mettendo un proprio file al posto di uno dei nostri ), oppure cercare di bloccare il sito modificando il
database. Abbiamo quindi bisogno di pratica di programmazione difensiva per difenderci da queste
situazioni.
La seconda sfida che non possiamo controllare o limitare i comandi che un utente esegue come parte
della richiesta. Normalmente, il comando sar una combinazione di un URL e, eventualmente di alcuni
valori di campo da un modulo HTML. La maggior parte degli utenti immettono i comandi
semplicemente facendo clic su un link o un pulsante di invio form. possibile, tuttavia, che un utente
abbia deliberatamente immesso un comando per cercare di fare qualcosa che non dovrebbe fare, ad
esempio, digitando manualmente un URL o tentando di alterare un form HTML all'interno del
loro browser. Purtroppo, non c' modo per il web server di capire se un utente ha fatto clic su un link
o inserito manualmente un URL. Allo stesso modo, non vi alcun modo per capire se un utente ha
semplicemente compilato un form e cliccato su invia o se ha modificato volontariamente il modulo per
inviare dati dannosi. Per essere sicuri che questo non accada, dobbiamo sempre pensare che i comandi in
arrivo con la richiesta dellutente possano essere progettati per attaccare o violare il sito e noi dobbiamo
esaminarli prima di eseguirli. Parleremo di pi sulla sicurezza e la programmazione difensiva pi avanti nel
libro. Tuttavia, loggetto abbastanza importante da giustificarne un esempio adesso.
Diciamo che abbiamo un semplice sistema di commenti in cui gli utenti possono inserire commenti agli
articoli. Non permetteremo a nessuno di inviare un commento, ma lo consentiremo solo agli utenti
autorizzati di inserirli. Un commento poi non verr visualizzato sul sito se non stato precedentemente
approvato, in modo da proteggere commenti inappropriati. In questo esempio, abbiamo quindi due campi:
il commento e se approvato o meno. Potremmo implementare questa situazione come segue. Quando si
visualizza il form, controlliamo se un utente autorizzato o meno. Se lo , mostriamo il form con in pi il
campo approva. Quindi prima di mostrare il modulo, si controlla se l'utente corrente autorizzato a
approvare i commenti. Se non autorizzato, dobbiamo semplicemente omettere il campo Approvato sul
35
form e mostrare solo il campo Commento. Cos gli utenti non autorizzati non vedranno mai il campo
Approvato e quindi non saranno in grado di selezionare la casella. Ora si potrebbe pensare che con questo
metodo abbiamo impedito agli utenti non autorizzati lapprovazione commenti. Ma non cos. Qualcuno
con la conoscenza sul come opera un form di applicazione web, potrebbe facilmente utilizzare un
programma come Firebug o Web Developer per modificare il codice HTML nella pagina per aggiungere il
campo mancante Approvato e impostarne il valore a Approvato. Poi, quando il modulo viene inviato, il
commento verrebbe approvato come se l'utente fosse stato autorizzato. Il server web non sa se il modulo
stato modificato prima dellinvio. Si vede solo arrivare i dati del modulo nella richiesta di informazioni.
Quindi questo metodo ha un buco di sicurezza molto grave. Come possiamo risolvere il problema? Un
modo potrebbe essere quello di aggiungere un controllo prima che il database venga aggiornato. In questo
esempio quindi, prima di aggiornare il database dovremmo verificare che l'utente sia autorizzato ad
approvare i commenti. In caso contrario, bisognerebbe sempre impostare il campo approvato a no e
quindi salvare il dati. In questo modo, anche se un utente non autorizzato aggiunge il campo approvato al
form, i dati non validi non verranno salvati nel database, in modo che nessun danno sar fatto.
JOOMLA IN PRATICA
Dopo tanta teoria passiamo alla partica
Joomla conosciuto dalla maggior parte delle persone come un CMS (Content Management System) ma
JOOMLA anche una piattaforma di sviluppo di software.
Questo E-Book non si occuper di spiegarvi come si installa un web server e tutto quanto serve per
lesecuzione di un sito basato su JOOMLA. Questo libro nasce per chi gi ha le nozioni di base di sviluppo
e di installazione di JOOMLA e copre in modo diretto quelle problematiche poco conosciute riguardo lo
sviluppo di Componenti, Moduli, Plugin e Template di JOOMLA.
Per cui, iniziamo subito a lavorare.
Dopo aver scompattato il pacchetto JOOMLA, andiamo subito ad aprire il file index.php nella root del
sito, vedremo richiamato allinterno la funzione getApplication di JFactory questa funzione richiama
lapplicazione che deve essere eseguita attraverso il parametro tra le parentesi per cui avendo aperto il file
index.php della root troveremo che tale parametro sar valorizzato con la parola site che indica a Joomla
che siamo nel front end del sito.
Se invece apriamo lo stesso file index.php ma della cartella Adminsitrator, vedremo che il parametro
passato alla funzione getApplication Administrator questo indica a JOOMLA che siamo nel back
end del sito.
Allo stresso modo troviamo un ulteriore index.php nella cartella Installation anche qui troviamo
richiamata la funzione getApplication ma anche qui con una differenza nel parametro passato infatti qui
Programmare JOOMLA guida pratica
Pag. 36
Autore: Gianpiero Fasulo
troviamo installation come parametro. Questo index.php serve a JOOMLA per installare il CMS per la
prima volta e conviene rimuoverla dopo aver installato JOOMLA per una questione di sicurezza.
JOOMLA per come fatto non permette di modificare direttamente i file del suo core per cui per poter
programmare JOOMLA sono state messe a disposizione diversi tipi di estensioni programmabili dagli
sviluppatori.
La prima tra le estensioni sono i componenti i componenti costituiscono il centro della pagina del sito
solo un componente per volta pu essere caricato ed eseguito in JOOMLA, i componenti sono le estensioni
pi complesse di Joomla e sono quelle che spesso leggono e scrivono dati nel database, un componente
tipico di Joomla il componente content/documenti
Altro tipo di estensione possibile in Joomla il Template il template quel tipo di estensione che si
occupa di creare il Layout del sito e quindi la sua visualizzazione grafica. E possibile caricare un solo
template per pagina questo per permette di caricare diversi template per diverse pagine del nostro sito.
Abbiamo poi come estensioni i moduli possiamo caricare diversi moduli tutti insieme nel nostro sito
Joomla e possiamo posizionarli in diversi modi nel nostro sito a seconda delle posizioni definite nel
template,
Poi abbiamo i plugins i plugins si trovano nella cartella plugins ed operano su certe situazioni allinterno
dei componenti. Ad es. si pu creare un plugin che va a modificare laspetto del testo di una particolare
stringa di testo facendola diventare automaticamente un link di solito quindi svolgono funzioni particolari.
Infine abbiamo i linguaggi, i file di linguaggio servono a Joomla per tradurre gli user interface elements
cio quelle parti del sito comuni a tutto il portale, Joomla non traduce automaticamente i contenuti del sito.
COME JOOMLA ESEGUE IL CODICE
Di solito i programmatori di PhP creano una singola pagina che richiama tutto il codice al suo interno,
Joomla invece esegue ogni singolo modulo e componente separatamente.
La prima cosa che fa Joomla esegue il componente il pi utilizzato per default in Joomla il componente
content/documenti Joomla quindi va a cercare nellalbero delle directory allinterno della cartella che nel
nostro esempio com_content la cartella view e nel caso di visualizzazione di un singolo articolo
scende nella cartella article e poi nella cartella tmpl va a caricare il file default.php ( che il file di
markup del componente in questione ).
Dopo aver fatto ci Joomla carica i moduli attivi per il nostro sito, ed anche in questo caso Joomla scende
nella directory del modulo ad es. per il modulo login mod_login e poi carica nella cartella tmpl un
ulteriore file default.php che come per il componente si occupa del markup ( visualizzazione ) del
modulo.
37
Infine Joomla carica il Template attivo per il sito ad es. se avessimo scelto il template Atomic joomla
cercher nella cartella template la cartella atomic e al suo interno il file index.php che si preoccupa di
posizionare tutti i moduli nel giusto posto e carica gli ulteriori Javascript e CSS
Una volta eseguiti tutti questi step Joomla mette tutto insieme e alla fine del file index.php della root tramite
la variabile $app visualizza il tutto.
Scaricate subito tutti i sorgenti che ci serviranno durante tutta la lettura del libro.
Andate quindi a questo indirizzo www.gfasulo.it/Joomla_Pratico/ scaricate e scompattate larchivio in una
cartella del vostro computer.
INSTALLIAMO UN MODULO E ANALIZZIAMOLO
Iniziamo col prendere il nostro primo file di esempio mod_explore.zip nella sotto cartella
Installiamo_un_modulo_e_analizziamolo e carichiamolo dal nostro back end decidiamo una
posizione ed attiviamolo.
Una volta fatto ci andiamo ad analizzare il codice ed i file caricati. Entriamo nella cartella modules e poi
apriamo la nostra mod_explore partendo dalla root del nostro backend allinterno troviamo i file che sono
stati installati nel momento in cui abbiamo installato il modulo.
Troviamo il file index.html che sempre vuoto e deve esistere per una questione di compatibilit con i
maggiori web server. Troviamo poi il file mod_explore.xml che il file pi importante per Joomla in
quanto viene usato dallo stesso JOOMLA quando va ad installare un modulo, allinterno troviamo molte
informazioni come ad es. il nome del modulo, lautore e molte altre descrizioni. Molto importante invece
la parte del file XML sotto i TAG dove vengono specificati i file da caricare in fase di installazione
del modulo e di quale file PhP Joomla deve eseguire quando carica il modulo.
Programmare JOOMLA guida pratica
Pag. 38
Autore: Gianpiero Fasulo
Eccovi di seguito il codice del file mod_explore.xml.
Explore Activities
Explore California
April 2011
Copyright (C)2011 Explore California
GNU General Public License version 2 or later
www.explorecalifornia.org
1.0
A module listing all of the activities in the Explore California guide
mod_explore.php
index.html
mod_explore.xml
Ecco invece il contenuto del file PhP mod_explore.php che fa una semplice echo
getQuery(true);
in questo modo impostando il parametro true joomla crea un oggetto query vuoto e questo una cosa da
non dimenticare mai quando si vogliono eseguire delle query perch ci assicura di svuotare una eventuale
query effettuata in precedenza casomai da un altro modulo.
A questo punto quindi possiamo scrivere il nostro statement SQL nel seguente modo:
$query->select('activity_name')
->from('#__explore_activities');
Dove activity_name il nome campo e #__explore_activities il nome tabella, da notare #__ come
prefisso ( prefix ) al nome della tabella, questo altro non se non un alias creato a livello di database, questo
prefix ci viene chiesto in fase di installazione di Joomla.
Fatto ci possiamo far eseguire la query tramite il comando:
$db->setQuery($query);
Programmare JOOMLA guida pratica
Pag. 48
Autore: Gianpiero Fasulo
questo fa si che ci venga restituito un array contenente i valori di risultato della query e per renderli
disponibili poi a Joomla li richiamiamo tramite la funzione loadObjectList() e li assegniamo alla variabile
per es. $rows nel seguente modo:
$rows = $db->loadObjectList();
a questo punto quindi non ci resta che prendere i dati con un ciclo foreach per visualizzarli:
Adesso create e caricate i dati di esempio col file SQL Crea_tab_explore_activities.sql che trovate nella
cartella SQL in modo da avere dati da visualizzare
Eccovi tutto il codice sopra spiegato nel file mod_explore.php per intero:
49
CONFIGURARE NEI MODULI DEL BACK END I
PARAMETRI
La configurazione di un modulo dal lato back end viene fatta in Joomla senza dover creare codice PhP ad
hoc. Quando apriamo un modulo dal lato amministrativo del nostro sito Joomla ( back end ) notiamo su
alcuni moduli nella parte in alto a destra dello stesso, dei parametri modulo questi, sono parametri che
vengono definiti a livello di codice Joomla nel file XML del modulo nella sezione vediamo un
esempio di file XML per comprenderne meglio il come si possa aggiungere un parametro al nostro modulo.
Vediamo di comprenderne il significato.
Dopo il primo tag config, abbiamo un tag fields che tramite il parametro name indica a Joomla che
vogliamo creare un parametro nel nostro modulo, abbiamo poi il tag fieldset che ha come parametro
name=basic ( ci sono diversi tipi di name fieldset ma li vedremo pi avanti ) per ora lasciamolo cos. Nel
tag field di seguito nel file, andiamo a definire tutte le caratteristiche del parametro/campo che stiamo
creando come ad es. il nome, il tipo il valore di default ed altri
Fatto questo, per poter richiamare e quindi visualizzare questo nuovo parametro nel nostro modulo lato
back end basta aprire il file mod_explore.php aggiungendogli la riga:
echo $params->get(message) [dove message il nome del campo creato]
in questo modo avremo configurato il nostro nuovo parametro nel nostro modulo explore.
Programmare JOOMLA guida pratica
Pag. 50
Autore: Gianpiero Fasulo
Quindi il nostro file mod_expore.php appena visto diventer ( ricoprite lintero contenuto ):
Avremo quindi lato front end la visualizzazione del valore inserito nel parametro creato, logicamente
affinch venga visualizzato un valore, dal back end dobbiamo aprire il modulo e inserire qualcosa nel
campo message che troveremo nelle opzioni del nostro modulo explore dal lato admin.
51
GLI STILI
Come possibile aggiungere parametri ai moduli, altres possibile applicare diversi layout grafici che al loro
variare, visualizzano in modo diverso loutput del nostro modulo.
Anche gli stili come i parametri sono definiti nel file XML per cui sempre nel nostro esempio, dovremo
aggiungere del codice al file mod_explore.xml.
Vediamo il codice da aggiungere
Plain List
Ordered List
Paragraphs
Come si pu notare abbiamo aggiunto un ulteriore sezione del campo field ( aggiunto sotto il TAG padre
fieldset ),
Programmare JOOMLA guida pratica
Pag. 52
Autore: Gianpiero Fasulo
La prima cosa da notare che questo nuovo tag field ha come valore del parametro name, il valore
layout diversamente da quello subito sopra ( name=message ) come anche il valore del campo type
list nel secondo caso ed anche questo diverso da text del primo TAG field, questo perch non
vogliamo che lamministratore del sito possa inserire del testo libero ma deve solo poter scegliere da una
serie di valori presenti nel nostro campo, altra differenza che in questo nuovo TAG field abbiamo definito
anche il suo valore di default in modo che anche se lAdmin non scegliesse nulla verrebbe comunque
utilizzato il valore di default per il layout scelto, la label invece da una piccola descrizione del nostro
campo in modo da dare un piccolo aiuto allAdmin, infine abbiamo le tre opzioni possibili da scegliere per il
layout, Plain List, Ordered List e Paragraphs, il layout di default sar Plain List.
A questo punto affinch il tutto funzioni, dobbiamo creare la cartella col nome tmpl allinterno della
cartella del nostro modulo mod_explore e allinterno di essa tre file PhP che guarda caso avranno nome
identico ai valori passati dalle option del nostro file XML quindi i file da creare avranno nome
default.php ordered.php e paragraphs.php , creiamo per primo il file default.php:
Come potete vedere, questo file altro non che quello che avevamo gi prima come layout del nostro
modulo ( ecco perch lo abbiamo utilizzato come default ) da notare in testa al file la riga defined(
'_JEXEC' ) or die, questa riga evita il richiamo diretto del file PHP da un URL questo perch essendo
questo un file PhP non vogliamo che venga eseguito se non allinterno di JOOMLA, cosa che controlliamo
appunto con questa riga di codice.
53
Vediamo adesso cosa mettere nel file ordered.php:
Noterete che i due file sono pressoch identici tranne per il TAG HTML
nel
secondo, questo perch vogliamo che cambi solo la visualizzazione del modulo nullaltro.
Intuibile quindi il contenuto del terzo file paragraph.php:
A questo punto ci resta una ulteriore modifica da fare nel file mod_explore.php del nostro modulo
mod_explore dobbiamo aggiungere prima della echo la seguente riga:
require JModuleHelper::getLayoutPath('mod_explore', $params->get('layout'));
questo permette di richiamare il parametro layout attraverso la chiamata a JModuleHelper che rende
possibile la scelta del layout allinterno del nostro modulo.
Programmare JOOMLA guida pratica
Pag. 54
Autore: Gianpiero Fasulo
Quindi nel file andremo a sostituire il codice che visualizzava il nostro modulo sempre allo stesso modo con
il seguente:
Come potete vedere, abbiamo solo aggiunto il tag HTML
Fatto questo, andiamo nella cartella template del nostro Joomla e allinterno della cartella del template
utilizzato dal nostro Joomla, creiamo se non esiste gi, la cartella html allinterno di questa, una ulteriore
cartella nominandola mod_explore ( che ricordiamo sempre il nome del nostro modulo )
A questo punto non ci resta che copiare il file default.php appena creato allinterno di questa cartella. A
questo punto basta fare un refresh della pagina del nostro sito e vedere che il mark-up del nostro modulo
cambiato ed cambiato nel solo titolo in quanto il nostro codice HTML ha aggiunto solo il tag al
titolo del modulo ( vedete il codice sopra ). Tutto ci per farvi comprendere che per modificare un layout
non c bisogno di toccare il codice sorgente del modulo di Joomla ma semplicemente creare quanto
abbiamo appena fatto noi.
57
DEFINIAMO LACRONIMO MVC
Joomla usa il design Patterns per la consistenza e la riusabilit del codice.
Molto del codice che scriviamo per la costruzione di un modulo il Joomla usa lMVC design parent.
Abbiamo dato una definizione molto breve dellMVC ma andiamo a vedere cosa lMVC e perch lo si
utilizza in Joomla.
L MVC il Model View Controller, design parent non un parte di codice specifico ma un metodo per
organizzare il codice in modo da poterlo riutilizzare facilmente.
Il Design Patterns sono design che permettono praticamente di fare tutto quanto appena detto parent
perch ogni parte del nostro codice creato in Joomla ha un suo Patterns ed completamente
indipendente da tutto il resto del codice. I Patterns permettono di organizzare il codice in modo
interscambiabile ed in tanti piccoli pezzi semplificando ogni singola parte del codice.
Programmare JOOMLA guida pratica
Pag. 58
Autore: Gianpiero Fasulo
FUNZIONAMENTO DELLMVC
LMVC divide lapplicazione in tre task primari.
Il primo task per il controller quello di ricevere linput dellutente e di dire al view ed al model cosa
devono fare. Dopo aver ricevuto linput dellutente il model si occuper di processare ogni singolo dato
come ad esempio processare query al database. Il suo compito quindi solo quello di processare i dati e
di renderli pronti per il database o per le view, infine il view si occuper della visualizzazione vera e
propria delloutput senza includere codice che si preoccupi di processare i dati.
Di solito per siamo abituati a scrivere o vedere script php che hanno al loro interno una lunga serie di
comandi che effettuano tutte e tre queste operazioni in un solo file, questo rende difficile la manutenzione
dello stesso e spesso ci causa anche problemi di bug difficili poi da risolvere.
Ma vediamo un esempio di codice di come funziona lMVC
Di seguito il contenuto del file controller
Possiamo vedere qindi che abbiamo richiamato direttamente la nostra variabile precedentemente definite ed
assegnata nel nostro file view.html.php
Non ci resta che visualizzare la nostra view tours per controllare loutput generato dalla views. Noterete la
visualizzazione della stringa California Tours.
Abbiamo quindi fatto questo bel escursus per comprendere quanto sia importante tenere separate le tre
componenti fondamentali dello sviluppo di applicazioni PhP.
Programmare JOOMLA guida pratica
Pag. 68
Autore: Gianpiero Fasulo
IL MODEL DATA
Il model il componente MVC che processa i dati, questo di solito il metodo utilizzato ma non
esclusivo per accedere ai dati del database.
Vediamo adesso il come utilizzando il model possiamo prendere i dati dal database e passarli alla view.
Creiamo una cartella models allinterno del nostro componente com_explore e allinterno di essa
creiamo un file php chiamandolo tours.php con dentro il seguente codice:
Programmare JOOMLA guida pratica
Pag. 70
Autore: Gianpiero Fasulo
Fatto ci richiamiamo la URL della view del tour
index.php?option=com_explore&view=tours
Vedremo che oltre allheader ( gi visualizzato in precedenza ) saranno presenti in una lista ordinata di tutti i
tour pubblicati. Questo ci deve essere da stimolo per la facile comprensione di come possibile poi
modificare la vista delle pagine senza andare a toccare il codice di accesso al database evitando cos probabili
errori.
71
VISUALIZZARE UN SINGOLO RECORD
In molti componenti Joomla, vediamo spesso la visualizzazione di un singolo record ricercato attraverso la
scelta effettuata da un utente del sito in base a chiavi di ricerca ben definite. Vediamo come sia possibile
realizzare e quindi si visualizzare un singolo record in Joomla.
Per prima cosa quindi creiamo una cartella nominata tables nel nostro back end ( quindi in
administrator/components/com_explore ) ed anche allinterno di quella principale del sito dove
installato il nostro componente com_explore. Notate quindi che questa cartella viene creata nel back
end del sito e non nel front end questo perch nello standard di Joomla le classi richiamate in questi casi
vengono lette dal front end attraverso il back end.
Allinterno quindi della cartella appena creata, creiamo un nuovo file PhP e lo nominiamo activity.php e
scriviamoci dentro il codice seguente:
Programmare JOOMLA guida pratica
Pag. 74
Autore: Gianpiero Fasulo
Notate come nella view andiamo a leggere due dei dati del nostro record ritornatoci dal Model e cio
lactivity_name e lactivity_description. Vediamo adesso in pratica la visualizzazione del nostro record
richiamando la view attraverso la URL.
index.php?option=com_explore&view=activity&id=1
Con questa URL diciamo a Joomla di voler vedere il record numero 1 della view activity del
componente com_explore.
Quindi riepilogando, quello che abbiamo fatto non stato altro che definire una JTable class, fare in modo
che il model la carichi/legga e ritorni i dati alla view che visualizza i dati attraverso loutput HTML del
suo file default.php.
Di seguito lo schema logico da tener bene a mente.
1) Estendere la classe JTable come fatto nel nostro file dal backend
administrator/components/com_explore/tables/activity.php
2) Creare il nuovo model dal forntend e quindi nel file
components/com_explore/models/activity.php
3) Creare poi la nuova view andanola a definire nel file
components/com_explore/views/activity.php
4) Ed infine creare il template di visualizzazione con il file creato in
components/com_explore/views/activity/tmpl/default.php.
75
VISUALIZZAZIONE COMPLESSA DI UN RECORD
Altrettanto spesso, succede che si voglia visualizzare una serie di records casomai in modo pi complesso
mettendo anche in unione ( Join ) due o pi tabelle.
Come al solito non perdiamoci danimo e mettiamoci subito al lavoro.
Nella cartella model del nostro componente dal lato front end andiamo a creare un nuovo file
nominandolo tour.php e scriviamogli dentro questo codice:
$
Vedete che in questo caso abbiamo gi che il tour_name e l activity_name sono parte del risultato
della nostra Join, come del resto gli altri campi riguardanti il tour.
Per visualizzare il nostro risultato e controllare che tutto sia ok non ci resta che lanciare la nostra URL
seguente:
index.php?option=com_explore&view=tour&id=1
Programmare JOOMLA guida pratica
Pag. 78
Autore: Gianpiero Fasulo
79
VISUALIZZARE RECORD DA DVERSE
TABELLE/DATASET
Pu a volte essere utile visualizzare record provenienti da diverse tabelle, allinterno di un'unica view.
Andremo infatti a vedere come visualizzare tutti i tours di una specifica attivit e di come per ogni tour si
possa poi entrare nel dettaglio. Avremo quindi una view che visualizzer un riassunto dei tour e un link che
ci porter nel dettaglio di ogni tour quindi accedendo alle info delle attivit nella prima fase e a quelle dei
tours una volta cliccato sul nome del tour.
Come al solito mettiamoci subito al lavoro.
Intuirete a questo punto che la prima cosa da fare creare il model per cui andremo ad aggiungere al
nostro file model/activity.php il seguente codice:
public function getTours()
{
$activity_id = JRequest::getInt('id');
$db = $this->getDbo();
$query = $db->getQuery(true);
$query->select('tour_name, tour_id, tour_location, tour_teaser');
$query->from('#__explore_tours');
$query->where("activity_id = '{$activity_id}'");
$db->setQuery($query);
$rows = $db->loadObjectList();
return $rows;
}
Noterete che lactivity_id gi stato assegnato nella funzione getItem ma in questo caso ci server per
poi utilizzarlo nella nostra Query custom questo perch vogliamo visualizzare tutti i tours che fanno
parte di quella attivit. Ci creiamo quindi i due oggetti per avere un oggetto $db e uno $query,
completamente vuoti ( come gi spiegato dobbiamo sempre essere sicuri di eseguire la nostra query e non
Programmare JOOMLA guida pratica
Pag. 80
Autore: Gianpiero Fasulo
altre ) di seguito vedete quindi la query che estrae dalla tabella #__exlpore_tours i quattro campi che
vogliamo, salviamo loggetto query ( $db->setQuery ) e ritorniamo lintero recordset alla funzione attraverso
il richiamo di loadObjectList(); che ritorna un oggetto di tipo array in modo che possiamo ciclare sul
risultato per visionare tutti i record.
A questo punto dobbiamo aggiornare anche la view affinch possa visualizzare quanto elaborato dal
model.
Andiamo quindi per primo a modificare il file view/activity/view.html.php ed aggiungiamo il seguente
codice evidenziato in grassetto:
class ExploreViewActivity extends JView
{
protected $item;
protected $tours;
public function display($tpl = null)
{
$this->item = $this->get('Item');
$this->tours = $this->get('Tours');
parent::display($tpl);
}
}
81
Andiamo quindi a modificare lultimo file interessato che quello che troviamo nella cartella
view/activity/tmpl/default.php e anche qui effettuiamo le nostre modifiche solo che in questo caso
dato che vogliamo modificare lintera view pi che modificare andremo a sostituire lintero contenuto del
file default.php con il codice seguente:
item = $this->get('Item');
$this->form = $this->get('Form');
aggiungete poi la propriet $form inserendo subito in testa alla classe la variabile $form come di seguito...
class ExploreViewActivity extends JView { protected $item; protected $form;
e adesso passiamo al layout.
129
Aprite il file views/activity/tmpl/edit.php e copiateci dentro questo div subito dopo il tag di apertura del
form:
noterete la classe class="width-60 fltlft" questa dice al Joomla con il primo parametro che il div deve
occupare il 60% dello schermo, e il secondo che deve essere allineato a sinistra.
Subito dopo cicliamo con un foreach, tutti i fieldset esistenti nel form che ci vengono ritornati come oggetti,
quindi esponiamo il campo label e input.
Se adesso facciamo il refresh della nostra pagina dal back end e clicchiamo sul pulsante aggiungi vedremo il
nostro form.
Programmare JOOMLA guida pratica
Pag. 130
Autore: Gianpiero Fasulo
LEGERE DATI CON JFORM
JFORM anche utile per la visualizzazione e soprattuto l'editing dei record. Al momento il nostro
componente non permette di editare correttamente i records infatti se andiamo a vedere dal nostro
backend un qualsiasi record e gli clicciamo sopra, noteremo come il form che ci si presenta privo di dati,
dobbiamo quindi implementare nel nostro modulo una funzione per la visualizzazione dei dati.
Per far ci quindi dobbiamo editare il file administrator/com_explore/models/activity.php e aggiungere
la seguente funzione:
protected function loadFormData()
{
$data = JFactory::getApplication()->getUserState('com_explore.edit.activity.data', array());
if (empty($data)) {
$data = $this->getItem();
}
return $data;
}
la riga che valorizza $data importante in quanto noi qui andiamo a leggere i dati della sessione e in base a
ci poi possiamo comprendere se dobbiamo leggere i dati dal database oppure se un inserimento di un
nuovo record nel caso non esistano dati nella sessione.
A questo punto non ci resta che rileggere la pagina di editazione del record e vedremo che tutti i campi sono
avvalorati correttamente.
Se proviamo ad inserire un nuovo record lasciano uno dei campi obbligatori vuoti vedremo che saremo
ridirezionati daccapo al form nel quale ci verr richiesto di riempire i campi obbligatori. Ci avviene perch
nella sessione mancano dei dati per l'inserimento corretto del record. Ecco il perch quindi abbiamo testato
che nella sessione non ci siano tutti i dati che servono poi per la insert e in base a ci quindi riusciamo a
capire se un record da editare e quindi di conseguenza leggere i dati dal DB oppure no e controllare che
tutti i campi siano compilati correttamente.
131
DIVIDERE IL LAYOUT DEL FORM IN DUE PARTI CON
JFORM
Pu spesso risultare comodo anche visivamente, dividere il form di input di due parti mettendo ad esempio
i campi obbligatori sulla sinistra del form e quelli opzionali sulla destra.
Ritornando al nostro esempio quindi vediamo come spostare il campo Immagine/Foto dalla sua posizione
in basso a sinistra a quella subito a destra.
Vediamo subito come fare....
Andiamo ad editare il file administrator/com_explore/models/forms/activity.xml vediamo dentro, che al
momento abbiamo un solo TAG FIELDSET che contiene tutto.
Allora per prima cosa andiamo a tagliare la parte del campo che vogliamo spostare creando un nuovo
TAG FIELDSET e lo compiamo dentro di esso.
A questo punto nominiamo il primo tag FIELDSET con name=essential e questo nostro nuovo appena
creato con name=optional.
Alla fine dovremmo avere il nuovo XML in questo modo:
mentre al primo DIV andiamo a inserirne il nome nel getFieldset
Dovreste trovarvi con questo codice:
133
comprendete che in questo modo i due DIV vanno a prendere i Fieldset corrispondenti.
Andiamo adesso ad inserire un nuovo record e vedremo che il form diviso in due parti sulla sinistra i
campi che avevamo gi prima mentre sulla destra stato spostato il nostro campo per la immagini.
Programmare JOOMLA guida pratica
Pag. 134
Autore: Gianpiero Fasulo
Gli elementi di JFORMS
Pu altres capitare di voler aggiungere ulteriori elementi al form che esulano dagli altri, diciamo che sono
campi indipendenti.
Ritornando al nostro esempio base del nostro componente, andiamo nel backend e clicchiamo su
aggiungi vediamo il nostro form che chiede il nome, l'alias, lo status e la foto.
Andiamo quindi sul nostro file a modificare questa view per ralizzare quanto detto.
Apriamo quindi il file activity.xml che si trova sotto il nostro componente
com_explore/models/forms/activity.xmle andiamo ad aggiungerci dentro questo codice prima del
fieldset name optional:
da notare il parametro in grassetto che dice a Joomla di non eliminare i tag html cosa che joomla fa
di default.
andiamo quindi ad aggiungere il campo nella nostra view apriamo il file
com_explore/views/activity/tmpl/edit.php e aggiungiamo queste righe:
queste due righe andranno a farci visualizzare il campo description dei nostri record con la possibilit di
editarlo anche con l'editor html. Mettendone due copriamo l'eventuale problematica di visualizzazione
dell'editor che sia sulla destra o sulla sinistra del nostro form.
135
Se adesso andiamo a ricaricare un qualsiasi record e